Výrazy jazyka C#

Tip

Tento článek je součástí části Základy pro vývojáře, kteří už znají aspoň jeden programovací jazyk a učí se jazyk C#. Pokud s programováním teprve začínáte, začněte nejprve kurzy Začínáme .

Pochází z jiného jazyka? Výrazy v jazyce C# fungují stejně jako v Java, C++ a JavaScriptu. Jeden rozdíl stojí za zmínku: operátory složeného přiřazení jako += a operátor ++ přírůstku jsou výrazy v jazyce C#, takže se mohou objevit ve větších výrazech.

Výraz je část kódu, kterou kompilátor vyhodnotí, aby vytvořil hodnotu – číslo, řetězec, odkaz nebo bool. Je například 3 + 4 * 2 výraz, který se vyhodnotí jako celé číslo 11a total > 10 je výrazem, který se vyhodnotí jako true nebo false.

Nejjednodušší výrazy jsou literály (například 42 nebo "hello") a názvy proměnných (například total). Složitější výrazy vytvoříte kombinací jednodušších výrazů s operátory.

Výrazy a příkazy

Výraz vytvoří hodnotu. Příkaz je kompletní instrukce, kterou program provede. Mnoho příkazů obsahuje výrazy. Jedná se například int total = 3 + 4 * 2; o příkaz deklarace proměnné. Kompilátor vyhodnotí výraz 3 + 4 * 2inicializátoru , který vytvoří 11, a přiřadí danou hodnotu nové proměnné total.

Výraz si můžete představit jako frázi a příkaz jazyka C# , jako je úplná věta. Tyto pracovní definice vám pomůžou pochopit formální terminologii a vysvětlení, se kterými se seznámíte, když se dozvíte více o jazyce C#, i když běžné kódování zřídka vyžaduje, abyste si tento rozdíl uvědoměle zapamatoval.

Kombinování výrazů

Výrazy lze kombinovat. Zvažte 3 + 4 * 2. Tento jediný výraz ve skutečnosti obsahuje dva menší výrazy: 4 * 2 a výraz pro sčítání3 + <result>. Když se výrazy zkombinují, jazyk C# potřebuje pravidlo pro rozhodnutí, které z nich se má vyhodnotit jako první. Toto pravidlo je priorita operátorů.

Nemusíte si pamatovat úplnou hierarchii priority. Další část shrnuje běžné způsoby seskupování a závorky vám vždy umožní jednoznačně určit pořadí, když si nejste jistí.

Priorita operátorů

Priorita operátoru určuje, jak se kombinované výrazy seskupují do dílčích výrazů. Tento koncept je podobný pravidlům pořadí operací z matematické třídy. Operátor s vyšší prioritou se váže těsněji ke svým operandům. Výraz je uspořádán, jako by byly tyto operandy uzávorkovány dohromady. V 3 + 4 * 2 má * vyšší precedenci než +, takže se výraz seskupuje jako 3 + (4 * 2), nikoli (3 + 4) * 2.

C# má více skupin priorit než čtyři zde shrnuté. Tyto další skupiny vynucují známá pravidla – například násobení před sčítáním – a pokrývají kompletní sadu operátorů. Následující skupiny se týkají toho, co se nejčastěji setkáte v každodenním kódu:

  1. Primární, unární a rozsah – jedná se o tři odlišné skupiny priority, z nichž všechny jsou úzce svázané než aritmetické. Tento souhrn je kombinuje do jednoho kroku, protože pro praktické účely se všechny použijí před aritmetikou.
    • Primární operátory – přístup ke členům (x.y), volání metod (f()), indexování (a[i]) a přístup podmíněný hodnotou null (?., ?[]) – mají ze všech nejvyšší prioritu.
    • Unární operátory působí na jediný operand: negace (-x), logická negace (!flag), prefixová inkrementace (++i) a postfixová inkrementace (i++).
    • Operátor rozsahu (..) sestaví rozsahy indexů pro výrazy řezu, například array[1..4].
  2. Aritmetika — *, % a / mají vyšší prioritu než + a -. Násobení a dělení probíhá před sčítáním a odčítáním.
  3. Porovnání — <, >, <=, >=, ==, != mají nižší prioritu než aritmetické operace, takže se aritmetické operace provedou před porovnáním.
  4. Logické operátory — && a || mají ze všech běžných operátorů nejnižší prioritu, takže se porovnání vyhodnotí před logickou kombinací.

Toto pořadí vyhodnocování znamená, že se výraz score + bonus > threshold && attempts < maxAttempts vyhodnotí přesně tak, jak byste ho přečetli: sečtěte score a bonus, porovnejte součet s threshold, porovnejte attempts s maxAttempts a pak oba výsledky bool zkombinujte pomocí &&. Přidání závorek, aby každé seskupení explicitně zobrazovaly stejnou strukturu: ((score + bonus) > threshold) && (attempts < maxAttempts).

Úplnou hierarchii priorit zahrnující všechny operátory najdete v tématu Operátory a výrazy jazyka C#.

Použijte závorky, aby byl záměr jasný

Závorky změní prioritu vyhodnocování a zároveň vyjadřují váš záměr. Pokud pořadí není z výše uvedených skupin zřejmé, přidejte závorky:

int score = 80;
int bonus = 15;
int threshold = 90;
bool eligible = true;

// Without parentheses: || binds less tightly than &&, so this reads as:
//   eligible && (score + bonus > threshold) || bonus > 20
bool result1 = eligible && score + bonus > threshold || bonus > 20;

