Operátorok és kifejezések

1Operátor és kifejezés

A kifejezés bármi, aminek értéke van: egy szám (42), egy változó (ar), egy művelet eredménye (ar * 1.27) vagy egy összehasonlítás (keszlet > 0). Az operátor a műveletet végző jel (+, >, &&…), az operandusok pedig azok az értékek, amelyeken dolgozik.

const ar = 6990;
const brutto = ar * 1.27;      // "ar * 1.27" egy kifejezés; a * az operátor, ar és 1.27 az operandusok
const draga = brutto > 10000;  // ez is kifejezés — értéke false
console.log(brutto, draga);    // 8877.3 false

Kifejezés mindenhová írható, ahová érték: console.log-ba, változó értékének, template literál ${}-jába, másik kifejezés belsejébe. A fejezet végéig operátorok szerint haladunk.

2Aritmetikai operátorok

A ** az ES2016-ban jött; korábban a Math.pow(2, 10) volt az egyetlen mód — mindkettő működik. A / egész számoknál is tizedes törtet adhat; ha egész hányados kell, kerekíts (Math.floor).

A % — a maradék sokoldalú

A maradékos osztás első látásra ritkán hasznos, valójában rengeteg mintában felbukkan:

const szam = 4721;
console.log(szam % 2 === 0);    // false — páros-e? (a maradék 0, ha páros)
console.log(szam % 10);         // 1 — az utolsó számjegy
console.log(szam % 100);        // 21 — az utolsó két számjegy

const ora = 23;
console.log((ora + 3) % 24);    // 2 — körbeforgás: 23 óra + 3 óra = hajnali 2

const mp = 125;
console.log(mp % 60);           // 5 — a percen felüli másodpercek

3Értékadó operátorok

Az alap értékadás a =: a jobb oldali kifejezés értékét a bal oldali változóba teszi. A rövidített formák egyszerre olvassák és módosítják a változót — ezért csak let-tel deklarált változón működnek:

let keszlet = 40;
keszlet -= 3;           // eladtunk 3-at → 37
keszlet++;              // egyet visszahoztak → 38

let osszeg = 0;
osszeg += 6990;         // 6990
osszeg += 1990;         // 8980 — így gyűjtünk egy kosár értékét

let nev = "Egér";
nev += " (fekete)";     // szövegre is: "Egér (fekete)"

4Összehasonlítás: == vs ===

Az összehasonlító operátorok két értéket vetnek össze, és logikai eredményt (true / false) adnak. Ez az eredmény változóba tehető, kiírható, és a következő fejezettől feltételként használjuk.

A leghíresebb buktató

Kétféle „egyenlő" van JavaScriptben:

• === (szigorú): csak akkor igaz, ha az érték ÉS a típus is megegyezik. Kiszámítható.
• == (laza): összehasonlítás előtt megpróbálja azonos típusra hozni az értékeket — bonyolult szabályok szerint, meglepő eredményekkel.

console.log(5 === 5);          // true
console.log("5" === 5);        // false — más a típus (string vs number)
console.log("5" == 5);         // true  — a == átalakítja, ezért egyenlőnek látja
console.log(0 == "");          // true  (!!)
console.log(0 == "0");         // true  (!!)
console.log("" == "0");        // false (!!!) — pedig az előző kettő szerint „egyenlők" lennének
console.log(null == undefined);   // true
console.log(null === undefined);  // false

Szövegeket is lehet </>-vel hasonlítani — betűrend szerint, de a kódtábla alapján: minden nagybetű kisebb minden kisbetűnél, az ékezetes betűk pedig a végén vannak. Rendezéshez ezért később mást használunk (8. fejezet).

5Logikai operátorok, rövidzár, truthy/falsy

A logikai operátorok igaz/hamis értékeket kombinálnak — így épülnek az összetett feltételek:

const ar = 6990, keszlet = 40;
console.log(ar < 10000 && keszlet > 0);   // true — olcsó ÉS raktáron
console.log(ar > 50000 || keszlet > 0);   // true — drága VAGY raktáron (elég az egyik)
console.log(!(keszlet === 0));             // true — NEM fogyott el
console.log(keszlet !== 0);                // ugyanaz, olvashatóbban

Truthy és falsy

