Bevezetés, változók, adattípusok, operátorok

JS Alapok.md

JavaScript alapok

Bevezetés

A JavaScript egy eredetileg webes környezetre tervezett programozási nyelv. A benne írt programokat scripteknek nevezzük, és ezek szöveg formájában tárolhatók, illetve futtathatók - nincs szükség például fordításra. Létezik több engine (motor), ami JavaScriptet futtat, ilyen például a V8, amire a Chromium böngészők és a Node.js is épül.

Környezet

A továbbiakban a következő programokra/kiegészítőkre lesz szükség:

• Node.js (v15.0.1)
• Visual Studio Code
• Live Share
• Windows Terminal

Kimenet és bemenet

A konzolba való írás rend szerint a következő paranccsal történik:

console.log('Hello world!');

Egyszerre több dolgot is kiírhatunk, ezek egymás után fognak megjelenni:

console.log(1, '+', 2, '=', 3);

Beolvasáshoz célszerű a readline modult használni. Ez enyhén bonyolultabb, mint a kiírás, de később pontos magyarázat is jön hozzá.

const readline = require('readline');

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

rl.question('Mi a neved?', nev => {
    console.log('Szervusz,', nev);
});

Változók

Az programok általában adatokkal dolgoznak. Például egy webshop tárolhatja azt, hogy éppen mi van egy-egy felhasználó kosarában, vagy egy chat alkalmazás azt, hogy éppen milyen üzenetet küldtek. Ezt az információt változókban tárolják.

A változó olyan adattároló egység, amelyhez névvel tudunk hozzáférni.

Új változót a let kulcsszóval hozhatunk létre:

let x = 615;
// x a változónk neve, 615 pedig az értéke

Azt is megtehetjük, hogy a változót először csak deklaráljuk, és csak később adunk neki értéket.

let nev;
nev = 'Raffy';

Egy olyan adattároló egységet, amelynek értékét nem módosítjuk, konstansnak nevezünk.

const pi = 3.1415;

Adattípusok

A változókban vagy konstansokban tárolt adatok többfélék lehetnek. Tárolhatunk bennük egész számokat, tizedesszámokat, szöveget, és hasonló dolgokat - egyet, vagy akár többet is.

let egesz = 15, tizedes = 13.7;
// Egy sorban egyszerre több változót is megadhatunk
// A tizedesszámokat pont segítségével adjuk meg

let szoveg = 'A szomszéd macska birtokháborító.';
// A szöveget vagy karakterláncot rend szerint ' vagy " karakterek között adjuk meg

let logikai = true;
// true = igaz, false = hamis

Ha egy változóban több különálló adatot akarunk tárolni, erre tömböt (array) használunk:

let tanulok = ['Raffy', 'ExAtom', 'FleKy', 'Krumpli', 'Atiii', 'Csaleqhx'];

A tömb adott eleméhez sorszámmal (index) férhetünk hozzá. A sorszámot [ ] közé írjuk. Az első elem szorszáma mindig 0!

console.log(tanulok[0]);
console.log(tanulok[1]);
/*
Kimenet:
    Raffy
    ExAtom
*/

Ha tulajdonságokat szeretnénk tárolni, használhatunk objektumokat. Ezek tulajdonságait a következő képpen definiáljuk:

let tanulo = {
    nev: 'Raffy',
    kor: 18,
    kedvenc: 'Történelem',
    jegyek: [10, 9, 9],
    altlag: 9.34
};

Az objektumok tulajdonságaihoz két módon férhetünk hozzá:

tanulo.kedvenc = 'Kiberbiztonság';
// (1) objektum.tulajdonsag

console.log(tanulo['kedvenc']);
// (2) objektum['tulajdonsag']
// Kimenet: Kiberbiztonság

Speciális adattípusok

null        - "semmi", adat hiányának kifejezésére használják
undefined   - "nem létezik", nem definiált tulajdonságoknál találkozhatunk vele
NaN         - "nem egy szám", szám típusú változók értéke érvénytelen művelet elvégzése után

Konverzió

Egy adat típusát átalakíthatjuk más típussá, ha szükséges.

let x = '113'; // 113, de szövegként
let y = Number(x) // átalakítva számmá
y = y + 5; // 118

Ha egy adatot szöveggel "adunk össze" (konkatenáció), az eredmény típusa szintén szöveg lesz.

Operátorok

A változókban tárolt adatokkal műveleteket végezhetünk. Ezek lehetnek matematikai műveletek, vagy más, általános műveletek. A művelet jelölését operátornak, a tagjait pedik operandusoknak nevezzük.

