Változók, típusok, operátorok és vezérlési szerkezetek JavaScriptben – a JavaScript alap építőkockái.

JavaScript – Alapok

Ez az oldal a teljes JavaScript jegyzet 1–4. fejezetének (alap fogalmak, változók, típusok, operátorok, control flow) feldarabolt, doksi‑barát változata.
A teljes, egyben lévő anyag: content/javascript/javascript-full.mdx.

1. Mi az a JavaScript? – röviden

Böngészőben és szerveren is futó általános célú nyelv.
A web logikáért felelős rétege:
- HTML = struktúra,
- CSS = megjelenés,
- JavaScript = viselkedés.
Modern engine‑ek (V8, SpiderMonkey, JavaScriptCore) Just‑In‑Time (JIT) fordítást használnak, de fejlesztőként ezt nem kell külön kezelned.

Kulcs tulajdonságok:

Single‑threaded – egy call stack, egyszerre egy futó szál.
Dynamically typed – a típus futásidőben dől el.
Event‑driven – eseményekre reagál (kattintás, hálózati válasz, időzítők).

2. Változók és típusok

Változók – "névvel ellátott dobozok"

Változó = név → érték páros. Az értéket el tudod tárolni, ki tudod olvasni, módosítani.

`var`, `let`, `const` – mi a különbség?

`var` – régi, kerülendő

var nev = "Adam";
var nev = "Peter"; // újra deklarálható – problémás
nev = "Laci";      // megváltoztatható

function scope, nem block scope,
hoisting‑gal (felemelés) kombinálva meglepő viselkedést okozhat.

Modern kódban kerüld, használd helyette a let / const párost.

`let` – változó érték, block scope

let kor = 25;
kor = 26;      // megváltoztatható ✓
// let kor = 27; // ugyanabban a scope‑ban újra deklarálni: HIBA ✗

Használd, ha az érték ténylegesen módosulni fog.

`const` – konstans referencia

const PI = 3.14;
// PI = 3; // HIBA ✗

const user = { nev: "Adam" };
user.nev = "Peter"; // működik – a belső állapot változik
// user = {};       // HIBA – maga a referencia nem változhat

Lényeg: const a referenciát teszi állandóvá, nem feltétlenül a belső objektumot.

Ökölszabály:

indulj mindig const‑tal,
ha kiderül, hogy módosulnia kell, válts let‑re,
var‑t ne használj.

Primitive típusok

Ezek egyszerű, érték típusok – közvetlen értékként tárolódnak, nem referenciaként.

// string
const uzenet = "Hello, világ!";
const nev = 'Adam';
const mondat = `Szia, ${nev}!`; // template literal

// number
const egesz = 42;
const tizedes = 3.14;
const vegtelen = Infinity;
const nemSzam = NaN; // Not a Number

// boolean
const aktiv = true;
const torolt = false;

// null – szándékos üresség
const adat = null;

// undefined – nincs érték rendelve
let valami;
console.log(valami); // undefined

// symbol – egyedi azonosító
const egyedi = Symbol("leiras");

// bigint – nagyon nagy egész számok
const nagyMeret = 9007199254740991n;

`null` vs `undefined`

Tipikus interjú kérdés.

	`null`	`undefined`
Jelentés	Szándékosan üres	Nincs érték rendelve
Ki állítja be?	Te, fejlesztő	A JS motor
`typeof`	`"object"` (ismert bug)	`"undefined"`

let a;           // undefined – nem adtunk értéket
let b = null;    // null – szándékosan üres

console.log(typeof a); // "undefined"
console.log(typeof b); // "object" – történelmi bug

Reference típusok

Referencia típusoknál a változó nem az értéket, hanem egy mutatót (referenciát) tárol egy memóriaterületre:

// Object
const felhasznalo = {
  nev: "Adam",
  kor: 25
};

// Array
const szamok = [1, 2, 3, 4, 5];

// Function
const udvozlet = function() { return "Hello!"; };

Viselkedés különbség (value vs reference):

// Primitive – érték másolódik
let a = 5;
let b = a;
b = 10;
console.log(a); // 5 – a nem változott

// Reference – referencia másolódik
let obj1 = { nev: "Adam" };
let obj2 = obj1;      // ugyanarra a memóriacímre mutat
obj2.nev = "Peter";
console.log(obj1.nev); // "Peter" – obj1 is megváltozott

Gondolatkép: primitive = másolat a papírról, reference = kulcsmásolat ugyanahhoz a házhoz.

`typeof` – típusellenőrzés

