Változók és adattípusok

1Mi a változó? let, const, var

A változó egy névvel ellátott „doboz", amelyben egy értéket tárolunk. A nevén keresztül később bármikor elérjük és felhasználjuk — nem kell újra beírni, és ha megváltozik, csak egy helyen kell átírni.

let ar = 6990;          // "ar" nevű doboz, benne a 6990 érték
console.log(ar);         // 6990 — a doboz tartalmát írjuk ki
console.log(ar * 2);     // 13980 — kifejezésben is használható

Változót háromféle kulcsszóval hozhatunk létre. A deklaráció (létrehozás) és az értékadás egy lépésben is mehet:

const nev = "Vezeték nélküli egér";   // állandó: nem fog megváltozni
let keszlet = 40;                     // változó: később módosítjuk
let utolsoRendeles;                   // deklaráció érték nélkül → undefined
var regi = 1;                         // régi módszer — ma már kerüljük

2let vs const

A let-tel létrehozott változó értéke később újra megadható, a const-é nem — ha mégis megpróbálod, hibát kapsz:

let keszlet = 40;
keszlet = 39;                  // OK: a let újraértékadható
keszlet = keszlet - 1;         // OK: a régi értékből számoljuk az újat → 38

const nev = "Egér";
nev = "Billentyűzet";          // TypeError: Assignment to constant variable.

3Elnevezési szabályok

• A név állhat betűkből, számokból, _ és $ jelből — de nem kezdődhet számmal.
• Nem lehet benne szóköz vagy kötőjel, és nem lehet kulcsszó (let, if, function…).
• A JavaScript megkülönbözteti a kis- és nagybetűt: az ar és az Ar két külön változó.
• A bevett stílus a camelCase: az első szó kicsivel, a továbbiak nagy kezdőbetűvel — teljesAr, vasarloNeve, rendelesDatum.
• Ékezetes betű technikailag megengedett, de kerüljük — a kódbázisok nemzetköziek. Ebben a kurzusban magyar szavakat használunk ékezet nélkül (keszlet, ar).

4Adattípusok és typeof

Minden értéknek van típusa. Az alaptípusok (primitívek), amelyekkel most dolgozunk:

Később jönnek az összetett típusok: tömb (6. fejezet), objektum (7. fejezet), függvény (5. fejezet).

typeof — melyik típus?

A typeof operátor egy szövegben megadja az érték típusának nevét:

console.log(typeof 42);          // "number"
console.log(typeof 3.14);        // "number" — nincs külön tizedes típus
console.log(typeof "Egér");      // "string"
console.log(typeof true);        // "boolean"
console.log(typeof undefined);   // "undefined"
console.log(typeof null);        // "object"  ← !!!

Dinamikus típusosság

A JavaScript dinamikusan típusos: nem kell előre megadni a típust, a változó azt veszi fel, amit beleteszünk — és menet közben akár meg is változhat. Ez kényelmes, de zavaró is lehet, ezért egy változóban tartsunk egyféle típust:

let adat = 42;             // typeof adat → "number"
adat = "negyvenkettő";     // typeof adat → "string" — megengedett, de kerüljük

Logikai értékek

A boolean típusnak két értéke van: true és false. Leggyakrabban egy összehasonlítás eredményeként keletkezik — az összehasonlító operátorokat a 3. fejezet részletezi, de a >-t már most használjuk:

const keszlet = 40;
const raktaron = keszlet > 0;     // az összehasonlítás eredménye: true
console.log("Raktáron:", raktaron);   // Raktáron: true
console.log(typeof raktaron);          // "boolean"

5Szövegek és template literál

Szöveget három módon írhatunk: "dupla idézőjel", 'aposztróf', vagy backtick (` `). Az első kettő egyenértékű; szövegeket a + jellel fűzünk össze:

const nev = "Egér";
const ar = 6990;
console.log("A(z) " + nev + " ára " + ar + " Ft.");   // A(z) Egér ára 6990 Ft.

A template literál (backtick) sokkal kényelmesebb: a ${...} belsejébe közvetlenül beírhatsz változót vagy bármilyen kifejezést, és a szöveg több sorba is törhet:

console.log(`A(z) ${nev} ára ${ar} Ft.`);
console.log(`Bruttó: ${ar * 1.27} Ft`);        // kifejezés is mehet → Bruttó: 8877.3 Ft
console.log(`Bruttó: ${Math.round(ar * 1.27)} Ft`);   // kerekítve → Bruttó: 8877 Ft

