Futtassa a fenti kódot. Megkapja a rendelést 1, 15, 2. Ennek az az oka, hogy a módszer mindent karakterlánccá alakít át, és az alapértelmezett lexikográfiai sorrendet használja.

Az előző cikkben arról beszéltünk, hogy mi ez és hogyan kell vele dolgozni. Ebben a cikkben fogunk beszélni többdimenziós tömb.

Ez egy tömb, amely egy vagy több elemet tartalmaz, amelyek szintén tömbök. A hirdetés mélységétől függően, különösen, lehet hívni kétdimenziós tömb(2 szint) sem háromdimenziós tömb(3 szint) sem négydimenziós(4 szint) és így tovább.

A legnépszerűbb az egydimenziós tömb után a leggyakrabban használt kétdimenziós tömb. Részletesebben tanulmányozzuk.

Mint látható, a kétdimenziós tömb elemei egydimenziós tömbök. Ha ezek az egydimenziós tömbök több tömböt tartalmaznának, akkor az arr tömb már háromdimenziós lenne.

Példaként hozzunk létre három egyszerű tömböt, és töltsük fel azokat adatokkal. Az elsőt páros számokkal, a másodikat páratlan számokkal, a harmadikat pedig tetszőleges adatokkal töltjük fel.

// Három üres tömb deklarálása var evenNumbers = new Array (); // k változó - tömbindexeknél páros számok var k = 0; var páratlan számok = új tömb (); // n változó - tömbindexekhez páratlan számok var n = 0; var adatok = new Array ("autó", "repülőgép", igaz, 89, "m"); // Töltse ki a páros számok tömböt páros számokkal a (var i = 1; i

Annak érdekében, hogy lássa, mi van a tömbön belül, használhat egy eszközt, például konzol.

Például látni szeretnénk egy páratlan számú tömb tartalmát. Ehhez írja be a következő sort az alábbi kódba:

Console.log (páratlan számok);

Az eredmény megtekintéséhez meg kell nyitnia konzol a böngészőben... A Google Chrome-ban ez a következőképpen történik: kattintson jobb gombbal az oldalra, és a helyi menüből válassza ki az utolsó „Kód megtekintése” lehetőséget, azaz az ellenőrzőt. Az angol verzióban ezt az opciót Inspect -nek hívják.

És alatta megjelenik a fejlesztői eszköztár. Ebben el kell mennie a Konzol fülre.

Most annak érdekében hozzon létre egy kétdimenziós tömböt, deklarálnia kell, és hozzá kell adnia a fent létrehozott egydimenziós tömböket.

// Kétdimenziós tömb deklarálása twoDimens, és kitöltése var twoDimens = new Array (páros számok, páratlan számok, adatok); console.log (twoDimens);

Lássuk ennek a tömbnek a tartalmát a konzolban.

kétdimenziós tömbön keresztül iterálva

Először is tanuljunk hogyan lehet elérni egy kétdimenziós tömb elemeit.

Az egyes tömbökhöz hasonlóan az elemekhez indexük is hozzáfér.

Például jelenítsük meg az elemet a 3. indexben egy páratlan számú tömbből (páratlan számok). Az oddNumbers egydimenziós tömb indexe a twoDimens kétdimenziós tömbben egy (1).

Document.write ("A páratlan számok tömbjének 3 -as indexű eleme:" + twoDimens); Elem: 7

A twoDimens tömbben az 1. indexben található elemre hivatkozunk. Az indexben lévő elem a páratlan számok tömbje. És ebben a tömbben már elérjük a 3 -as indexű elemet, ami a 7 -es szám.

Most térjünk rá magára a kérdésre hogyan lehet iterálni egy kétdimenziós tömbön.

A kétdimenziós tömb feletti hurok dupla hurok segítségével történik. Például iteráljuk át a kétdimenziós tömbünket.

