# Változók, utasítások, kifejezések, kommentek, Operátorok és precedencia.

JavaScriptben (ahogy más programozási nyelvek esetén) praktikus okokból a kommenteket egyrészt az egyes programrészek rövid bemutatására használjuk. Másrészt pedig a kommentbe helyezett programsorok nem hajtódnak végre, így tesztelés céljából is praktikus a használata. Megkülönböztetjük az egysoros és többsoros kommentelési legetőségeket. Az egysoros kommentek az alábbi jellel kezdődnek: //. Bármi amit utána írunk, nem hajtódik végre. A többsoros kommentek az alábbi jelek közé kell szúrni: /* és */. Bármi Bármi amit a két jel közé szírunk be, nem hajtódik végre.

// Egysoros komment.

/*
Többsoros 
komment.
*/

A literálokat arra használjuk a JavaScriptben (sok más programozási nyelhez hasonlóan), hogy fix értékeket fejezzünk ki. Néhány típus ezek közül:

• Integer (egész)

• Floating point (lebegőpontos)

• Boolean (logikai)

• String (sztring)

• Regular expression (reguláris kifejezés)

• Array (tömb)

• Object (objektum)

Az egész literálókat bináris, decimális, oktális, valamint hexadecimális formában fejezhetjük ki. Szintaxisuk (a megkötésekkel együtt )a következőképpen néz ki:

• bináris forma: az első két karaktere (prefixum) 0b vagy 0B; karakterei állhatnak (0-1) számokból.

• oktális forma: az első két karaktere (prefixum) 0o vagy 0O; karakterei állhatnak (0-7) számokból.

• decimális forma: az első karakter nem lehet 0 szám; karakterei állhatnak (0-9) számokból.

• hexadecimális forma: az első két karaktere (prefixum) 0x vagy 0X; karakterei állhatnak (0-9) számokból és (a-f vagy A-F) betűkből.

0b1111 
// példa bináris literálra
017 
// példa oktális literálra
17 
// példa decimális literálra
0xF 
//példa hexadecimális literálra

A lebegőpontos literálok olyan nem egész számokat fejeznek ki, melyek a következő részekből tevődik össze (balról jobbra olvasva):

• decimális egészrész, ahol előjelek (+ vagy -) szerepelhetnek.

• tizedesjel (.)

• decimális törtrész

• exponens rész; (e vagy E) karakter után decimális egészrész (+ vagy -) előjellel

3.14  // példa lebegőpontos számra
−1.602176487E−19  
// példa lebegőpontos számra

A sztring literálok szimpla '', vagy dupla "" idézőjelek közé írt, tetszőleges hosszúságú karaktersorozatot takar. Tetszőleges Unicode karaktert meg lehet jeleníteni, viszont ezeket előtte le kell védeni (\) visszafele jellel. Például a (\n) sortörés speciális karakter. A JavaScript szimpla idézőjel közötti számokat szám, a dupla idézőjel közötti számokat pedig sztring típusúként fogja kezelni. A JavaScriptben a literálokra ugyanazokat a metódusokat használhatjuk, mint a String objektum megfelelőikre. A két forma közti különbség az, hogy az előbbihez nem lehet új tulajdonságokat rendelni. Ennek oka, hogy a rajtuk végzett tetszőleges művelet során valójában létrejön ideiglenesen egy String objektum, melynek lényegi része megegyezik a literál tartalmával. Magukon a String objektumokon sem végezhető módosítás, ehelyett a műveletek egy teljesen új és módosított objektumot adnak vissza.

'Ez egy sztring lirerál'  
// példa sztring literálra
"Ez egy sztring lirerál"  
// példa sztring literálra
"Ez egy sztring literál".length  
/* példa sztring literálból ideiglenesen sztring objektummá alakíkításról, 
hogy ismét sztring literált kapjunk végeredményként, mely a 22 szám */
'22'.
"22".

A gyakran mintának nevezett reguláris kifejezés (regular expression) a jelsorozatok, stringek egy halmazát határozza meg. Ezt a mintát // közé szoktuk beszúrni.

var regulariskifehezes = /ab+c/;

Egy tömbi literál egy vesszővel elválasztott kifejezések listája, ahol minden egyes kifejezés a tömb egy-egy eleme és amiket szögletes zárójelek ([]) közé ékelünk be. Az elemek típusai tetszőlegesek lehetnek, azaz egy tömbön belül eltérő típusú adat is előfordulhat. Amikor egy tömb literált inicializálunk konkrét értékekkel, akkor a tömb hossza meg fog egyezni a benne található elemek számával. Majd a későbbiekben látni fogjuk, hogy ez egy összetett adattípus, melynek meghívható metódusai vannak (objektum) és tömbi literál formában lehet az objektum tömböt inicializálni.