A Math.round() a legközelebbi egészre kerekít (8877.3 → 8877, 2.5 → 3). Árakkal dolgozva szinte mindig kell — a többi Math-függvényt a 3. fejezet gyűjti össze.

6A számok különlegességei

JavaScriptben egyetlen számtípus van: a number, amely 64 bites lebegőpontos számként tárol egészet és tizedes törtet is. Ebből néhány érdekesség következik, amelyeket érdemes fejből tudni.

0.1 + 0.2 — a tizedes törtek pontatlanok

console.log(0.1 + 0.2);               // 0.30000000000000004  (!)
console.log(6990 * 1.27);             // 8877.3 — itt szerencsénk volt
console.log((0.1 + 0.2).toFixed(2));  // "0.30" — két tizedesre kerekített SZÖVEG

A számítógép kettes számrendszerben tárol, és a 0.1 abban nem véges — ahogy az 1/3 tízesben sem. Ezért pénzügyi számításnál kerekítünk: Math.round() egészre, vagy szam.toFixed(2) adott tizedesre. Fontos: a toFixed szöveget ad vissza (mindig pontosan annyi tizedessel), a Math.round számot.

Math.floor és a maradék

A Math.floor() mindig lefelé kerekít (7.9 → 7). A % (maradékos osztás) az osztás maradékát adja (125 % 60 → 5). Kettőjükkel „bontunk" mennyiségeket: másodpercből perc és másodperc, forintból ezresek és a többi:

const mp = 125;
const perc = Math.floor(mp / 60);   // 125 / 60 = 2.083… → 2
const marad = mp % 60;              // 125 - 2·60 = 5
console.log(`${perc} perc ${marad} mp`);   // 2 perc 5 mp

NaN, Infinity, Number.isInteger

console.log(Number("alma"));      // NaN — "Not a Number": sikertelen számmá alakítás
console.log(typeof NaN);          // "number" — a NaN is a number típus tagja (!)
console.log(NaN + 1);             // NaN — bármi, amiben NaN van, NaN marad
console.log(1 / 0);               // Infinity — nincs hiba, „végtelen"
console.log(Number.isInteger(5));     // true
console.log(Number.isInteger(5.5));   // false
console.log(Number.isNaN(NaN));       // true — így ellenőrizd, hogy valami NaN-e

7Típuskonverzió

Gyakran más típusban kapunk egy értéket, mint ahogyan használni akarjuk — legtöbbször szövegként érkezik egy szám. Ilyenkor explicit (kimondott) konverziót végzünk:

A Boolean() szabálya egyszerű: 0, "" (üres szöveg), null, undefined, NaN és false hamis — minden más igaz. Ezt „truthy/falsy"-nak hívják, a 3. fejezetben lesz fontos.

Implicit konverzió — amikor a gép dönt helyetted

Ha két különböző típust operátorral kötsz össze, a JavaScript magától átalakít valamit — és nem mindig azt, amire számítasz. A + a legveszélyesebb: ha bármelyik oldal szöveg, összefűz. A többi aritmetikai operátor (-, *, /) viszont számmá alakít:

console.log("5" + 2);      // "52"  — összefűzés!
console.log("5" * 2);      // 10    — a * számmá alakítja a "5"-öt
console.log("5" - 2);      // 3
console.log("5" + 2 * 2);  // "54"  — előbb 2*2=4, aztán "5"+4 összefűzés
console.log(Number("5") + 2);   // 7 — így egyértelmű

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

Kísérletezz a változókkal és a típusokkal! Próbáld ki a const újraértékadását (hibát kapsz), a 0.1 + 0.2-t, és a "5" + 2 vs "5" * 2 különbséget. A kimenet úgy jelenik meg, ahogy Node-ban a terminálban látnád.

9Feladatok

Webshop-ízű számolós feladatok: bruttó ár, kör, átváltások, típusok. Az adott változókat a gyakorló hozza létre (let-tel, tehát módosíthatod is őket) — te hozz létre továbbiakat const-tal, számolj, és írd ki pontosan a kért formában. Figyelj a kerekítésre: a toFixed szöveget ad (5.0), a Math.round számot (5).

10Összegzés