A (var i = 0; i< twoDimens.length; i++){ for(var j = 0; j < twoDimens[i].length; j++){ document.write("

Elem indexdel " + i +" " + j +" egyenlő: " + kétdimenziós [i] [j] +"

Az első ciklusban a kétDimens tömb felett iterálunk. A második ciklusban már iteráljuk magát az elemet (tömböt). Először is, az i változó 0 -val egyenlő. Ezért a második ciklusban először iteráljuk az első evenNumbers tömböt, amelynek indexe 0. És már a második cikluson belül is elérjük ennek a tömbnek az elemeit. Így: twoDimens [j]. Ahol j 0 -tól a páros számok tömb hosszáig terjed.

Miután megismételtük az első tömb elemeit, visszatérünk az első ciklushoz, növeljük az i változót, és folytatjuk az iterációt a páratlan számok második tömbjén, amelynek indexe 1. tömb twoDimens.

Most nézzük a keresés eredményét:

Csak erről akartam beszélni ebben a cikkben. Most már tudja, hogyan hozhat létre kétdimenziós tömböt, hogyan férhet hozzá egy kétdimenziós tömb elemeihez, és hogyan ismételheti meg a kétdimenziós tömböt. Remélem minden világos volt. Sok sikert kívánok!

Tömbök

Sor rendezett értékgyűjtemény. A tömb értékeit elemeknek nevezzük, és minden elemet a tömb numerikus pozíciója, indexnek nevezünk. A JavaScript tömbjei típustalanok: a tömb elemei bármilyen típusúak lehetnek, és ugyanazon tömb különböző elemei különböző típusúak lehetnek. A tömb elemek akár objektumok vagy más tömbök is lehetnek, így bonyolult adatstruktúrákat hozhat létre, például objektumokat és tömbtömböket.

A JavaScript tömbindexei nulla alapúak és 32 bites egész számokat használnak-a tömb első elemének indexe 0. A JavaScript tömbök dinamikusak: szükség szerint növekedhetnek és zsugorodhatnak; nincs szükség rögzített méretű tömbök deklarálására azok létrehozásakor, vagy a memória újbóli kiosztására, amikor átméretezik őket.

A JavaScript tömbjei az objektumok speciális formája, és a tömbindexek alig többet jelentenek, mint a tulajdonságnevek, amelyek véletlenül egész számok.

Tömbök létrehozása

A tömb létrehozásának legegyszerűbb módja a literál, amely egy egyszerű vesszővel elválasztott tömbelemek listája szögletes zárójelben. A tömb literál értékeinek nem kell konstansoknak lenniük - ezek bármilyen kifejezések lehetnek, beleértve az objektum literálokat is:

Var üres =; // Üres tömb var számok =; // Tömb öt numerikus elemmel var misc = [1.1, igaz, "a",]; // 3 különböző típusú elem + záró vessző var bázis = 1024; var tábla =; // Tömb változókkal var arrObj = [,]; // 2 tömb belsejében, amelyek objektumokat tartalmaznak

A tömb literális szintaxisa lehetővé teszi egy opcionális záró vessző beszúrását, azaz A literal [,] egy tömbhöz illeszkedik, nem pedig hárommal.

Egy tömb létrehozásának másik módja a konstruktor hívása Tömb ()... A konstruktor háromféleképpen hívható meg:

Hívja a konstruktőrt érvek nélkül:

Var arr = új tömb ();

Ebben az esetben a literálnak megfelelő üres tömb jön létre.

Hívja meg a konstruktort egyetlen numerikus argumentummal, amely megadja a tömb hosszát:

Var arr = új tömb (10);

Ebben az esetben a megadott hosszúságú üres tömb jön létre. Az Array () konstruktor hívásának ezen formája használható memória előzetes lefoglalására egy tömbhöz, ha elemeinek száma előre ismert. Ne feledje, hogy ez nem tárol semmilyen értéket a tömbben.

Kifejezetten adja meg a konstruktorhívás első két vagy több tömb elemének vagy egy nem numerikus elemének értékeit:

Var arr = új tömb (5, 4, 3, 2, 1, "teszt");

Ebben az esetben a konstruktor argumentumai az új tömb elemeinek értékeivé válnak. A tömb literálok használata szinte mindig könnyebb, mint az Array () konstruktor ilyen használata.

Tömb elemek olvasása és írása

A tömb elemek a kezelő segítségével érhetők el. A zárójelek bal oldalán tömbreferenciának kell lennie. Egy tetszőleges kifejezésnek, amely nem negatív egész értéket ad vissza, zárójelben kell lennie. Ez a szintaxis alkalmas egy tömb elem értékének olvasására és írására egyaránt. Ezért az alábbi JavaScript utasítások mindegyike érvényes:

// Egy tömb létrehozása egy elemmel var arr = ["world"]; // A 0. tétel olvasása var value = arr; // Írja be az értéket az 1 elembe arr = 3,14; // Írja be az értéket a 2 elembe i = 2; arr [i] = 3; // Írjon értéket a 3. elemre arr = "hello"; // Olvassa el a 0. és 2. tételt, írja be az értéket a 3. tételbe arr] = arr;

Hadd emlékeztessem önöket arra, hogy a tömbök speciális típusú objektumok. A tömb elemek eléréséhez használt szögletes zárójel pontosan ugyanúgy működik, mint az objektum tulajdonságainak eléréséhez használt szögletes zárójel. A JavaScript -értelmező a zárójelben lévő numerikus indexeket karakterláncokká alakítja át - az 1. index "1" karakterlánccá válik -, majd a karakterláncokat tulajdonságnévként használja.

Semmi különös nincs abban, hogy a numerikus indexeket karakterláncokká alakítjuk át: ugyanez történhet normál objektumokkal is:

Var obj = (); // Egyszerű objektum létrehozása obj = "one"; // Indexelje egész számokkal

A tömbök sajátossága, hogy nem negatív egész tulajdonságtulajdonságok használatakor a tömbök automatikusan meghatározzák a tulajdonság értékét hossz... Például az arr tömböt egyetlen elemmel hozták létre fent. Ezután az elemekhez értékeket rendeltek az 1, 2 és 3 indexekkel. E műveletek eredményeképpen a tömb hossztulajdonságának értéke megváltozott és egyenlő lett 4 -gyel.

Világosan meg kell különböztetni a tömb indexeit és az objektumtulajdonságokat. Minden index tulajdonságnév, de csak az egész nevű tulajdonságok indexek. Minden tömb objektum, és tetszőleges névvel adhat hozzá tulajdonságokat. Ha azonban megérinti azokat a tulajdonságokat, amelyek tömbindexek, a tömbök úgy reagálnak, hogy szükség szerint frissítik a length tulajdonság értékét.

Vegye figyelembe, hogy a negatív és a nem egész számok tömbindexként használhatók. Ebben az esetben a számokat karakterláncokká alakítják át, amelyeket tulajdonságnevekként használnak.

Tömb elemek hozzáadása és eltávolítása

Már láttuk, hogy a legegyszerűbb módja annak, hogy elemeket adjunk hozzá egy tömbhöz, ha értékeket rendelünk az új indexekhez. A módszerrel egy vagy több elemet is hozzáadhat a tömb végéhez nyom ():

Var arr =; // Üres tömb létrehozása arr.push ("zero"); // Érték hozzáadása a véghez arr.push ("one", 2); // Adjon hozzá még két értéket

Hozzáadhat egy elemet a tömb végéhez is, ha értéket rendel hozzá az arr elemhez. Ha egy elemet egy tömb elejére kíván beszúrni, használhatja a módszert váltás nélküli ()és a tömb meglévő elemei a magasabb indexekre tolódnak.

A tömb elemeit a törlés operátorral törölheti, például az objektumok szokásos tulajdonságait:

Var arr =; törlés arr; 2 in arr; // hamis, a tömb 2. indexe undefined arr.length; // 3: a delete operátor nem változtatja meg a tömb hossz tulajdonságát

Az elem eltávolítása hasonló (de kissé eltérő), ha az elemhez nem definiált értéket rendelnek. Ne feledje, hogy a delete operátor alkalmazása egy tömb elemére nem változtatja meg a length tulajdonság értékét, és nem mozdul lefelé a magasabb indexű elemekkel, hogy kitöltse az elem törlése után maradt űrt.

Ezenkívül lehetőség van arra, hogy a tömb végén lévő elemeket eltávolítsuk, ha egyszerűen új értéket rendelünk a length tulajdonsághoz. A tömböknek van módszere pop ()(ellentétben a push () -al), amely 1 -gyel csökkenti a tömb hosszát, és visszaadja az eltávolított elem értékét. Van egy módszer is műszak ()(ellentétben az unshift () -el), amely eltávolítja az elemet a tömb elején. A törlés operátorral ellentétben a shift () metódus minden elemet egy pozícióval lejjebb helyez az aktuális indexük alatt.

Végül van egy többcélú módszer összeillesztés (), amely lehetővé teszi tömb elemeinek beillesztését, törlését és cseréjét. Megváltoztatja a length tulajdonság értékét, és szükség szerint eltolja a tömb elemeit alacsonyabb vagy magasabb indexekkel. Mindezeket a módszereket egy kicsit később tárgyaljuk.

Többdimenziós tömbök

A JavaScript nem támogatja az "igazi" többdimenziós tömböket, de jó munkát végez, hogy utánozza azokat tömbök tömbjeiből. Ahhoz, hogy tömb tömb adatelemét elérje, elegendő kétszer használni az operátort.

Tegyük fel például, hogy a változó mátrix számtömb tömb. Az [x] mátrix minden eleme számtömb. Az [x] [y] kifejezési mátrix segítségével elérheti a tömb adott számát. Az alábbiakban egy konkrét példa látható, ahol kétdimenziós tömböt használunk szorzótáblaként:

// Többdimenziós tömb létrehozása var table = new Array (10); // A táblázatban 10 sor található (var i = 0; i

Tömbosztály -módszerek

Az ECMAScript 3 szabvány számos kényelmes funkciót határoz meg az Array.prototype részeként a tömbökkel való munkavégzéshez, amelyek bármely tömb módszereként elérhetők. Ezeket a módszereket a következő alfejezetekben mutatjuk be.

Csatlakozás () metódus

Az Array.join () metódus a tömb összes elemét karakterláncokká alakítja, összefűzi és visszaadja a kapott karakterláncot. Egy opcionális argumentum átadható a metódusnak egy karakterlánccal, amelyet az eredménylánc elemeinek elválasztására használnak. Ha nincs megadva elválasztó karakterlánc, vesszőt használunk. Például a következő részlet az "1,2,3" karakterláncot eredményezi:

Var arr =; arr.join (); // "1,2,3" arr.join ("-"); // "1-2-3"

Fordított () módszer

Az Array.reverse () metódus megfordítja a tömb elemeinek sorrendjét, és visszaad egy átrendezett tömböt. A permutáció közvetlenül az eredeti tömbön történik, azaz ez a módszer nem hoz létre új tömböt átrendezett elemekkel, hanem átrendezi azokat egy már meglévő tömbben. Például a következő részlet, amely a reverse () és a join () metódusokat használja, a "3,2,1" karakterláncot eredményezi:

Var arr =; arr.reverse (). join (); // "3,2,1"

Rendezés () módszer

Az Array.sort () metódus rendezi az eredeti tömb elemeit, és visszaadja a rendezett tömböt. Ha a sort () metódust argumentumok nélkül hívják meg, a rendezés betűrendben történik (összehasonlításképpen az elemeket szükség esetén ideiglenesen karakterláncokká alakítják át). A nem definiált elemek a tömb végére kerülnek.

Az összehasonlítási függvényt argumentumként adhatja át a rendezéshez (), hogy bármilyen más nem ábécé sorrendben rendezhesse. Ez a függvény beállítja, hogy két argumentuma közül melyik legyen az első a rendezett listában. Ha az első argumentumnak meg kell előznie a másodikat, az összehasonlító függvénynek negatív számot kell visszaadnia. Ha az első argumentum a második követése a rendezett tömbben, akkor a függvénynek nullánál nagyobb számot kell visszaadnia. És ha a két érték egyenértékű (azaz a sorrendjük nem fontos), akkor az összehasonlító függvénynek 0 -t kell adnia:

Var arr =; arr.sort (); // Ábécé sorrend: 1111, 222, 33, 4 arr.sort (függvény (a, b) (// Numerikus sorrend: 4, 33, 222, 1111 return ab; // Visszaadja a 0 // értéket a fajtától függően rendelés a és b)); // Rendezés hátra, a legmagasabbtól a legalacsonyabb arr.sort (függvény (a, b) (visszatérés b-a));

Figyelje meg, milyen kényelmes egy névtelen függvény használata ebben a részletben. Az összehasonlító funkciót csak itt használják, így nem kell nevet adni.

A concat () módszer

Az Array.concat () metódus új tömböt hoz létre és ad vissza, amely tartalmazza az eredeti tömb elemeit, amelyeken a concat () metódust hívták, és minden argumentum értékét átadta a concat () metódusnak. Ha ezen argumentumok egyike tömb, akkor annak elemei hozzáadódnak a visszaadott tömbhöz. Meg kell azonban jegyezni, hogy nincs tömb rekurzív konverzió tömbből egydimenziós tömbbe. A concat () metódus nem módosítja az eredeti tömböt. Az alábbiakban néhány példa látható:

Var arr =; arr.concat (4, 5); // Visszaadja az arr.concat (); // Visszaadja arr.concat (,) // Visszaadja arr.concat (4,]) // Visszaadja]

Szelet () módszer

Az Array.slice () metódus a megadott tömb egy szeletét vagy altömbjét adja vissza. A módszer két argumentuma határozza meg a visszaadott rész kezdetét és végét. A visszaadott tömb tartalmazza az első argumentumban számozott elemet és az összes további elemet a második argumentumban számozott elemig (de nem beleértve).

Ha csak egy argumentum van megadva, a visszaadott tömb minden elemet tartalmaz a kezdő pozíciótól a tömb végéig. Ha bármelyik argumentum negatív, akkor az elemszámot adja meg a tömb végéhez viszonyítva. Tehát a -1 argumentum a tömb utolsó elemének felel meg, a -3 argumentum pedig a tömb harmadik elemének a végétől. Íme néhány példa:

Var arr =; arr.szelet (0,3); // Visszaadja az arr.slice (3); // Visszaadja az arr.slice (1, -1); // Visszaadja az arr.slice (-3, -2); // Vissza fog térni

Splice () módszer

Az Array.splice () metódus egy általános módszer, amely beszúr vagy eltávolít egy tömb elemeit. A szelet () és a concat () metódusokkal ellentétben a splice () metódus módosítja az eredeti tömböt, amelyen meghívták. Ne feledje, hogy a splice () és a szelet () metódusoknak nagyon hasonló a neve, de teljesen más műveleteket hajtanak végre.

A splice () metódus eltávolíthatja az elemeket egy tömbből, új elemeket szúrhat be, vagy mindkettőt egyszerre végezheti el. A tömb elemeit szükség szerint eltoljuk, hogy a beillesztés vagy törlés után egy összefüggő szekvencia alakuljon ki.

A splice () metódus első argumentuma határozza meg a tömb pozícióját, ahonnan beszúrni és / vagy törölni kell. A második argumentum meghatározza a tömbből eltávolítandó (kivágott) elemek számát. Ha a második argumentum kihagyásra kerül, a tömb minden eleme eltávolításra kerül a megadott tömbtől a tömb végéig. A splice () metódus az eltávolított elemek tömbjét, vagy (ha egyik elemet sem távolította el) egy üres tömböt ad vissza.

A splice () metódus első két argumentuma határozza meg az eltávolítandó tömb elemeket. Ezeket az érveket tetszőleges számú további argumentum követheti, amelyek meghatározzák a tömbbe illesztendő elemeket, kezdve az első argumentumban megadott pozíciótól.

Var arr =; arr.selyem (4); // Visszaadja arr = arr.splice (1,2); // Visszaadja az arr = arr.splice (1,1); // Vissza fog térni; arr = arr =; arr.slicice (2,0, "a", "b"); // Vissza fog térni; arr =

A push () és a pop () metódusok

A push () és a pop () metódusokkal tömbökkel, például veremekkel dolgozhat. A push () metódus egy vagy több új elemet ad hozzá a tömb végéhez, és visszaadja annak új hosszát. A pop () metódus az ellenkező műveletet hajtja végre - eltávolítja a tömb utolsó elemét, csökkenti a tömb hosszát, és visszaadja az eltávolított értéket. Vegye figyelembe, hogy mindkét módszer módosítja az eredeti tömböt, ahelyett, hogy módosított másolatot hozna létre.

Az unshift () és shift () metódusok

Az unshift () és shift () metódusok nagyjából ugyanúgy viselkednek, mint a push () és a pop (), azzal a különbséggel, hogy az elemeket a tömb elején helyezik el és távolítják el, nem pedig a végén. Az unshift () metódus a meglévő elemeket a nagyobb indexek felé tolja el, hogy helyet biztosítson, hozzáadja az elemet vagy elemeket a tömb elejéhez, és visszaadja a tömb új hosszát. A shift () metódus eltávolítja és visszaadja a tömb első elemét, az összes következő elemet egy pozícióval lejjebb tolva elfoglalja a tömb elején felszabadult helyet.

Utolsó frissítés: 2018.04.09

A tömbök adatkészletekkel való használatra szolgálnak. Az új tömb () kifejezés egy tömb létrehozására szolgál:

Var myArray = új tömb ();

Van egy rövidebb módja is a tömb inicializálásának:

Var myArray =;

Ebben az esetben üres tömböt hozunk létre. De hozzá lehet adni kezdeti adatokat is:

Var emberek = ["Tom", "Alice", "Sam"]; console.log (emberek);

Ebben az esetben a myArray három elemet tartalmaz. Grafikailag a következőképpen ábrázolható:

Az indexeket arra használják, hogy egy tömb egyes elemeire hivatkozzanak. A számlálás nulláról indul, vagyis az első elemnek 0, az utolsónak pedig 2 -es indexe lesz:

Var emberek = ["Tom", "Alice", "Sam"]; console.log (emberek); // Tom var person3 = emberek; // Sam console.log (személy3); // Sam

Ha megpróbálunk elérni egy elemet a tömb méreténél nagyobb indexnél, akkor meghatározatlan lesz:

Var emberek = ["Tom", "Alice", "Sam"]; console.log (emberek); // határozatlan

Ezenkívül az index megadja a tömb elemeinek értékeit:

Var emberek = ["Tom", "Alice", "Sam"]; console.log (emberek); // Tom emberek = "Bob"; console.log (emberek); // Bob

Sőt, más nyelvekkel ellentétben, mint például a C # vagy a Java, telepíthet egy olyan elemet, amelyet eredetileg nem telepített:

Var emberek = ["Tom", "Alice", "Sam"]; console.log (emberek); // undefined - csak három elem van a tömbben people = "Bob"; console.log (emberek); // Bob

Azt is érdemes megjegyezni, hogy a JavaScript számos programozási nyelvével ellentétben a tömbök nincsenek erősen gépelve, egy tömb különböző típusú adatokat tárolhat:

Var objektumok = ["Tom", 12, igaz, 3,14, hamis]; console.log (objektumok);

szóráskezelő

A szórás operátor ... lehetővé teszi, hogy egy tömbből külön vegyünk értékeket:

Legyenek számok =; console.log (... számok); // 1 2 3 4 console.log (számok); //

A spread operátor a tömb előtt van megadva. Ennek eredményeképpen a ... számok kifejezés számhalmazt ad vissza, de ez nem tömb lesz, hanem egyedi értékek.

Többdimenziós tömbök

A tömbök lehetnek egy- és többdimenziósak. A többdimenziós tömb minden eleme külön tömb lehet. A fentiekben egydimenziós tömböt tekintettünk, most hozzunk létre egy többdimenziós tömböt:

Var számok1 =; // egydimenziós tömb var számok2 = [,]; // kétdimenziós tömb

Vizuálisan mindkét tömb a következőképpen ábrázolható:

Egydimenziós tömbszámok1

Egy tömb egyetlen elemének lekéréséhez indexet is használunk:

Var tomInfo = emberek;

Csak most a tomInfo változó fog tömböt képviselni. Ahhoz, hogy egy elem beágyazott tömbbe kerüljön, a második dimenzióját kell használnunk:

Console.log ("Név:" + személyek); // Tom console.log ("Age:" + people); 25

Vagyis, ha vizuálisan ábrázolhatunk egy kétdimenziós tömböt táblázat formájában, akkor az emberek elem a táblázat cellájára hivatkozik, amely az első sor és a második oszlop metszéspontjában található (az első dimenzió 0 - egy sor, a második dimenzió - 1 - egy oszlop).

A feladatot is elvégezhetjük:

Var emberek = [["Tom", 25, hamis], ["Bill", 38, igaz], ["Alice", 21, hamis]]; emberek = 56; // külön érték hozzárendelése console.log (people); // 56 ember = ["Bob", 29, hamis]; // tömb konzol hozzárendelése.log (people); // Bob

Többdimenziós tömbök létrehozásakor nem korlátozódunk csak a kétdimenziós tömbökre, hanem használhatunk nagyméretű tömböket is:

Var számok =; számok =; // most a számok egy kétdimenziós tömb számok =; // most a számok egy háromdimenziós tömb számok = 5; // a 3D tömb első eleme 5 console.log (számok);

Üdvözlet mindenkinek, aki érdeklődik a JavaScript többdimenziós tömbjei és a rendezés iránt. A mostani kiadványban megpróbálom minden részletre kiterjedni ezt a témát.

Ezért a cikk elolvasása után megtudhatja, hogy miért használnak többdimenziós tömböket a webalkalmazásokban, hogyan jönnek létre, és hogyan kezelhetők és rendezhetők. Térjünk rá a tanulásra!

Hogyan jönnek létre és mire valók a többdimenziós tömbök?

Először is érdemes emlékezni arra, hogyan jön létre egy szabályos egydimenziós tömb.

var tömb =

Ne feledje, hogy a többdimenziós tömb tömb tömb. Egyetértek, ez tautológiának tűnik. Azonban olvassa el újra a definíciót. Valóban, a többdimenziós tömb bizonyos számú egymásba ágyazott tömbből áll.

Tekintsük a következő helyzetet. A játék elején a felhasználó beírja a nevét, és a vége után egy minősítési táblázat jelenik meg a képernyőn a játékosok nevével és adataival.

Világos, hogy az ilyen információkat adatbázisban tárolják. De amikor kihúzzuk az adatbázisból, egy többdimenziós tömböt kapunk. Végül is minden alséma tartalmazza a játékos bejelentkezési adatait és a szerzett pontok számát.

Minden így fog kinézni:

var eredmények = [["Markus", 333], ["Natasha", 211], ["Alexey", 124]];

Mint látható, az információkat heterogén módon lehet tárolni. Ez lehet karakterlánc, szám és akár páros is. Ez azért lehetséges, mert a tömbök típustalanok.

Ebben az esetben az elemekhez való hozzáférés kettős operátoron keresztül történik.

Az anyag megszilárdításához elemezzen egy kis programot.

Eredmények =

A tömbök meglehetősen kényelmes módon tárolják a megrendelt összetett adatokat feldolgozásuk során. Ezenkívül nagyon kényelmes velük dolgozni, és ugyanakkor a feldolgozás sebessége meglehetősen magas.

Adatválogatási módszerek

A JavaScript tömbjeihez van egy beépített módszer, az ún rendezés ()... Ez az eszköz nagyon rugalmas. És most elmagyarázom, miért.

Ha paraméterek nélküli módszert használ, akkor az altömböket automatikusan az első elem szerint rendezi betűrendben. Tehát híváskor eredmények.rendezés () az elemzett objektum így fog kinézni:

Alekszej, 124

Markus, 333

Natasha, 211

És ha kicseréli az egyes beágyazott tömb elemeit, akkor a következőket kapja:

124, Alekszej

211, Natasha

333, Markus

Ebben az esetben összehasonlításképpen minden elemet ideiglenesen karakterlánccá alakítunk át.

Ha egy adott feladat megoldásához olyan funkcióra van szüksége, amely nem szabványos módon rendezi az elemeket, akkor saját maga írhatja meg, és adja át paraméterként rendezés ()... Meg kell jegyezni, hogy a felhasználó által definiált függvénynek vissza kell adnia:

• pozitív szám (általában 1 -et válasszon), ha az első megadott tétel követi a másodikat az összehasonlításban;
• negatív szám (általában -1), ha a második kiválasztott elem követi az elsőt;
• nulla, ha a két vizsgált érték egyenlő.

Példaként vegyük a kezdeti tömböt eredmények pontok szerint rendezni. Ezenkívül az eredményeket a legmagasabbtól a legalacsonyabbig rendezik. Ezt kétféleképpen lehet megtenni.

Az első verzióban megváltoztattam a rendezési logikát, azaz olyan helyzetben, amikor pozitív számot kell visszaadni, negatívot adok vissza, és fordítva.

Rekord táblázat:

A második módszerben azonban a rendezési logikát érintetlenül hagytam, de emellett egy másik módszert használtam - fordított ()... Ahogy a neve is sugallja, a fordított megfordítja az elemek sorrendjét.

Ezért a sort () függvény így fog kinézni:

függvény RecordSort (a, b) (ha (a> b) visszatér 1; egyébként ha (a< b) return -1; else return 0; }

Ezt követően tegyük hozzá a fenti módszert.

A következtetés hasonló módon történik.

Egy fontos pontra szeretném felhívni a figyelmet. Ezen funkciók használatakor minden változás azon a tömbön történik, amelyre alkalmazza őket. Így ha meg kell őriznie az adatok eredeti formáját, akkor hozzon létre egy másolatot, majd szerkessze azt.

Nos, szóltam a többdimenziós tömbökről és azok rendezéséről. Ha tetszett a cikk, akkor iratkozzon fel a blogra, és olvasson más hasonlóan érdekes publikációkat. Hálás lennék az újraküldésekért. A következő alkalomig!

Viszlát!

Üdvözlettel: Roman Chueshov