typeof "hello"      // "string"
typeof 42           // "number"
typeof true         // "boolean"
typeof undefined    // "undefined"
typeof null         // "object"   // történelmi bug
typeof {}           // "object"
typeof []           // "object"   // tömb is object
typeof function(){} // "function" // külön shorthand

Tömb ellenőrzéshez:
Array.isArray([]) → true.

3. Operátorok – alapok

Aritmetikai operátorok

const a = 10;
const b = 3;

console.log(a + b);  // 13 – összeadás
console.log(a - b);  // 7  – kivonás
console.log(a * b);  // 30 – szorzás
console.log(a / b);  // 3.333... – osztás
console.log(a % b);  // 1  – maradékos osztás (modulo)
console.log(a ** b); // 1000 – hatványozás

Különlegesség – + és stringek:

console.log("5" + 3);  // "53" – string összefűzés
console.log("5" - 3);  // 2   – itt számmá alakít

Ha az egyik operandus string, a + összefűz, nem összead.

Összehasonlítók: `==` vs `===`

`==` – laza egyenlőség (type coercion)

console.log(5 == "5");     // true   (string → number)
console.log(0 == false);   // true   (false → 0)
console.log(null == undefined); // true
console.log("" == false);  // true

`===` – szigorú egyenlőség

console.log(5 === "5");   // false – más típus
console.log(0 === false); // false
console.log(5 === 5);     // true

Irányelv: mindig ===‑t használj, a == tipikus hibaforrás.

Truthy és falsy értékek

if feltételeknél minden érték boolean-ként kerül kiértékelésre.

Falsy értékek:

false
0
""
null
undefined
NaN

Minden más truthy, pl.:

"0"   // nem üres string
[]    // üres tömb
{}    // üres object
-1    // bármilyen nullától különböző szám

if ("") {
  console.log("Nem fut le");
}

if ("hello") {
  console.log("Lefut"); // ✓
}

if ([]) {
  console.log("Üres tömb is truthy"); // ✓
}

Logikai operátorok

// AND – mindkettőnek igaznak kell lennie
true && true   // true
true && false  // false

// OR – elég, ha az egyik igaz
true || false  // true
false || false // false

// NOT – negálás
!true   // false
!false  // true
!!"hi"  // true – truthy → boolean

Gyakori minták:

const nev = felhasznalo?.nev || "Névtelen"; // alapérték truthy hiányában

// Csak akkor igaz, ha mindkét feltétel igaz
const aktiv = bejelentkezett && vanJogosultsag;

4. Control Flow – vezérlési szerkezetek

`if / else`

const kor = 20;

if (kor >= 18) {
  console.log("Felnőtt");
} else if (kor >= 13) {
  console.log("Tinédzser");
} else {
  console.log("Gyerek");
}

Ternary operátor:

const uzenet = kor >= 18 ? "Felnőtt" : "Kiskorú";

`switch`

Hasznos, ha ugyanazt a változót több lehetséges értékkel hasonlítod össze.

const nap = "Hétfő";

switch (nap) {
  case "Hétfő":
  case "Kedd":
    console.log("Hét eleje");
    break;
  case "Péntek":
    console.log("Majdnem hétvége!");
    break;
  default:
    console.log("Egyéb nap");
}

Mindig figyelj a break‑re – különben a végéig "lecsorog" (fall‑through).

Ciklusok: `for`, `for...of`, `for...in`

// klasszikus for
for (let i = 0; i < 5; i++) {
  console.log(i); // 0, 1, 2, 3, 4
}

// for...of – tömb elemein megy végig
const gyumolcsok = ["alma", "körte", "szilva"];
for (const gyumolcs of gyumolcsok) {
  console.log(gyumolcs);
}

// for...in – object kulcsain megy végig
const auto = { marka: "Toyota", ev: 2022 };
for (const kulcs in auto) {
  console.log(kulcs, auto[kulcs]);
}

`while` és `do...while`

// while – előbb ellenőriz, aztán fut
let i = 0;
while (i < 3) {
  console.log(i); // 0, 1, 2
  i++;
}

// do...while – legalább egyszer lefut
let j = 0;
do {
  console.log(j);
  j++;
} while (j < 3);

Összefoglaló – Alapok

Változók: const alapértelmezett, let ha tényleg változik, var‑t ne használd.
Típusok: ismerd a primitive vs reference különbséget (másolás, összehasonlítás).
Összehasonlítás: gyakorlatban szinte mindig === / !==.
Truthy/falsy: 0, "", null, undefined, NaN, false falsy – minden más truthy.
Control flow: if/else + switch + alap ciklusok adják a vezérlés gerincét.

Következő oldal:
Függvények, scope, closures →

Alapok

On this page