JS Elemi és összetett adattípusok. Operátorok

A JavaScript dinamikusan típusos nyelv, ami azt jelenti, hogy a változó típusát nem kell előre deklarálni, és futás közben változhat.

Változók típusai

Egyszerű típusok

Típus	Leírás	Példa
`String`	Szöveges adatok.	`let nev = "Béla";`
`Number`	Lehet egész, vagy lebegőpontos. Alapértelmezetten $64$-bites IEEE 754 lebegőpontos szám (Double).	`let eletkor = 70;` `let ar = 19.99;`
`BigInt`	Nagyon nagy egész számok tárolására, amik meghaladják a `Number` típus biztonságos tárolási határát ($2^{53} – 1$).	`let x = 123456789012345678901234567890n;` (Az `n` jelzi, hogy BigInt)
`Boolean`	Logikai érték: `true` (igaz) vagy `false` (hamis).	`let vanEredmeny = true;`
`undefined`	A változó deklarálva van, de értéket nem kapott.	`let y;` (itt $y$ értéke `undefined`)
`null`	Érték hiányát jelöli, szándékosan beállítva. A fejlesztő jelzi vele, hogy a változó üres.	`let data = null;`
`Symbol`	Egyedi azonosítókat hoz létre, gyakran objektum tulajdonságok kulcsaként használják. (ES6)

Összetett Adattípus (Referencia típusok)

Object: A JavaScript legtöbb elemének alapja.

Változó nevére vonatkozó megkötések

Változó neve betűvel, $-ral, vagy _ jellel kezdődhet.
Érzékeny a kis és nagybetűkre!
Minimális változónév hossz: 1 betű.
Lehetőleg ne használjunk ékezetes betűket fájl és változónévként se!

Operátorok

Aritmetikai operátorok:

Operátor	Leírás	Példa
`+`	Összeadás, String esetén összefűzés (Concatenation).	`5 + 3` (8), `"hello" + " világ"` („hello világ”)
`-`	Kivonás.	`5 - 3` (2)
*``**	Szorzás.	`5 * 3` (15)
`/`	Osztás.	`5 / 2` (2.5)
`%`	Maradékos osztás (Modulus).	`5 % 2` (1)
``**	Hatványozás. (ES6)	`2 ** 3` (8)
`++`	Inkremens (növelés 1-gyel).	`i++` vagy `++i`
`--`	Dekremens (csökkentés 1-gyel).	`i--` vagy `--i`

Összehasonlító operátorok:

Operátor	Leírás	Példa
`==`	Egyenlő (érték szerint, típus-kényszerítéssel).	`5 == "5"` ($\text{true}$)
`===`	Szigorúan egyenlő (érték és típus szerint). Ajánlott.	`5 === "5"` ($\text{false}$)
`!=`	Nem egyenlő (érték szerint, típus-kényszerítéssel).	`5 != "6"` ($\text{true}$)
`!==`	Szigorúan nem egyenlő (érték vagy típus szerint). Ajánlott.	`5 !== "5"` ($\text{true}$)
`>`	Nagyobb.
`<`	Kisebb.
`>=`	Nagyobb vagy egyenlő.
`<=`	Kisebb vagy egyenlő.

Logikai operátorok:

Operátor	Jelentés	Példa	Eredmény
`&&`	AND (És)	`true && false`	$\text{false}$
**		**	OR (Vagy)
`!`	NOT (Negálás)	`!true`	$\text{false}$

Értékadó Operátorok

Operátor	Rövidítés	Teljes alak
`=`	Sima értékadás.	`let c = 8;`
`+=`	Hozzáadás és értékadás.	`C += A` $\implies$ `C = C + A`
*`=`**	Szorzás és értékadás.	`C = A` $\implies$ `C = C A`
`/=`	Osztás és értékadás.	`C /= A` $\implies$ `C = C / A`
`=`**	Hatványozás és értékadás. (ES2016)	`C = A` $\implies$ `C = C A`
…	…

Kommentek használata

Kódunkat elláthatjuk megjegyzésekkel. Egy soros megjegyés: // komment szövege
Többsoros megjegyzés: /* komment szövege */

Típus-ellenőrzés és Konverzió

Típus-ellenőrzés: typeof

A typeof operátor (vagy függvényként: typeof()) megmondja egy változó adattípusát (stringként adja vissza).

let num = 1999;
let str = "hello";
let bool = true;