Értékadás

let y = 6;
y = 10;
console.log(y);
// Kimenet: 10, mivel megváltoztattuk az y értékét

Aritmetikai operátorok

let x, y = 4;

x = y + 1;  // x értéke 4 + 1 = 5 lesz
y = y - 10; // y értéke 4 - 10 = -6 lesz
x = x * y;  // x értéke 5 × (-6) = -30 lesz
x = x / 4;  // x értéke (-30) ÷ 4 = 7.5 lesz

y = 5;
x = y % 3;  // x az y (itt 5) 3-mal való osztási maradékát fogja tárolni, azaz 2-t

Ha osztáskor a két operandusból legalább egy tizedesszám, vagy egészek, de nem oszthatóak, az eredmény tizedesszám lesz.

Logikai operátorok

NOT !   - negáció, a kifejezés fordítottját téríti vissza.
AND &&  - logikai "és", csak akkor térít vissza igazat, ha mindkét operandus igaz.
OR  ||  - logikai "vagy", akkor térít vissza igazat, ha legalább egyik operandus igaz.
XOR     - kizáró vagy, JavaScriptben nincs külön operátor rá. Akkor térít vissza igazat, ha csak az egyik operandusa igaz.

Az AND műveletnek előnye van az OR-ral szemben.

q	p	q && p	q || p
1	1	1	1
1	0	0	1
0	1	0	1
0	0	0	0

Feltételes operátorok

Logikai értéket térítenek vissza, feltételekben használják őket.

let bool;
bool = (2 == 2);    // igaz, mivel 2 egyenlő 2-vel
bool = (3 > 5);     // hamis, mivel 3 nem nagyobb, mint 5
bool = (2 < 3);     // igaz, mivel 2 kisebb, mint 3
bool = (5 >= 7);    // hamis, mivel 5 nem nagyobb, vagy egyenlő 7-tel
bool = (12 <= 12);  // igaz, mivel 12 kisebb, vagy egyenlő 12-vel
bool = (13 != 12);  // igaz, mivel 13 nem egyenlő 12-vel

A szigorú feltételes operátoroknál van egy további egyenlőségjel. Ezek figyelembe veszik az operandusok típusait is. Lásd az if utasítást további magyarázatért.

Bit operátorok

Bitek szintjén végzik a műveleteket az operandusokkal. Ritkán használják őket.

NOT - ~
AND - &
OR  - |
XOR - ^
SHL, SHR, SSHR - <<, >>>, >> (bit mutáció)

let x = 3, y = 7;
console.log(x & y); // "és" bit operátor
console.log(x | y); // "vagy" bit operátor
console.log(x ^ y); // kizáró vagy bit operátor

00000011 &  3           00000011 |  3           00000011 ^  3
00000111    7           00000111    7           00000111    7
__________              __________              __________
00000011    3           00000111    7           00000100    4

Shorthand operátorok

Az operátorok többségének létezik shorthand (azaz rövidített) változata. Ezeket célszerű használni, ahol csak lehet, és nem veszít a kód az olvashatóságból. Általános forma: operandus1 operátor= operandus2

let x = 5;
x += 1; // x = x + 1, itt 6
x *= 2; // x = x * 2, itt 12

Speciális operátorok

Egy változó 1-gyel való növelésére vagy csökkentésére a következő kifejezéseket használhatjuk:

let x = 5;
x++; // x értéke 6 lesz
x--; // x értéke ismét 5 lesz

Ha először akarjuk növelni vagy csökkenteni a változó értékét, és utána használni (például összetett kifejezésben), akkor a következő alakot használjuk:

let x = 5, y;
--x;     // x értéke 4 lesz
y = --x; // x értéke 3 lesz, majd y értéke is
// Ha fordítva használnánk:
y = x++; // y értéke 3 lesz, majd x értéke 4 lesz

A typeof operátor visszatéríti az egyetlen operandus primitív típusát.

console.log(typeof 'alma'); // string
console.log(typeof 13);     // number
console.log(typeof []);     // object
console.log(typeof {});     // object

A delete operátor törli egy objektum adott tulajdonságát.

let obj = {
    name: 'Én csak egy kis tulajdonság vagyok, ne bánts! :c',
    magic: 'Abrakadabra, te sügérfejű!'
};
delete obj.magic;
console.log(obj); // { name: '...' }

---

További információ

• JavaScript.info
• W3Schools