// With parentheses: forces the || to combine two complete conditions
bool result2 = (eligible && score + bonus > threshold) || bonus > 20;

Console.WriteLine(result1); // => True
Console.WriteLine(result2); // => True

// Parentheses can also change the result:
bool isAdmin = false;
bool isOwner = true;

// Without: && binds tighter, so: (isAdmin && isOwner) || true
bool access1 = isAdmin && isOwner || true;
// With: forces the || to run first
bool access2 = isAdmin && (isOwner || true);

Console.WriteLine(access1); // => True   (false && true is false; false || true is true)
Console.WriteLine(access2); // => False  (false && anything is false)

Poslední dva řádky ukazují, že závorky můžou změnit výsledek, nejen styl. Když se && a || vyskytují společně, přidejte závorky, abyste upřesnili, která podmínka se vyhodnotí jako první. Čtenář, který vidí (isAdmin && isOwner) || isSuperUser záměr okamžitě zná.

Jak se vyhodnocují výrazy

Pochopení toho, jak jazyk C# vyhodnocuje kombinované výrazy, je jednodušší pomocí analogie. Zamyslete se nad složitým matematickým problémem s tužkou a papírem: identifikujete nejvnitřnější nebo nejvyšší prioritu dílčího výrazu, vypočítáte jeho dočasnou hodnotu, zapíšete výsledek a pak zopakujete další dílčí výraz – pokračujete, dokud nedosáhnete konečné odpovědi.

Jazyk C# se řídí stejným procesem a řídí se dvěma pravidly:

Pravidlo 1: Operandy se vyhodnocují zleva doprava. U libovolného binárního výrazu musí být oba operandy plně vyhodnoceny, než se operátor použije. Jazyk C# nejprve vyhodnotí levý operand, poté pravý operand a pak provede operaci.

Pravidlo 2: Některé operátory používají zkrácené vyhodnocování. Některé operátory přestanou vyhodnocovat ihned po určení výsledku a přeskočí všechny zbývající operandy:

  • && (podmíněné AND): vrátí false, jakmile je levá strana false. Pravá strana se nikdy nevyhodnocuje.
  • || (podmíněné NEBO): vrátí true, jakmile levá strana nabude hodnoty true. Pravá strana se nikdy nevyhodnocuje.
  • ?: (podmíněný/ternární): vyhodnotí pouze větev, která odpovídá podmínce – druhá větev se nikdy nevyhodnotí.
  • ?. (podmíněný přístup ke členu při hodnotě null) a ?[] (podmíněný přístup k prvku při hodnotě null): zastaví se a okamžitě vrátí null, pokud má levá strana hodnotu null, přičemž přeskočí přístup ke členu nebo indexování.
  • ??= (přiřazení se slučováním hodnoty null): přiřadí pravou stranu pouze tehdy, když je levá strana null.

Vyhodnocení papíru a tužky

Zvažte výraz 3 + 6 / 2. I když se sčítání zobrazuje jako první v pořadí čtení, / má vyšší prioritu než +, takže 6 / 2 se jedná o dílčí výraz, který se vyhodnocuje jako první. Krok za krokem – přesně tak, jak byste to dělali na papíře:

3 + 6 / 2
      ↓   (evaluate 6 / 2 → 3)
3 +   3
  ↓   (evaluate 3 + 3 → 6)
  6

// 3 + 6 / 2
// Step 1: 6 / 2 has higher precedence → interim value 3
// Step 2: 3 + 3 → final result 6
int result = 3 + 6 / 2;
Console.WriteLine(result); // => 6

Dočasná hodnota 3, vytvořená pomocí +, se stane pravým operandem 6 a konečným výsledkem je 6 / 2. Každý dílčí výraz vytvoří dočasnou hodnotu; tyto dočasné hodnoty předají další dílčí výraz, dokud nezůstane pouze jedna hodnota.

Asociativita je související koncept: pokud mají dva operátory stejnou prioritu, asociativita rozhoduje, která z nich je první. Většina operátorů jazyka C# je levě asociativní, což znamená, že se seskupují zleva doprava. Takže a - b - c je to stejné jako (a - b) - c, ne a - (b - c).

Vyhodnocení krátkého okruhu v praxi

Vyhodnocení zkratového okruhu je zvlášť užitečné pro kontroly null:

string? text = null;

// Safe: second condition runs only when text is not null
bool hasContent = text != null && text.Length > 0;
Console.WriteLine(hasContent); // => False  (short-circuits after null check; no NullReferenceException)

text = "hello";
hasContent = text != null && text.Length > 0;
Console.WriteLine(hasContent); // => True

// || short-circuits on true: right side is never evaluated when left side is true
string word = "hello";
bool anyMatch = word.StartsWith("h") || word.StartsWith("x");
Console.WriteLine(anyMatch); // => True  (right side never evaluated)

// ?. short-circuits on null: returns null without accessing .Length
string? maybeNull = null;
int? length = maybeNull?.Length;   // length is null; no NullReferenceException
Console.WriteLine(length.HasValue); // => False

text != null && text.Length > 0 je bezpečný, protože druhá podmínka se spustí jenom tehdy, když text není null. Podobně ?. zastaví vyhodnocování, když narazí na referenci null, čímž se zabrání NullReferenceException bez explicitní kontroly if.

Širší pohled na operátory bezpečné s hodnotou null najdete v tématu Operátory null jazyka C#.

Viz také

  • Last updated on