A logikai operátorok nem csak true/false-szal működnek: bármilyen értéket „igaznak" (truthy) vagy „hamisnak" (falsy) tekintenek. A falsy értékek köre kicsi, tanuld meg fejből:

A Boolean(x) megmutatja, melyik: Boolean("0") → true, mert a "0" nem üres szöveg. Ugyanezt teszi a dupla tagadás is: !!x.

Rövidzár (short-circuit) — és amit visszaad

Az && és a || balról jobbra értékel, és megáll, amint eldőlt az eredmény: a && az első falsy-nál, a || az első truthy-nál. Ráadásul nem true/false-t adnak vissza, hanem azt az operandust, amelyiknél megálltak:

console.log("" || "Vendég");        // "Vendég" — a bal falsy, ezért a jobb oldalt adja
console.log("Anna" || "Vendég");    // "Anna"   — a bal truthy, meg sem nézi a jobbat
console.log(0 || 10);               // 10
console.log(5 && "ok");             // "ok" — a bal truthy, ezért a jobb oldalt adja
console.log(0 && "ok");             // 0    — a bal falsy, itt megáll

Ebből születik a leggyakoribb minta, az alapérték: const nev = bejovoNev || "Vendég"; — ha van név, az marad; ha üres/hiányzik, „Vendég" lesz.

6A feltételes operátor (? :)

A feltételes (más néven ternary, azaz háromoperandusú) operátor egy sorban választ két érték közül a feltétel alapján:

// feltétel ? érték_ha_igaz : érték_ha_hamis
const keszlet = 0;
const allapot = keszlet > 0 ? "raktáron" : "elfogyott";
console.log(allapot);                                  // elfogyott

const szam = 7;
console.log(szam % 2 === 0 ? "páros" : "páratlan");   // páratlan

const ar = 12000;
const fizetendo = ar >= 10000 ? ar * 0.9 : ar;          // a két ág kifejezés is lehet → 10800
console.log(`Fizetendő: ${fizetendo} Ft`);

Olvasd így: „ha a készlet nagyobb nullánál, akkor „raktáron", különben „elfogyott"". Ez egy kifejezés — értéke van, ezért változóba tehető, kiírható, template literálba írható. A következő fejezet if/else szerkezete ugyanezt tudja, de utasításként, több sorban.

7A Math objektum

A Math beépített objektum matematikai függvényeket és állandókat gyűjt. Nem kell létrehozni, bárhol elérhető — Node-ban és böngészőben ugyanúgy. A leggyakoribbak:

const db = 25, dobozMeret = 10;
console.log(Math.ceil(db / dobozMeret));       // 3 — a megkezdett doboz is számít

const kert = "500";
const meret = Math.min(Number(kert) || 10, 50);  // 50 — alapérték + felső korlát egy sorban
console.log(meret);

8Műveleti sorrend (precedencia)

Az operátoroknak — a matematikához hasonlóan — elsőbbségi sorrendjük van. Az erősebb köt előbb; azonos szintűek balról jobbra. A gyakorlatban ezt a sorrendet érdemes fejben tartani (fentről lefelé csökkenő erősség):

console.log(2 + 3 * 4);          // 14 — előbb a szorzás
console.log((2 + 3) * 4);        // 20 — a zárójel előrébb sorol
console.log(10 - 4 - 3);         // 3  — azonos szint: balról jobbra, (10-4)-3
console.log(5 > 3 && 2 + 2 === 4);   // true — aritmetika, aztán összehasonlítás, végül &&
console.log(true || false && false);  // true — az && erősebb: true || (false && false)

9Élő kód — próbáld ki!

Kísérletezz az operátorokkal! Különösen érdemes a == vs === mintát, a rövidzár visszatérési értékét és a Math kerekítéseit negatív számokkal kipróbálni. Írj át egy-egy értéket, és tippeld meg előre a kimenetet.

10Feladatok

Döntések elágazás nélkül: minden feladat megoldható kifejezésekkel — ternaryvel, logikai operátorokkal, Math-tal és a %-kal. (Az if és a ciklusok a következő fejezetben jönnek — most szándékosan nem használjuk őket.) Az adott változókat a gyakorló hozza létre, te csak használd őket, és írd ki pontosan a kért formában.

11Összegzés