JavaScript változók

A JavaScriptben a változók olyan tárolók, amelyek adatokat tárolnak. A változókat különböző típusú adatok tárolására használhatjuk, például számokra, szövegekre, objektumokra stb.

Változók deklarálása

A változókat a var, let vagy const kulcsszavakkal deklarálhatjuk.

var

A var kulcsszóval deklarált változók funkció szintű vagy globális hatókörűek. Ez azt jelenti, hogy a változók a deklaráció helyétől függetlenül elérhetők a funkción vagy a globális szinten belül.

Példa

var x = 10;
console.log(x); // 10

function testVar() {
    var y = 20;
    console.log(y); // 20
}
testVar();
// console.log(y); // Hiba, mivel y nincs a globális hatókörben

Hoisting

A var kulcsszóval deklarált változók esetében a deklaráció feljebb kerül a kódban (hoisting). Ez azt jelenti, hogy a változót a deklaráció előtt is használhatjuk, de az értéke undefined lesz.

console.log(z); // undefined
var z = 30;
console.log(z); // 30

let

A let kulcsszóval deklarált változók blokk szintű hatókörűek. Ez azt jelenti, hogy a változók csak abban a blokkban (kódrészletben) érhetők el, ahol deklarálták őket.

Példa

let a = 10;
console.log(a); // 10

{
    let b = 20;
    console.log(b); // 20
}
// console.log(b); // Hiba, mivel b nincs a blokk hatókörén kívül

Hoisting

A let kulcsszóval deklarált változók is hoisting alá esnek, de a var-tól eltérően nem lesznek elérhetők a deklaráció előtt. Ezt időbeli halott zónának (temporal dead zone, TDZ) nevezik.

// console.log(c); // Hiba, mivel c a TDZ-ben van
let c = 30;
console.log(c); // 30

const

A const kulcsszóval deklarált változók szintén blokk szintű hatókörűek, de a let-től eltérően értéküket nem lehet újra hozzárendelni. Ez azt jelenti, hogy a const változók állandók.

Példa

const d = 10;
console.log(d); // 10

// d = 20; // Hiba, mivel d értékét nem lehet megváltoztatni

Objektumok és tömbök

Fontos megjegyezni, hogy a const nem jelenti azt, hogy az objektumok vagy tömbök tartalma nem változhat. Csak az újra hozzárendelést akadályozza meg.

const obj = { name: 'Alice' };
obj.name = 'Bob'; // Ez megengedett
console.log(obj.name); // Bob

// obj = { name: 'Charlie' }; // Hiba, mivel obj újra hozzárendelése nem megengedett

const arr = [1, 2, 3];
arr.push(4); // Ez megengedett
console.log(arr); // [1, 2, 3, 4]

// arr = [5, 6, 7]; // Hiba, mivel arr újra hozzárendelése nem megengedett

JSON

A fenti példában bemutatott objektumok egy típusa a JSON (JavaScript Object Notation).

Kapcsolódó anyag megtekintése

Változó Hatókörök

A változók hatókörének megértése fontos a JavaScriptben.

Globális hatókör

A globális hatókörben deklarált változók a teljes programban elérhetők.

var globalVar = 'I am global';
function testGlobal() {
    console.log(globalVar); // I am global
}
testGlobal();
console.log(globalVar); // I am global

Funkció hatókör

A funkció hatókörben deklarált változók csak az adott funkción belül érhetők el.

function testFunctionScope() {
    var functionVar = 'I am local';
    console.log(functionVar); // I am local
}
testFunctionScope();
// console.log(functionVar); // Hiba, mivel functionVar nincs a globális hatókörben

Blokk hatókör

A blokk hatókör a {} közötti kódrészlet, például egy ciklus vagy feltételes szerkezet.

if (true) {
    let blockVar = 'I am in a block';
    console.log(blockVar); // I am in a block
}
// console.log(blockVar); // Hiba, mivel blockVar nincs a blokk hatókörén kívül

Változók típusai

A JavaScript dinamikusan típusos nyelv, ami azt jelenti, hogy a változók típusai futási időben határozódnak meg.

Alapvető Típusok

Típus	Leírás	Példa
Number	Számok	1, 2, 3.14
String	Szövegek	'hello', "world"
Boolean	Logikai értékek	true vagy false
Null	Egy üres érték.
Undefined	Egy változó, amely nincs inicializálva.
Symbol	Egy egyedi és változhatatlan érték.
BigInt	Nagy egész számok.

Példák

let num = 42;
let str = 'hello';
let bool = true;
let n = null;
let u;
let sym = Symbol('sym');
let bigInt = 1234567890123456789012345678901234567890n;

console.log(typeof num); // number
console.log(typeof str); // string
console.log(typeof bool); // boolean
console.log(typeof n); // object (ez egy ismert hiba a JavaScriptben)
console.log(typeof u); // undefined
console.log(typeof sym); // symbol
console.log(typeof bigInt); // bigint

Összetett Típusok

• Object: Kulcs-érték párok halmaza.
• Array: Lista-szerű objektum, amely több értéket tárolhat.

Példák

Kód másolása
let obj = { name: 'Alice', age: 25 };
let arr = [1, 2, 3, 4, 5];

console.log(typeof obj); // object
console.log(typeof arr); // object (mivel az Array is egy speciális Object)

Záró gondolatok

A változók alapvető építőelemei a JavaScript nyelvnek. A var, let és const különböző esetekben hasznosak, és fontos megérteni a hatókörüket és viselkedésüket. Az alapvető és összetett típusok ismerete segít a hatékony és hibamentes kódírásban.