var elemek = ["elso elem", "masodik elem", "harmadik elem"];

Az objektum literál egy vesszővel elválasztott tulajdonság-érték párosokból álló lista, amiket kapcsos zárójelek ({}) közé ékelünk be.

var elemek = {egy: "egyik elem", ketto: "másik elem", harom: "harmadik elem"};

JavaScriptben három formáját ismerjük a deklarálásnak:

• var - ezzel a kulcsszóval deklarálhatunk egy változót, melynek értékét a program futása közben módosítani lehet és opcionálisan inicializálhatunk egy tetszőleges típusú kezdőértékkel.

• let - ezzel a kulcsszóval egy blokk hatókörben érvényes lokális változót deklarálhatunk, melyet opcionálisan inicializálhatunk egy tetszőleges típusú kezdőértékkel.

• const - ezzel a kulcsszóval deklarálhatunk egy kizárólag olvasható, melynek értékét a program futása közben nem lehet módosítani és kötelező inicializálni egy tetszőleges típusú kezdőértékkel.

A változókat tekinthetjük egy olyan absztraktciónak a programon belül, melyhez opcionálisan tetszőleges típusú értéket rendelhetünk. A változó nevét azonosítónak hívjuk és az elnevezés formája szabályokhoz van kötve. A JavaScriptben az azonosítók érzékenyek a kis és nagybetűkre, bármilyen Unicode betűt tartalmazhatnak (például á, é, ő, ű, α, ß, ...), viszont számmal nem kezdődhetnek.

A változókat láthatóságuk (scope) szempontjából két csoportra lehet felosztani:

• lokális

• globális

A globális szó lényegében azt takarja, hogy a változó hatóköre az egész programja kiterjedt, míg az utóbbi hatóköre gyakran csak egy függvényen belül értelmezhető. A lokális csoport tovább bontható az alábbi változókra:

• blokk szintű (a let kulcsszóval deklarált)

• függvényszintű (var szóval definiált)

Egy változót többször is deklarálhatunk ugyanazzal az elnevezéssel, ez különösebben nem jelent problémát.

// példa globális változóra

var szamlalo = 0;

function szamlalovisszater(){
	return szamlalo;
};

szamlalovisszater(); 
// a szamlalo változó globálisan van értelmezve

// példa lokális változóra

function allapotbeallit(){
	var allapot = "be";
	console.log(allapot);
}

allapotbeallit();  
// az állapot változó lokálisan van értelmezve

console.log(változó);  
// undefined - kívülről nem tudjuk meghivatkozni az állapot változót

A dolgot némileg tovább árnyalja az a tény, ha egymásba ágyazunk két függvényt, a külső függvényben deklarálok egy lokális változót és a belsőbe meghívva értelmezve van, viszont a legkülső függvények kívül továbbra sincs értelmezve. Csakis tőlünk (programozóktól) függ, hogy melyik hatókör meddig érhet.

var ev = 20;
  if (ev > 12){
    var kutyaev = ev * 7;
    console.log(`A te kutyád ${kutyaev} éves kutyaévekben`); 
	// A te kutyád 140 éves kutyaévekben
  }

Globálisan azért volt elérhető a kutyaév változó, mert a var kulcsszó által deklarált változók hatókörét a függvények határozzák meg, nem egy függvényen belül volt definiálva. Ezzel szemben a let kulcsszóval definiált változók hatókörét éppp a {} blokkok határozzák meg, a függvények nem.

var ev = 20
  if (ev > 12){
    let kutyaev = ev * 7;
    console.log(`A te kutyád ${kutyaev} éves kutyaévekben`); 
	// Uncaught ReferenceError: kutyaev is not defined.
  }

A konstans értékét a program futása közben nem lehet módosítani. Valamilyen tetszőleges típusú kezdőértékkel inicializálni kell. A konstans nevére ugyanazon szabályok érvényesek, mint a változó nevére. A hatókör szabályai lényegében a let kulcsszóval deklarált változók szabályaival egyeznek meg. Meg kell jegyeznünk, hogy ugyanolyan hatóköri szinten lévő, megegyező nevű függvényt és konstanst nem deklarálhatunk, különben hibát fog okozni.

const konstans = 20;

A kifejezések azon részei a kódnak, melyek valamilyen műveletet végeznek el és a művelet eredményét adják vissza, vagy valamilyen értéket képviselnek. Vegyük példának az y = 26 kifejezést, ahol az y változóhoz hozzárendeljük a 26 értéket a = operátorral. Vegyünk egy másik példát, konkrétan a 26-10 kifejezést, ahol a - operátor a baloldali értékből kivonja a jobboldali értéket anélkül, hogy a kapott értéket hozzárendelné egy változóhoz. Ezek a kifejezések lehetnek:

