Elágazások

Ha valamilyen feltételtől függően a programnak több lehetséges, egymástól különböző lefutása van, akkor úgy nevezett elágazást kell használnunk.

Vegyük a következő példát:

Console.WriteLine("A");
Console.WriteLine("B");

if (num == 5) // Ha igaz, hogy "num" változó értéke 5, ...
{       
		Console.WriteLine("C");       // ... végrehajtódik a kapcsos zárójelek közti részt.
		Console.WriteLine("D");       
}

Console.WriteLine("E");
Console.WriteLine("F");

// Unityben Debug.Log)

A példában bemutatott kód a megszokott módon fentről lefelé fut. Ám az if elágazásban lévő rész csak akkor fut le, ha num értéke 5. Ebben az esetben az A, B C, D, E és F is kiírásra kerül.

Ezzel szemben ha num érték mondjuk 6, akkor csak az A, B, E és F kerül kiírásra.

Egyágú elégazás: if szerkezet

If elágazáshoz mindig kell zárójelek közt egy feltételt megadni. Ez a feltétel mindig egy bool típusú kifejezés. A fenti elágazást tehát leírhatnánk így is:

bool condition = num == 5;
if (condition) {  ...  }

A fenti esetben egyágú elágazásról beszélünk. Ebben az esetben egy feltételtől függően vagy végrehajtunk egy kódrészletet vagy átugorjuk.

Kétágú elégazás: if-else szerkezet

Írhatunk kétágú elágazást is, ami esetében mindkét lehetőség (true/ false) esetén végrehajtóik egy kódrészlet, ami a másik ágban nem fut le.

bool isEven = num % 2 == 0;     //"num" páros-e?

if (isEven)                     // Ha num páros
{
    Console.WriteLine("Even");  // Akkor kiírjuk az "Even" (páros) szót.
}
else                            // Különban
{
    Console.WriteLine("Odd");   // Kiírjuk az "Odd" (páratlan) szót.
}

// Unityben Debug.Log() paranccsal tudnánk kiírni a konzolra.

Többágú elágazás: else-if szerkezet

Az if és else ágakat sorba lehet fűzni. Ezt nevezzük else-if szerkezetnek. Az alábbi szerkezetben egy háromágú elágazást írok.

if (num > 0)                        // Ha "num" nagyobb nullánál,
{
    Console.WriteLine"Positive");   // akkor kiírjuk az "Positive" (pozitív) szót.
}
else if(num < 0)                    // Ha ez nem igaz, de "num" kisebb nullánál,
{
    Console.WriteLine("Negative");  // kiírjuk az "Negative" (negatív) szót.
}
else                                // Ha ez sem igaz,
{
    Console.WriteLine("Zero");      // kiírjuk a "Zero" (nulla) szót.
}

// Unityben Debug.Log() paranccsal tudnánk kiírni a konzolra.

Ha csak egy utasítást hajtunk végre egy ágon belül a kapcsos zárójeleket elhagyhatjuk. Ezzel kevesebb sorból írhatjuk le ugyanazt.

A lenti példában egy 5 ágú elágazás írtam le zárójelek nélkül.

if (num > 100)                       // Ha "num" nagyobb, mint 100,
		Console.WriteLine("Very High");  // akkor kiírjuk, hogy "Very High" (nagyon magas).
else if(num > 50)                    // Egyébként ha "num" nagyobb, mint 50,
		Console.WriteLine("High");       // akkor kiírjuk, hogy "High" (magas).
else if(num > 20)                    // Egyébként ha "num" nagyobb, mint 20,
		Console.WriteLine("Medium");     // akkor kiírjuk, hogy "Medium" (közepes).
else if(num > 5)                     // Egyébként ha "num" nagyobb, mint 5,
		Console.WriteLine("Low");        // akkor kiírjuk, hogy "Low" (alacsony).
else                                 // Egyébként
		Console.WriteLine("Very Low");   // kiírjuk, hogy "Very Low" (nagyon alacsony).

// Unityben Debug.Log() paranccsal tudnánk kiírni a konzolra.

Létezik egy másik módja a többágú elágazásnak, a switch. Ezt itt most nem tanuljuk, de hosszabb távon érdemes lehet utánanézni.

Gyakran csak arra kell nekünk egy elágazás, hogy feltételtől függően értéket adjunk egy változónak. Ebben az esetben van egy egyszerűsített forma is.

Többágú elágazás másként: a switch szerkezet:

A switch egy alternatív formája a többágú elágazásnak, amikor nem bool típusú kifejezésektől, hanem egy változó különböző lehetséges értékeitől függ, hogy melyik szálat hajtjuk végre.

int remaider = someVariable % 5;

switch (remaider)   // A remaider változó értékétől függ, melyik szálat hajtjuk végre.
{
    case 1:                               // Ha remaider értéke 1
        Debug.Log("Reaminderis  1");   
        break;                            // Minden szál végére ki kell tenni a beak-et
    case 2:                               // Ha remaider értéke 2
        Debug.Log("Reaminder is 2");
        break;
    case 3:                               // Ha remaider értéke 3 vagy 4
    case 4:                               
        Debug.Log("Reaminder is 3 or 4");
        break;
    default:                              // Egyébként:
        Debug.Log("Reaminder: 0");        // A default szál opcionális.
        break;
}

A feltételes értékadás operátor

Nézzük a következő példát:

string text;

if (num % 2 == 0)     // Ha num páros,
		text ="Even";     // text értéke legyen "Even" (páros).
else                  // Különben,
		text = "Odd"      // text értéke legyen "Odd" (páratlan).

Mindez egy sorban is kifejezhető a feltételes értékadás operátorral: ?:

string text = num % 2 == 0 ? "Even" : "Odd";
// típus változónév  =  feltétel  ?  érték, ha a feltétel igaz  :   érték, ha nem igaz