Tömbök #

Az ES lehetőséget biztosít számunkra, hogy egy rugalmas szerkezetben tárolassunk több elemet is. Azonban ez a hagyományosan (más nyelvekben ismert) tömbtől jelentősen eltér. Ugyanis amit kapunk valójában egy generikus lista lesz, tehát tulajdonképpen egy tömbön belül bármilyen különböző típusú elemet is tárolhatunk, valamint tetszőlegesen tudjuk bővíteni, vagy az elemeit törölni.

Tömböt az alábbi két módszer bármelyikével létre tudjuk hozni:

const tomb1 = Array();
const tomb2 = []

Elemek hozzáadása #

tomb1.push("elem"); //Vegehez
tomb1.unshift(10); //Elejehez

Elemek törlése #

Az elemek törlése esetén a függvény visszadja nekünk a megfelelő elemet, így azt el tudjuk menteni egy változóba.

let elem1 = tomb2.pop(); //Utolsot
let elem2 = tomb2.shift(); //Elsot

Elemek kiválasztása tetszőleges helyről #

A függvény csak egy másolatot csinál a kiválasztott elemekről és az eredetit tömbben érintetlenül hagyja.

Amire oda kell figyelni itt, hogy a második paraméterünk mindig az utolsó kiválasztanó elem utánit kell megadni.

const FIRST = 1;
const AFTERLAST = 4;

let elemek2 = tomb2.slice(FIRST, AFTERLAST);

Elem törlése tetszőleges helyről #

Adott mennyiségű elem törlése.

const FIRST = 1;
const QTY = 3;

let elemek1 = tomb1.splice(FIRST, QTY);

Elemszám lekérdezése #

let arraySize = tomb.length;

Elemek rendezése #

tomb1.sort();

Elemek sorrendjének megfordítása #

tomb2.reverse();

Saját rendező függvény írása #

function compareEgyszeru(a, b){
    if(a > b){
        return 1;
    }
    else if( a < b)
    {
        return -1;
    }
    else{
        return 0;
    }
}

function compareOsszetett(a, b){
    if(a.tulajdonsag > b.tulajdonsag){
        return 1;
    }
    else if( a.tulajdonsag < b.tulajdonsag)
    {
        return -1;
    }
    else{
        return 0;
    }
}

Spread operátor #

ES6 óta lehetőségünk van arra, hogy a tömbünk elemeit "kibonttassuk" a böngészővel. Ez pedig úgy, fog nekünk kinézni, hogy ahol több elemet vár az függvényünk, ott a ... segítségével szépen egyesével fogja a tömb elemeit kipakolni az ES.

const eredeti = [1,2,3];

const operatorNelkul = [eredeti[0],eredeti[1],eredeti[2]];
const operatorral = [...eredeti];

A második esetben látjuk, hogy egy nagyobb tömbb esetén sokkal egyszerűbb és kényelmesebb megoldás.

Tárolás #

Az előző szekcióban láttuk, hogy egy tömb másolása nem a legszebb, de miért így másoljuk le a tömböt?

const masolat = eredeti;

Nem elég ez ↑?

Az előző kóddal az lesz a problémánk, hogy amikor létrehozzuk a tömböt, akkor valójában az eredeti nevű változónk nem a tömböt tárolja el, hanem egy mutatót a tömbre. Ezért, ha lemásoljuk ami a változóban van, akkor tulajdonképpen ezt a mutatót másoljuk le, így mindekettő változó ugyanazt a tömböt fogja nézni és változtatni.

Destrukció tömbök esetén #

Lehetőségünk van, arra, hogy index szerint külön változókra, vagy tömbre bontsuk szét az eredeti tömbünket.

Ezt a következő módon tudjuk megtenni:

const [lastName, firstName] = "Papp Zsombor".split(' ');

A fenti esetben a lastName értékel "Papp" és a firstName értéke "Zsombor" lett. Innentől kezdve a firstName és a lastName teljesen önálló változóként használhatóak.

A helyzet akkor érdekes, ha több adatunk is van, de nem szeretnénk, hogy azok elvesszenek, hanem szeretnénk őket összegyűjteni.

const [lastName,firstName, ...rest] = "Papp Zsombor Frontend Developer @ Mozilla".split(' ');

Ekkor az két elemünk esetén változatlan a dolog. Az érdekes a ...rest lesz, ugyanis a ... azt mondja meg, hogy szeretnénk minden maradékot a rest nevű változóban összegyűjteni.

Tehát a rest értéke ez lesz: ["Frontend","Developer","@","Mozilla"].

\pagebreak