• Aritmetikai kifejezések: egy számot értékelnek ki (az aritmetikai operátorok segítségével).

• String kifejezések: egy sztringet értékelnek ki (a string operátorok segítségével).

• Logikai kifejezések: egy logikai értéket értékelik ki (a Boolean (logikai) operátorok segítségével).

• Elsődleges kifejezések: alapvető kulcsszavak és kifejezések.

• Baloldali kifejezések: a baloldali értékek a hozzárendelés rendeltetési helye.

# Elsődleges kifejezések

# Baloldali kifejezések

JavaScriptben, mint megannyi más programozási nyelvben is definiálva vannak operátorok, melyek segítségével értéket lehet rendelni az egyes változókhoz, össze tudun hasonlítani értékeket, különböző jellegű műveleteket tudunk végrehajtani, stb. A JavaScriptben előfordulnak egy (az operátor előtt vagy után helyezkedik el egy operandus), illetve két (az operátor két oldalán helyezkednek el az operandusok) operandusu operátorok. Továbbá egy speciális ternáris operátort, a feltételes operátort. Ezek az operátorok lehetnek:

• Értékadó

• Összehasonlító

• Aritmetikai

• Bitenkénti

• Feltételes

• Logikai

• Vessző

• Unáris

• Kapcsolat

Az értékadó operátor hozzárendel az operandusához egy adott típusú értéket. Ilyen operátor az egyensőségjel (=) és a koncenciója szerint a bal oldali változóhoz hozzárendeli a jobboldali értéket.

var x=1;
var y;
x=y;

Az összehasonlító operátor összehasonlít két operandushoz rendelt értéket és igaz logikai értékkel tér vissza ha igen, egyébként hamissal. Az összehasonlítandó értékek lehetnek számok, objektumok, logikai értékek vagy stringek. Az utóbbiakat a lexikografikus értékük szerint történik az ellenőrzés. Azon értékek szerinti összehasonlításon túl azt is megvizsgálhatjuk, hogy a típus szerint is megegyeznek. Ha igen igaz logikai értékkel tér vissza, egyébként hamissal. Mindegyik operátorhoz hozzá lehet rendelni konvenció szerint baloldalt a tagadó (!) jelet, ami a visszatérő logikai érték negátját képezi.

Az aritmetikai operátor az operandusok számértékeire hatva visszatér egy másik számértékkel. Ide tartozik az összeadás (+), a kivonás (-), a szorzás (*), az osztás (/) és a modulo (%).

var z;
z=3+4; 
// összeadás
z=3-4; 
// kivonás
z=2*3; 
// szorzás
z=2/3; 
// osztás
z=3%2; 
// modulo
z=3**2; 
// hatványképzés (hatványalap**hatványkitevő)
var x,y;
x=5; 
y=++x; 
// preinkrement
x=5;
y=x++; 
// posztinkrement
x=5;
y=--x; 
// predekrement
x=5;
y=x--; 
// predekrement

A bitenkénti operátorok bit szintjén végzik el a számításokat.

A feltételes (ternáris) az egyetlen olyan JavaScript operátor, aminek három operandusa van. Két értékből (érték 1 és érték2) egyet ad vissza annak a függvényében, hogy teljesül-e a feltétel. Amennyiben a feltétel teljesül (igazzal tér vissza), az operátor az érték1-el tér vissza, egyébként meg érték2-vel. Szintaxisa a következő:

feltétel ? érték1 : érték2

A lenti példában az állapot nevű változóhoz a felnőtt vagy fiatal érték rendelődik annak a függvényében, hogy a feltételben az évhez rendelt érték nagyobb, vagy egyenlő, mint a feltételben megadott 18 értékkel:

var állapot = ( év >=18 ) ? 'felnőtt' : 'fiatal';

Az unáris operátorokat azon operátoroknak nevezzük, melyek csupán egyetlen operandussal rendelkeznek.

A kapcsolati operátorok összehasonlítják az operandusaikat és valamilyen logikai típusú értékkel (igaz vagy hamis) térnek vissza annak a függvényében, hogy az összehasonlítás feltétele miképp teljesül.

Az operátorok precendenciája meghatározza a műveleti sorrendet, azaz, hogy melyik hajtódjon végre hamarabb, és melyik később. Zárójelek használatával ezt a sorrendet felülírhatjuk. Egy listában felsoroltunk néhány fontosabb operátort a legnagyobb precedenciától a legkisebbig: