Vezérlési szerkezetek¶

A vezérlési szerkezetek terén nagy szerencsénk van, ebben az esetben nincs különösebb eltérés a Pythonhoz képest, csak a blokkok jelölése az eltérő.

Matematikai kondíciók¶

Művelet	Jelölés	Operátor
Szigorúan nagyobb	\(>\)	`>`
Nagyobb egyenlő	\(\geq\)	`>=`
Kisebb	\(<\)	`<`
Kisebb egyenlő	\(\leq\)	`<=`
Egyenlőség	\(=\)	`==`
Nem egyenlő	\(\neq\)	`!=`
Típusos egyenlő	\(\equiv\)	`===`
Típusos nem egyenlő	\(\not\equiv\)	`!==`

Matematikai kondíciók igazságértéke¶

A matematikai kondíciók az általánosságban vett matematikai műveleteket jelentik. Ezek a műveletek minden esetben kiértékelődnek és egy igazságértéket fognak felvenni.

Vegyünk pár példát:

Állítás	Kiértékelés	Eredmény
\(5 > 3\)	Az 5 nagyobb mint a 3?	Igen, ez igaz.
\(5 < 3\)	Az 5 kisebb mint a 3?	Nem, ez hamis.
\(3 \geq 3\)	A 3 nagyobb vagy egyenlő mint 3?	Igen, ez igaz.
\(3 > 3\)	A 3 nagyobb mint a 3?	Nem, ez hamis.

Feltételezes vezérlés¶

Ha állítás¶

Feltétel szabása az if szóval történik, amely egy logikailag kiértékelhető állítást tartalmaz. A matematikai kondíciók eredménye logikai igaz vagy logikai hamis lesz.

let homerseklet = 17;

if (homerseklet > 20) {
    console.log("Nagy a forróság!");
}

A fenti példa esetében a console.log csak akkor fog lefutni ha az állítás értéke igaz, tehát a homerseklet nagyobb mint 20.

Vagy ha állítás¶

A vagy ha állítás előtt mindenképpen szükséges egy ha állítás.

let homerseklet = 17;

if (homerseklet > 20) {
    console.log("Nagy a forróság!");
} else if (homerseklet < 10) {
    console.log("Nagyon hideg van!");
}

Egyébként (else) állítás¶

Az else ágat akkor használjuk, ha az előző feltételek egyike sem teljesül.

let homerseklet = 17;

if (homerseklet > 20) {
    console.log("Nagy a forróság!");
} else if (homerseklet < 10) {
    console.log("Nagyon hideg van!");
} else {
    console.log("Az időjárás kellemes.");
}

Többszintű feltételek¶

Egymásba ágyazott feltételeket is létrehozhatunk.

let homerseklet = 17;
let paratartalom = 30;

if (homerseklet > 20) {
    if (paratartalom > 50) {
        console.log("Forró és párás az idő.");
    } else {
        console.log("Forró, de nem párás az idő.");
    }
} else {
    console.log("Nem forró az idő.");
}

Konnektívák¶

A logikai feladatok megoldásához a Boole-algebrát használjuk, amely lehetőséget ad arra, hogy a logikai kapcsolatokat matematikai úton kezeljük.

Kételemű Boole-algebra felvehető értékek:

false (0)
true (1)

ÉS¶

Abban az esetben ha kettő vagy több feltételnek egyszerre kell teljesülnie, akkor ÉS kötöszót használunk. Az ÉS csak akkor teljesül ha a bal oldal és jobb oldal is igaz.

JavaScriptJavaPython

let a = 5

if (a < 10 && a > 0) {
    console.log("Pozitív szám ami kisebb mint tíz!")
}

int a = 5

if (a < 10 && a > 0) {
    System.out.print("Pozitív szám ami kisebb mint tíz!")
}

a = 5

if a < 10 and a > 0:
    print("Pozitív szám ami kisebb mint tíz!")

VAGY¶

Abban az esetben, ha kettő vagy több feltétel közül legalább az egyiknek kell teljesülnie, akkor VAGY kötöszót használunk.

A vagy az alábbi esetekben értékelődik igazra: - a bal oldal igaz - a jobb oldal igaz - mindkét oldal igaz

JavaScriptJavaPython

let a = 5

if (a < 10 || a > 0) {
    console.log("Pozitív szám ami kisebb mint tíz!")
}

int a = 5

if (a < 10 || a > 20) {
    System.out.print("Pozitív szám ami kisebb mint tíz vagy nagyobb mint húsz!")
}

a = 5

if a < 10 or a > 20:
    print("Pozitív szám ami kisebb mint tíz vagy nagyobb mint húsz!")

Igazságtábla¶

Az igazságtábla egy táblázat, amelyben a logikai műveletek eredményeit mutatja be. Ezekben az esetekben az A szerepét egy konkrét állítás veszi fel (pl. a < 10), míg a B szerepét egy másik állítás (pl. a > 20).

Bináris értékekkelLogikai értékekkel

A	B	AND	OR	XOR
0	0	0	0	0
0	1	0	1	1
1	0	0	1	1
1	1	1	1	0

A	B	AND	OR	XOR
False	False	False	False	False
False	True	False	True	True
True	False	False	True	True
True	True	True	True	False

Igazságtábla programkóddal¶

JavaScriptJavaPython

let a = false; // 0
let b = true; // 1

let es = a && b;
let vagy = a || b;
let kizarovagy = a ^ b;

console.log(a, b, es, vagy, kizarovagy);

boolean a = false; // 0
boolean b = true; // 1

boolean es = a && b;
boolean vagy = a || b;
boolean kizarovagy = a ^ b;

System.out.printf("%b %b %b %b %b",a , b , es, vagy, kizarovagy);

a = False # 0
b = True # 1

es = a and b
vagy = a or b
kizarovagy = a ^ b

print(a, b, es, vagy, kizarovagy)

switch¶

A switch utasítást akkor használjuk, ha egy változó több lehetséges értékét kell ellenőrizni. Minden egyes értéket egy case blokkban vizsgálunk.

let nap = 4;

switch (nap) {
    case 1:
        console.log("Hétfő");
        break;
    case 2:
        console.log("Kedd");
        break;
    case 3:
        console.log("Szerda");
        break;
    default:
        console.log("Ismeretlen nap.");
}

Tip

Általánosan elmondható, hogy ha 5-nél többször vizsgáljuk ugyan azt a változót, akkor érdemes switch-case szerkezetet használni.

Alapértelmezett érték¶

Kérdés

Felvetődhet a kérdés, hogy mit tegyünk abban az esetben ha szeretnénk egy alapértelmezett értéket is megadni, amennyiben egyik feltétel sem teljesül, hasonlóan az if-else esetében az else ághoz.

A megoldást a default kulcsszó jelenti, amelyet a switch-case szerkezet végére kell írni.

Módosítsuk az előzőekben elkészített programunkat! Adjuk meg például azt, hogy a mai nap a hét 8. napja! Ebben az esetben a default ág fog lefutni.

let nap = 8;

switch (nap) {
    case 1:
        console.log("Hétfő");
        break;
    case 2:
        console.log("Kedd");
        break;
    case 3:
        console.log("Szerda");
        break;
    default:
        console.log("Nem létező nap!");
}

Strict Equality Operator¶

JavaScriptben az == és az === operátorok hasonlítják össze az értékeket, de különböző módon.

Az == (egyenlőség) operátor először típuskonverziót végez, mielőtt összehasonlítja az értékeket. Ez azt jelenti, hogy különböző típusú értékeket is egyenlőnek tekinthet, ha azok értéke konvertálható egymásba. Az === (szigorú egyenlőség) operátor nem végez típuskonverziót, és csak akkor tekinti egyenlőnek az értékeket, ha azok típusa és értéke is megegyezik.

Példák

console.log(5 == "5");   // true, mert a típuskonverzió után mindkettő 5
console.log(5 === "5");  // false, mert a típusok különböznek (szám és string)

console.log(null == undefined);   // true, mert a típuskonverzió után mindkettő "nincs érték"
console.log(null === undefined);  // false, mert a típusok különböznek

console.log(true == 1);   // true, mert a típuskonverzió után mindkettő 1
console.log(true === 1);  // false, mert a típusok különböznek (boolean és szám)

Az === használata biztonságosabb és kiszámíthatóbb összehasonlítást biztosít, mert elkerüli a váratlan típuskonverziók miatti hibákat. Ezért a JavaScript kódolás során ajánlott inkább az === operátort használni, amikor egyenlőséget vizsgálunk.

Összefoglalás¶

A vezérlési szerkezetek segítenek a program logikai folyamatának irányításában. Az if-else, switch utasítások, valamint az === operátor mind fontos eszközök, amelyeket a JavaScript programozás során használhatunk. Ezeknek a szerkezeteknek a megértése és helyes alkalmazása kulcsfontosságú a hatékony és olvasható kód írásához.