console.log(typeof num); // Eredmény: "number"
console.log(typeof str); // Eredmény: "string"
console.log(typeof bool); // Eredmény: "boolean"
console.log(typeof null); // Eredmény: "object" (Ez egy ismert hiba a JS-ben, de a null ténylegesen primitív típus.)
console.log(typeof {a:1}); // Eredmény: "object"

let num = 1999;

let str = "hello";

let bool = true;

console.log(typeof num); // Eredmény: "number"

console.log(typeof str); // Eredmény: "string"

console.log(typeof bool); // Eredmény: "boolean"

console.log(typeof null); // Eredmény: "object" (Ez egy ismert hiba a JS-ben, de a null ténylegesen primitív típus.)

console.log(typeof {a:1}); // Eredmény: "object"

Típuskonverzió (Type Conversion)

Kényszerített Típuskonverzió (Explicit Conversion)
A fejlesztő szándékosan megváltoztatja egy érték típusát.

Számmá alakítás

let s = "123.45";
let n1 = Number(s); // Eredmény: 123.45 (Number)
let n2 = parseInt(s); // Eredmény: 123 (Egész szám - Number)
let n3 = parseFloat(s); // Eredmény: 123.45 (Lebegőpontos - Number)

let s = "123.45";

let n1 = Number(s); // Eredmény: 123.45 (Number)

let n2 = parseInt(s); // Eredmény: 123 (Egész szám - Number)

let n3 = parseFloat(s); // Eredmény: 123.45 (Lebegőpontos - Number)

Stringgé alakítás:

let n = 42;
let s1 = String(n); // Eredmény: "42" (String)
let s2 = n.toString(); // Eredmény: "42" (String)

let n = 42;

let s1 = String(n); // Eredmény: "42" (String)

let s2 = n.toString(); // Eredmény: "42" (String)

Logikaivá (Boolean) alakítás:

let b1 = Boolean(1); // Eredmény: true
let b2 = Boolean(0); // Eredmény: false
let b3 = Boolean("hello"); // Eredmény: true
let b4 = Boolean(""); // Eredmény: false (Üres string)
// Az 5 "hamis" (falsy) érték: 0, null, undefined, "", NaN (Not-a-Number)

let b1 = Boolean(1); // Eredmény: true

let b2 = Boolean(0); // Eredmény: false

let b3 = Boolean("hello"); // Eredmény: true

let b4 = Boolean(""); // Eredmény: false (Üres string)

// Az 5 "hamis" (falsy) érték: 0, null, undefined, "", NaN (Not-a-Number)

Automatikus Típuskonverzió (Implicit Coercion)

A JavaScript automatikusan konvertálja a típusokat egy művelet végrehajtásakor.

Összeadás (+): Ha az egyik operandus String, a másik is String-gé alakul, és összefűzés történik.

let x = 5 + "3"; // Eredmény: "53" (String)
let y = "5" + 3; // Eredmény: "53" (String)

1 2	let x = 5 + "3"; // Eredmény: "53" (String) let y = "5" + 3; // Eredmény: "53" (String)

Aritmetikai műveletek (kivéve +): A String-ek számmá alakulnak.

let z = "10" / "2"; // Eredmény: 5 (Number)

1	let z = "10" / "2"; // Eredmény: 5 (Number)

Laza egyenlőség (==): Lásd fentebb, típuskonverzióval hasonlít.

1 == true; // Eredmény: true (1-et true-vá alakítja)

1	1 == true; // Eredmény: true (1-et true-vá alakítja)

Felhasználói beviteli/kimeneti példa

/* Felhasználói bevitel és négyzetgyök számítás */
let a = prompt('Kérek egy számot','0');

// A prompt mindig stringet ad vissza, de a Math.sqrt() implicit konvertálja számmá
let i = Math.sqrt(a);

// Eredmény kiírása:
document.write('Az ', a, ' szám négyzetgyöke ', i);

// ... vagy a modern konzolra:
console.log(`Az ${a} szám négyzetgyöke ${i}`); // ún. Template Literals (ES6)

/* Felhasználói bevitel és négyzetgyök számítás */

let a = prompt('Kérek egy számot','0');

// A prompt mindig stringet ad vissza, de a Math.sqrt() implicit konvertálja számmá

let i = Math.sqrt(a);

// Eredmény kiírása:

document.write('Az ', a, ' szám négyzetgyöke ', i);

// ... vagy a modern konzolra:

console.log(`Az ${a} szám négyzetgyöke ${i}`); // ún. Template Literals (ES6)