A JavaScriptben a többdimenziós tömbök tömbök tömbjei. Például egy kétdimenziós tömb elemének eléréséhez kétszer kell megadni az operátort.

Tegyük fel, hogy a változó mátrix egész számok tömbje. A mátrix[j] mindegyik eleme számokból álló tömb. Egyetlen számra való hivatkozáshoz a mátrix[j][k] jelölést használjuk.

Példa. Kétdimenziós tömböt használunk a szorzótábla létrehozásához.

var mátrix = new Array(10); // 10 sor van a mátrixban

for(var j = 0; j< matrix.length; j++)

mátrix[j] = új tömb(10); //d minden sor 10 oszlopot hozott létre

for(var row = 0; sor< matrix.length; row++) {

for(col = 0; col< matrix .length; col++) {

mátrix = sor*oszlop; // tömbelemek kitöltése

var eredmény = mátrix ; // szorzás eredménye 24

A JavaScript kétdimenziós tömbjének tipikus használata egyéni menüopciók tömbjének létrehozása. Tegyük fel, hogy néhány főmenü opció megfelel a legördülő almenü opcióinak. Hozzunk létre egy tömböt, amelynek hossza megfelel a főmenü opcióinak számának. Ennek a tömbnek az elemei a megfelelő almenük opcióneveinek tömbjei lesznek.

menü = new Array();

menü = new Array ("Option 1.1", "Option 1.2", "Option 1.3");

menü = new Array ("Option 2.1", "Option 2 . 2");

menü = new Array("Opció 3.1", "Opció 3.2", "Opció 3.3", "Opció 3.4");

A 2. almenü 1. opciójának eléréséhez a következőket kell írnia:

menü // értéke "Opció 2.1";

Változtassuk meg a tömb felépítését úgy, hogy az tartalmazza a főmenü opciók és az almenü opciók nevét is:

menü = new Array()

menü = new Array("Menü1", "Menü2", "Menü3");

menü = new Array();

menü = new Array("Opció 1.1", "Opció 1.2", "Opció 1.3");

menü = new Array ("Option 2.1", "Option 2. 2");

menü = new Array ("Option 3.1", "Option 3.2", "Option 3.3", "Option 3.4");

menü // értéke "Menu2"

menü // értéke "Menu3"

menü // értéke "Option 2.1"

menü // értéke " Option 3.2 "

Array Methods

NÁL NÉL ez a szekció Nézzük meg azokat a módszereket, amelyekkel manipulálhatjuk a tömbök elemeit.

join() - olyan metódus, amely a tömb minden elemét stringgé alakítja és összefűzi. A metódus argumentumaként megadhat egy opcionális karakterláncot, amely az egyes elemek elválasztására szolgál a teljes karakterláncban. Ha nem ad meg határolót, akkor a rendszer alapértelmezés szerint vesszőt használ az elválasztáshoz.

var arr = ; // adott egy három elemből álló tömb

varstr = arr.join(); // str értéke "12,23,38"

str = arr.join("; "); // str == "12; 23; 38"

Ahogy korábban megjegyeztük, az Array.join() metódus a String.split() metódus fordítottja, amely a karakterláncokat tömbelemekre bontja.

fordított() - olyan módszer, amely megfordítja az elemek sorrendjét egy tömbben. Ez a módszer nem hoz létre új tömböt, hanem megváltoztatja a sorrendjüket az eredeti tömbben.

var arr = new Tömb(1,2,3); // arr = 1, arr = 2, arr = 3

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

var str = arr.join(); // str == "3,2,1"

sort() - egy metódus, amely egy tömb elemeit a helyükre rendezi, és a rendezett tömböt adja vissza. Ha a sort() metódus argumentumok nélkül kerül meghívásra, akkor a tömb elemeit ábécé sorrendben rendezi, és szükség esetén átmenetileg karakterlánc-értékekké alakítja át őket, hogy elvégezze az összehasonlítást.

var arr = new Array("banán", "sherry", "alma");

varstr = arr.join(", "); // str == "alma, banán, cseresznye"

Ha van egy meghatározatlan elem a tömbben, akkor az átkerül a tömb végére.

Annak érdekében, hogy ne ábécé sorrendben, hanem más módon rendezhessünk, az összehasonlító függvényt argumentumként átadjuk a sort () metódusnak, melynek feladata, hogy jelezze azt a szabályt, amely szerint két argumentuma közül az egyik elhelyezkedik. korábban a rendezett listában. Ha a másodikat meg kell előznie az első argumentumnak, az összehasonlító függvénynek negatív értéket kell visszaadnia. Ha egy rendezett tömbben az első argumentumnak a másodikat kell követnie, akkor a függvénynek pozitív számot kell visszaadnia. Az összehasonlító függvénynek 0-t kell visszaadnia, ha a két érték ekvivalens, azaz a sorrend nem fontos. Példa.

Rendezzük számsorrendbe.

var arr = ;

arr.sort(); // ábécé sorrendben: 11111, 2222, 333, 44

arr.sort(function(first,second) ( //

visszatérés első - második; )); // Számsorrend: 44, 333, 2222, 11111

Kényelmes ebben a kódrészletben literális függvényt használni, mert az összehasonlító függvényt egyszer hívják meg, és nem kell nevet adni neki.

Egyéb rendezési funkciók meghatározásával sokféle rendezési módszert valósíthat meg.

concate() - olyan metódus, amely egy új tömböt hoz létre és ad vissza, amely tartalmazza az eredeti tömb elemeit, kiegészítve a concat() metódusban megadott összes argumentum értékével. Abban az esetben, ha maga az argumentum egy tömb, az elemei hozzáadódnak a végső tömbhöz. Meg kell azonban jegyezni, hogy a tömbök és a tömbök szétválasztásakor nem történik rekurzió.

var arr = ;

arr.concat(4, 5) // eredmény

arr. concat(); // eredmény

arr. concat (,) // eredmény

arr. concat (4, ]) // eredmény ]

szelet() - olyan metódus, amely az eredeti tömb egy altömbjét (töredékét) adja vissza. A metódusnak két argumentuma van, amelyek a visszaadott altömb elejét és végét jelzik. A visszaadott tömb tartalmazni fogja az elemeket attól az elemtől kezdve, amelynek indexét az első argumentum határozza meg, egészen addig az elemig, amelynek számát a második argumentum határozza meg, de nem tartalmazza.

Ha egyetlen argumentumot ad meg, akkor a visszaadott tömb az argumentum által megadott pozíciótól a tömb végéig tartalmazza az elemeket. A negatív argumentum a tömb végétől számítva adja meg a tömbelem számát.

var arr = ;

arr.slice(0,3); // Visszatérés

arr. szelet (3); // Visszatérés

arr. szelet(1,-1); // Visszatérés

arr. szelet(-3,-2); // Visszatérés

splice()- egy általános módszer, amely egy tömb elemeinek hozzáadására és eltávolítására, vagy mindkét műveletre egyszerre használható. A metódus művelet eredményeként az eredeti tömb megváltozik.

A splice() metódusban az első argumentum annak a tömbnek az indexét adja meg, amelyből a törlés és/vagy beillesztés indul, a második argumentum pedig az eltávolítandó elemek számát adja meg. Ha elhagyja a második argumentumot, akkor a tömb elemei a metódus első argumentumában megadott pozíciótól kezdve a tömb végéig törlődnek. A splice() metódussal tér vissza eltávolított elemek tömbje. Ha a második argumentum 0, a metódus üres tömböt ad vissza.

var arr = ;

arr.splice(4); // visszatér ; arr egyenlővé válik

arr.splice(1,2); // visszatér ; arr egyenlővé válik

A splice() metódus két argumentumát, amelyek a tömb eltávolítandó elemeit határozzák meg, követheti bármilyen szám további argumentumok, amelyek meghatározzák a tömbbe beillesztendő elemeket, a metódus első argumentuma által megadott indextől kezdve.

var arr = ;

arr.splice(2,0"ab","cd"); /* vissza fog térni ; arr lesz */

arr.splice(2,2,,3); /* visszaadja ["ab","cd"]; az arr lesz ,3,33,44,55] */

Figyelembe kell venni, hogy a splice() metódus nem osztja fel a tömb argumentumát külön beszúrt elemekre, hanem magát a tömböt szúrja be.

push() és pop() - metódusok, amelyek lehetővé teszik a tömbök veremként való használatát. A push() metódus új elemeket ad a tömb végéhez, és visszaadja a tömb új hosszát. A pop() metódus eltávolítja a tömb utolsó elemét, és eredményként az eltávolított értéket adja vissza.

Mindkét módszer módosítja az eredeti tömböt. Ha a push() és pop() metódusok kombinációját használja a JavaScriptben a kódban, akkor egy tömb segítségével létrehozhat egy veremet egy first-in, last-out szolgáltatásszabállyal.

var verem = ; // üres verem

verem.push(1,2); // tömb: 2-t ad vissza

Kazal. pop(); // tömb: 2-t ad vissza

verem.push(3); // tömb: 2-t ad vissza

stack.pop(); // tömb: 3-at ad vissza

stack.push(); // tömb: ] 2-t ad vissza

Kazal. pop() // array: visszatér

Kazal. pop(); // tömb: 1-et ad vissza

unshift() és shift() - metódusok, amelyek szinte ugyanúgy működnek, mint a push() és a pop(), de nem a tömb végére, hanem az elejére szúrnak be és távolítanak el elemeket.

Az unshift() metódus hozzáad egy vagy több elemet a tömb elejéhez, eltolja az elemeket a tömb végére, és visszaadja a tömb új hosszát. A shift() metódus a tömb első elemének eltávolítására szolgál, és az eltávolított elemet adja vissza.

var arr = ; // arr:

arr.unshift(1); // arr: 1-et fog visszaadni

arr.unshift(22); // arr: visszatér 2

arr.shift(); // arr: 22-én tér vissza

arr.unshift(3,); // arr:,1] 3-at ad vissza

arr.shift(); // arr:[,1] 3-at ad vissza

arr.shift(); // arr: visszatér

arr.shift(); // arr: 1-et fog visszaadni

Ha az unshift() metódust több argumentummal hívjuk meg, akkor ezek az argumentumok egyszerre kerülnek beillesztésre, nem pedig egyenként, ahogy az a splice() metódusnál történik. Vagyis a végső tömbben az értékek ugyanabban a sorrendben lesznek elrendezve, mint ahogy az argumentumlistában szerepeltek a metódus meghívásakor.

toString() és toLocaleString()- olyan módszerek, amelyek a tömb minden elemét karakterláncokká alakítják, és megjelenítik a kapott karakterláncok listáját vesszővel elválasztva. A toString() metódus, mint már említettük, a JavaScript bármely objektumához elérhető, beleértve a tömböket is. Felhívjuk figyelmét, hogy a metódusok működése következtében a tömbértékek körül sem szögletes zárójel, sem egyéb határoló nem marad.

A ToString() // az "1,2,3" értéket adja vissza

["a", "b", "c"].toString() // az "a,b,c" értéket adja vissza

].toString() // az "1,2,s" értéket adja vissza

A toString() metódus ugyanazt a karakterláncot adja vissza, mint a join() metódus, ha paraméterek nélkül hívják meg.

A toLocaleString() egy olyan metódus, amelyben az eredményül kapott karakterláncokat egy régióspecifikus elválasztó segítségével összefűzzük.

Példa 1. Ciklikus banner készítése (diavetítés).

Hozzunk létre egy tömböt a képekből, amelyek bizonyos időközönként megjelennek az oldalon.

2. példa Véletlenszerű aforizma megjelenítése egy oldalon. Egy véletlenszerű aforizma jelenik meg minden alkalommal, amikor az oldalt frissítik.

dátum objektum

NÁL NÉL JavaScript objektum A dátum úgy lett kialakítva, hogy a dátum- és időértékekkel működjön együtt. Az objektumpéldányt a Date() konstruktor hozza létre az új operátor használatával.

var új_nap = new Date();/* Létrejött egy objektum példány, amely információkat tárol az aktuális időről és dátumról (olvassa a számítógép rendszeridejét). */

var karácsony = new Date(2016, 11, 25);/* Létrejön egy karácsony dátumú objektum példánya. A hónapszámok nulla alapúak, így a december 11-es számmal szerepel */

A Date() objektumban definiált metódusok lehetővé teszik különböző időpontok és dátumok beállítását és tárolását, valamint egy sor művelet végrehajtását rajtuk a helyi idő vagy a greenwichi középidő (GMT) szerint.

Christmas.setFullYear(xmas.getFullYear() + 1);/* Jövő év karácsonyának dátuma */

var hétköznap = Christmas.getDay();// Karácsony hetének napja.

document.write("Ma: " + new_day.toLocaleString());// Az aktuális dátum és idő karakterlánc-értéke.

A JavaScript függvényeket határoz meg a Date() objektumhoz (ezt nem a Date() objektum hívja meg, tehát nem metódusokat, hanem függvényeket), hogy egy számként vagy karakterláncként megadott dátumot ezredmásodpercekben megadott belső reprezentációvá alakítson át, amelyet bizonyos műveletekben használnak. dátumokkal.

A konstruktor a Date() objektum új példányának létrehozásakor használható következő lehetőségeket:

new Date();/* A Date() konstruktor argumentumok nélkül létrehoz egy objektumot, amelynek értéke megegyezik az aktuális dátummal és időponttal. */

new Date(szám_ezredmásodperc);/* Egyetlen numerikus érték van megadva a konstruktorban, és ez a dátum ezredmásodperces reprezentációjaként szolgál, amely megegyezik a getTime() metódus által visszaadott értékkel.*/

new Date(date_string_representation);/* Ha egyetlen karakterlánc-argumentumot adunk meg a konstruktornak, akkor azt egy dátum karakterlánc-reprezentációjaként kezeli a rendszer a Date.parse() metódus által elfogadott formátumban. */

new Date(év, hónap, nap, óra, perc, másodperc, ezredmásodperc);/* A konstruktor 2-7 numerikus argumentumot adhat át, amelyek egyedi dátum- és időmezőket határoznak meg. Az évet és hónapot meghatározó első két mezőn kívül az összes többi argumentum nem kötelező. */

A Date() függvényként hívható meg, új operátor nélkül. Ebben az esetben az összes átadott argumentumot figyelmen kívül hagyja, visszatér mostani dátumés az idő.

Határozzuk meg, milyen értékeket vehetnek fel az argumentumok a konstruktor különböző formáinak használatakor:

A num_milliseconds a kívánt dátum és 1970. január 1. éjfél (UTC) közötti ezredmásodpercek száma. Tegyük fel, hogy ha az argumentum 5000, akkor egy olyan dátum jön létre, amely 1970. 01. 01. éjfél után öt másodperccel van.

date_string_representation – Az argumentum egy dátumot és egy opcionális időt ad meg karakterláncként. A karakterláncnak olyan formátumban kell lennie, amelyet a Date.parse() metódus megért.

év – az év négy számjegye. A JavaScript korábbi implementációival való kompatibilitás érdekében, ha egy argumentum értéke 0 és 99 között van, az 1900-as szám hozzáadódik az értékéhez.

A nap egy 1 és 31 közötti egész szám, amely a hónap napját jelöli. Az érvelés nem kötelező.

óra egy egész szám 0-tól, ami éjfélt jelent, 23-ig. Az argumentum nem kötelező.

perc egy 0 és 59 közötti egész szám. Az argumentum nem kötelező.

másodpercig. Másodpercek percben, egész számként megadva 0 és 59 között. Opcionális argumentum.

ezredmásodperc a 0 és 999 közötti egész számként megadott ezredmásodpercek száma. Az argumentum nem kötelező.

Utolsó frissítés: 2018.09.04

A tömböket úgy tervezték, hogy adatkészletekkel működjenek. A new Array() kifejezés egy tömb létrehozására szolgál:

var myArray = new Array();

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

Var myArray = ;

Ebben az esetben egy üres tömböt hozunk létre. De kiindulási adatokat is hozzáadhat hozzá:

Var people = ["Tom", "Alice", "Sam"]; konzolnapló (emberek);

Ebben az esetben a myArray tömb három elemből áll. Grafikusan a következőképpen ábrázolható:

Az indexek az egyes tömbelemek elérésére szolgálnak. A számlálás nulláról indul, vagyis az első elem indexe 0, az utolsóé pedig 2 lesz:

Var people = ["Tom", "Alice", "Sam"]; konzolnapló (emberek); // Tom var person3 = emberek; // Sam console.log(person3); // Sam

Ha a tömb méreténél nagyobb indexű elemhez próbálunk hozzáférni, akkor undefined-et kapunk:

Var people = ["Tom", "Alice", "Sam"]; konzolnapló (emberek); // meghatározatlan

Ezenkívül index szerint a tömbelemek értékei vannak beállítva:

Var people = ["Tom", "Alice", "Sam"]; konzolnapló (emberek); // Tom people = "Bob"; konzolnapló (emberek); // Bob

Ezenkívül más nyelvektől, például a C#-tól vagy a Java-tól eltérően telepíthet olyan elemet, amely eredetileg nincs telepítve:

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

Azt is érdemes megjegyezni, hogy számos programozási nyelvtől eltérően a JavaScript tömbök nincsenek erősen begépelve, egy tömb különböző típusú adatokat tárolhat:

Var objects = ["Tom", 12, igaz, 3,14, hamis]; konzolnapló(objektumok);

terjedő operátor

A spread operátor ... lehetővé teszi, hogy egy tömbből egyedileg vegyen át értékeket:

legyen számok = ; konzolnapló(...számok); // 1 2 3 4 console.log(numbers); //

A spread operátor a tömb elé kerül. Ennek eredményeként a...számok kifejezés egy 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 egydimenziósak vagy többdimenziósak. A többdimenziós tömb minden eleme külön tömb lehet. A fentiekben egy egydimenziós tömböt vettünk figyelembe, most egy többdimenziós tömböt hozunk létre:

var számok1 = ; // egydimenziós tömb var numbers2 = [, ]; // 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 egyedi elemének megszerzéséhez indexet is használunk:

Var tomInfo = emberek;

Csak most a tomInfo változó képvisel egy tömböt. Ahhoz, hogy egy elemet beágyazott tömbbe kapjunk, a második dimenzióját kell használnunk:

Console.log("Név: " + emberek); // Tom console.log("Kor: " + emberek); 25

Vagyis ha egy kétdimenziós tömböt vizuálisan táblázatként tudunk ábrázolni, akkor a people elem az első sor és a második oszlop metszéspontjában található táblázatcellára fog hivatkozni (az első dimenzió 0 - sor, a második dimenzió - 1 - oszlop).

Feladatot is teljesíthetünk:

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

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

varnumbers = ; számok = ; // a now numbers egy 2D tömb numbers=; // a most számok egy 3D tömb számok = 5; // a 3D tömb első eleme 5 console.log(numbers);

• I. Iteráció valós tömbök felett
  1. Minden módszerhez és a kapcsolódó módszerekhez
  2. hurokhoz
  3. A for...in loop megfelelő használata
  4. for... of loop (az iterátor implicit használata)
  5. Egy iterátor kifejezett használata
• 1. Valós tömb iterációs módszerek használata
  2. Konvertálás valódi tömbbe
  3. Megjegyzés a futásidejű objektumokról

I. Iteráció valós tömbök felett

A Ebben a pillanatban Háromféleképpen lehet ismételni egy valódi tömb elemeit:

1. metódus Array.prototype.forEach ;
2. klasszikus for loop;
3. Egy "jól megformált" a...huroknak.

Emellett hamarosan, az új ECMAScript 6 (ES 6) szabvány megjelenésével további két módszer várható:

1. for... of loop (az iterátor implicit használata);
2. iterátor explicit használata.

1. A forEach módszer és a kapcsolódó módszerek

Ha projektjét úgy tervezték, hogy támogassa az ECMAScript 5 (ES5) szabvány funkcióit, használhatja annak egyik újítását - a forEach módszert.

Használati példa:
var a = ["a", "b", "c"]; a.forEach(function(entry) ( console.log(entry); ));
Általában a forEach használata megköveteli az es5-shim emulációs könyvtár felvételét azoknál a böngészőknél, amelyek nem rendelkeznek natív támogatással ehhez a módszerhez. Ezek közé tartozik az IE 8 és korábbi verziók, amelyeket néhol még mindig használnak.

A forEach előnye, hogy nincs szükség helyi változók deklarálására az aktuális tömbelem indexének és értékének tárolásához, mivel ezek automatikusan átkerülnek a függvénynek. visszahív(visszahívás) érvként.

Ha aggódik az egyes elemek visszahívásának lehetséges költségei miatt, ne aggódjon, és olvassa el ezt.

A ForEach-et úgy tervezték, hogy egy tömb összes elemén át iteráljon, de ezen kívül az ES5 számos további hasznos módszert kínál az összes vagy néhány elem iterálására, valamint azokkal való műveletekre:

• every - igazat ad vissza, ha a tömb minden elemére a visszahívás egy igaz értéket ad vissza.
• some – igazat ad vissza, ha a tömb legalább egy elemére a visszahívás egy igaz értéket ad vissza.
• szűrő – létrehoz egy új tömböt, amely tartalmazza az eredeti tömb azon elemeit, amelyekre a visszahívás igazat ad vissza.
• térkép - létrehoz egy új tömböt, amely a visszahívás által visszaadott értékekből áll.
• redukció – Egy tömböt egyetlen értékre redukál úgy, hogy a tömb minden elemére sorra visszahívást alkalmaz, az elsőtől kezdve (hasznos lehet a tömbelemek összegének és egyéb összegző függvények kiszámításához).
• ReductionRight – a redukcióhoz hasonlóan működik, de fordított sorrendben iterálja az elemeket.

2. A for ciklus

Jó öreg a sziklákhoz:

Var a = ["a", "b", "c"]; var index; for (index = 0; index< a.length; ++index) { console.log(a); }
Ha a tömb hossza nem változik a ciklus során, és maga a ciklus egy teljesítménykritikus kódrészlethez tartozik (ami nem valószínű), akkor használhatja a "optimálisabb" verziót, amely tárolja a ciklus hosszát. sor:

Var a = ["a", "b", "c"]; var index, len; for (index = 0, len = a.length; index< len; ++index) { console.log(a); }
Elméletileg ennek a kódnak kicsit gyorsabban kell futnia, mint az előzőnek.

Ha az elemek feletti iteráció sorrendje nem fontos, akkor még tovább léphet az optimalizálás terén, és megszabadulhat a tömb hosszának tárolására szolgáló változótól, ha az iterációs sorrendet fordítottra változtatja:

Var a = ["a", "b", "c"]; var index; for (index = a.length - 1; index >= 0; --index) ( console.log(a); )
Azonban a modern JavaScript motorok Az ilyen optimalizáló játékok általában nem jelentenek semmit.

3. A for...in ciklus megfelelő használata

Ha a for...in ciklus használata javasolt, ne feledje, hogy a tömbökön keresztüli iteráció nem az, amire való. A közkeletű tévhittel ellentétben a for...in ciklus nem a tömb indexein iterál, hanem az objektum felsorolható tulajdonságain.

Bizonyos esetekben azonban, például a ritka tömbökön történő iteráció, a for...in hasznos lehet, ha megteszi az alábbi példában látható óvintézkedéseket:

// a - ritka tömb var a = ; a = "a"; a = "b"; a = "c"; for (var key in a) ( if (a.hasOwnProperty(key) && /^0$|^\d*$/.test(key) && kulcs<= 4294967294) { console.log(a); } }
Ebben a példában két ellenőrzést hajtunk végre a ciklus minden iterációján:

1. hogy a tömbnek van saját kulcs nevű tulajdonsága (nem a prototípusától örökölt).
2. ez a kulcs egy olyan karakterlánc, amely egy olyan egész szám tizedes jelölését tartalmazza, amelynek értéke kisebb, mint 4294967294. Honnan származik az utolsó szám? Az ES5 tömbindexének definíciójából következik, hogy egy tömb elemének legmagasabb indexe (2^32 - 2) = 4294967294 .

Természetesen az ilyen ellenőrzések több időt vesznek igénybe a ciklus végrehajtása során. De ritka tömb esetén ez a módszer hatékonyabb, mint a for ciklus, mivel ebben az esetben csak azokat az elemeket iteráljuk át, amelyek a tömbben kifejezetten definiáltak. Tehát a fenti példában csak 3 iteráció kerül végrehajtásra (a 0, 10 és 10000 indexeknél) a for ciklus 10001-gyel szemben.

Annak érdekében, hogy ne írjon le ilyen nehézkes ellenőrző kódot minden alkalommal, amikor egy tömbön át kell iterálnia, külön függvényként is megírhatja:

Függvény arrayHasOwnIndex(tömb, kulcs) ( return array.hasOwnProperty(kulcs) && /^0$|^\d*$/.test(kulcs) && kulcs<= 4294967294; }
Ezután a példa hurok törzse jelentősen csökken:

For (kulcs be a) ( if (arrayHasOwnIndex(a, kulcs)) ( console.log(a); ) )
A fent említett ellenőrzési kód univerzális, minden esetre alkalmas. De helyette használhat egy rövidebb verziót is, bár formailag nem egészen helyes, de a legtöbb esetben megfelelő:

For (kulcs in a) ( if (a.hasOwnProperty(key) && String(parseInt(kulcs, 10)) === kulcs) ( console.log(a; ) )

4. A for... of ciklus (iterátor implicit használata)

Az ES6, még vázlat státuszában, iterátorokat kell bevezetnie a JavaScriptbe.

iterátor egy objektummal megvalósított protokoll, amely szabványos módot határoz meg egy értéksorozat (véges vagy végtelen) megszerzésére.
Az iterátor egy objektum, amely meghatározza a next() metódust, egy argumentum nélküli függvény, amely két tulajdonságú objektumot ad vissza:

1. kész (boolean) – igaz, ha az iterátor elérte az iterálható sorozat végét. Ellenkező esetben hamis.
2. érték – az iterátor által visszaadott értéket határozza meg. Lehet definiálatlan (hiányzó), ha a done tulajdonság true értékre van állítva.

Számos beépített objektum, pl. A valódi tömbök alapértelmezés szerint iterátorokkal rendelkeznek. Az iterátor valódi tömbökön való használatának legegyszerűbb módja az új for...of konstrukció használata.

Példa a következő használatára:...

Varval; var a = ["a", "b", "c"]; for (a érték) ( console.log(val); )
A fenti példában a for...of ciklus implicit módon meghívja az Array objektum iterátorát, hogy megkapja a tömbben lévő minden értéket.

5. Iterátor kifejezett használata

Az iterátorok kifejezetten használhatók, bár ebben az esetben a kód sokkal bonyolultabb lesz a for...of ciklushoz képest. Valahogy így néz ki:

Var a = ["a", "b", "c"]; var it = a.entries(); var bejegyzés; while (!(bejegyzés = it.next()).kész) ( console.log(entry.value); )
Ebben a példában az Array.prototype.entries metódus egy iterátort ad vissza, amely a tömb értékeinek megjelenítésére szolgál. Minden iterációnál az enter.value egy [kulcs, érték] alakú tömböt tartalmaz.

II. Iteráció tömbszerű objektumok felett

A valódi tömbök mellett a JavaScript is rendelkezik tömbszerű objektumok . Közös bennük a valós tömbök, hogy rendelkeznek egy long tulajdonsággal és olyan tulajdonságokkal, amelyek nevei számok formájában megfelelnek a tömb elemeinek. A példák közé tartozik a NodeList gyűjtemény DOM-ja és a bármely függvényen/metóduson belül elérhető pszeudotömb argumentumok.

1. Metódusok használata valós tömbök feletti iterációhoz

Legalább a legtöbb, ha nem az összes valós tömbön keresztüli iterációs metódus használható tömbszerű objektumok iterációjára.

A for és for...in konstrukciók pontosan ugyanúgy alkalmazhatók tömbszerű objektumokra, mint a valódi tömbök.

A ForEach és más Array.prototype metódusok tömbszerű objektumokra is vonatkoznak. Ehhez egy Function.call vagy Function.apply hívást kell használnia.

Például, ha a forEach-t alkalmazni szeretné egy csomópont objektum childNodes tulajdonságára, akkor ezt a következőképpen tegye:

Array.prototype.forEach.call(node.childNodes, function(child) ( // csinálj valamit a gyermekobjektummal));
A technika újrafelhasználásának kényelme érdekében deklarálhat egy hivatkozást az Array.prototype.forEach metódusra egy külön változóban, és használhatja rövidítésként:

// (Feltéve, hogy az összes alábbi kód ugyanabban a hatókörben van) var forEach = Array.prototype.forEach; // ... forEach.call(node.childNodes, function(child) ( // csinálj valamit a gyermekobjektummal));
Ha egy tömbszerű objektumnak van iterátora, akkor ez ugyanúgy használható explicit vagy implicit módon az objektum feletti iterációra, mint a valódi tömbök esetében.

2. Konvertálás valódi tömbbe

Van egy másik, nagyon egyszerű módja is a tömbszerű objektumok iterációjának: konvertálja azt valódi tömbbé, és használja a fent tárgyalt módszerek bármelyikét a valós tömbök közötti iterációhoz. Az átalakításhoz használhatja az Array.prototype.slice általános metódust, amely bármilyen tömbszerű objektumra alkalmazható. Ez nagyon egyszerűen megtehető, amint az az alábbi példában látható:

Var trueArray = Array.prototype.slice.call(arrayLikeObject, 0);
Például, ha egy NodeList gyűjteményt valódi tömbbé szeretne konvertálni, akkor a következő kódra lesz szüksége:

Vardivs = Array.prototype.slice.call(document.querySelectorAll("div"), 0);
frissítés: Amint azt rock és torbasow megjegyzéseiben megjegyezte , az ES6 - ban az Array.prototype.slice helyett használhatja a leíróbb Array.from metódust .

3. Megjegyzés a futásidejű objektumokról

Ha Array.prototype metódusokat alkalmaz futásidejű objektumokra (például DOM-gyűjteményekre), akkor tudnia kell, hogy ezek a módszerek nem garantáltan működnek megfelelően minden futási környezetben (beleértve a böngészőket is). Ez egy adott objektum viselkedésétől függ egy adott futásidőben, pontosabban attól, hogy a HasProperty absztrakt művelet hogyan valósul meg az adott objektumban. A probléma az, hogy maga az ES5 szabvány megengedi annak lehetőségét, hogy egy objektum hibásan viselkedjen ezzel a művelettel kapcsolatban (lásd 8.6.2).

Ezért fontos, hogy tesztelje az Array.prototype metódusok működését minden egyes futási környezetben (böngészőben), amelyben használni kívánja az alkalmazást.

Üdvözlök mindenkit, aki érdeklődik olyan téma iránt, mint a JavaScript többdimenziós tömbök és a rendezés. A mostani kiadványban ezt a témát igyekszem minden részletre kiterjedni.

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

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

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

tömb =

Most ne feledje, hogy a többdimenziós tömb tömbök tömbje. Egyetértek, tautológiának hangzik. Olvassa el azonban újra a definíciót. Valójában egy többdimenziós tömb bizonyos számú beágyazott tömbből áll.

Vegye figyelembe a következő helyzetet. Egy adott játék elején a felhasználó beírja a nevét, majd a vége után egy értékelési táblázat jelenik meg a képernyőn a játékosok nevével és rekordjaikkal.

Nyilvánvaló, hogy az ilyen információkat az 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 alrendszer tárolja a játékos bejelentkezési adatait és a szerzett pontok számát.

Mindez így fog kinézni:

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

Mint látható, az információ heterogén módon tárolható. Lehetnek karakterláncok, számok és akár . Ez azért lehetséges, mert a tömbök típusozatlanok.

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

Az anyag konszolidálásához elemezzen egy kis programot.

Az eredmények értéke =

A tömbök meglehetősen kényelmes eszközt jelentenek a rendezett összetett adatok tárolására a feldolgozás során. Ezenkívül nagyon kényelmes velük dolgozni, és ugyanakkor a feldolgozási sebességük meglehetősen magas.

Az adatok rendezésének módjai

A JavaScript beépített metódussal rendelkezik az úgynevezett tömbökhöz fajta(). Ez az eszköz nagyon rugalmas. És most elmagyarázom, miért.

Ha a metódust paraméterek nélkül használja, akkor az altáblákat automatikusan az első elem szerint rendezi ábécé sorrendben. Igen, híváskor eredmények.fajta() az elemzett objektum így fog kinézni:

Alekszej, 124 éves

Márkus, 333

Natasha, 211 éves

És ha felcseréli az elemeket az egyes beágyazott tömbökben, a következőket kapja:

124, Alekszej

211, Natasa

333, Marcus

Ebben az esetben összehasonlítás céljából minden elemet átmenetileg karakterláncokká alakítanak át.

Ha egy adott probléma megoldásához olyan függvényre van szüksége, amely nem szabványos módon rendezi az elemeket, akkor saját maga is megírhatja, és paraméterként átadhatja fajta(). Ebben az esetben érdemes megfontolni, hogy a felhasználó által definiált függvénynek vissza kell térnie:

• pozitív szám (általában 1-et válasszunk), ha az első megadott elem követi a másodikat összehasonlításkor;
• negatív szám (általában -1), ha a második kiválasztott elemnek az elsőt kell követnie;
• null, ha a két tesztelt érték egyenlő.

Példaként vegyük az eredeti tömböt eredmények pontok szerint rendezve. Az eredményeket a rendszer a legnagyobbtól a legkisebbig rendezi. Ezt kétféleképpen lehet megtenni.

Az első lehetőségnél változtattam a rendezési logikán, pl. olyan helyzetben, amikor pozitív számot kell visszaadni, akkor negatívat adok vissza, és fordítva.

Rekord táblázat:

De a második módszernél érintetlenül hagytam a rendezési logikát, de egy további módszert alkalmaztam - fordított(). Ahogy a neve is sugallja, a fordított fordítottja megfordítja az elemek sorrendjét.

Tehát a sort() függvény így néz ki:

1 2 3 4 5

függvény RecordSort(a, b) ( ha (a > b) 1-et ad vissza; else if (a< b) return -1; else return 0; }

függvény RecordSort(a, b) ( ha (a > b) 1-et ad vissza; else if (a< b) return -1; else return 0; }

És utána adja hozzá a fenti módszert.

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

Egy fontos pontra szeretném felhívni a figyelmet. E függvények használatakor minden változás abban a tömbben történik, amelyre alkalmazza őket. Így, ha meg kell őriznie az adatok eredeti formáját, készítsen másolatot, majd szerkessze azt.

Nos, szóval a többdimenziós tömbökről és azok rendezéséről beszéltem. Ha tetszett a cikk, iratkozzon fel a blogra, és olvasson el más, hasonlóan érdekes kiadványokat. Hálás leszek az újraküldésekért. Hamarosan találkozunk!

Viszlát!

Üdvözlettel: Roman Chueshov

Ebben a cikkben a szabványos JavaScript-tömböket tekintjük meg numerikus indexekkel. A tömbök deklarálása szögletes zárójelben történik:

var fruits = ["Alma", "Narancs", "Szamár"]

Egy elem kivonásához tegye az indexét szögletes zárójelbe. Első index 0:

var fruits = ["Alma", "Narancs", "Szamár"] alert(fruits) alert(fruits) alert(fruits)

Megkaphatjuk egy JavaScript tömb hosszát is:

var fruits = ["Alma", "Narancs", "Szamár"] alert(fruits.length)

Hoppá! Létrehoztunk egy tömböt két gyümölccsel és egy szamárral. Most el kell távolítanunk a szamarat.

pop és push módszerek

A JavaScript pop metódusa eltávolít egy tömbelemet, és visszaadja azt.

A következő példa azt mutatja be, hogyan kerül lekérésre a "Donkey" egy tömbből:

var fruits = ["Apple", "Orange", "Donkey"] alert("Törölöm a "+fruits.pop()"-t) // Most már csak az ["Apple","Orange"] alert("Now" a tömb mérete : "+fruits.length) // szamár eltávolítva

Vegye figyelembe, hogy a pop magát a tömböt módosítja.

A Pop megfelelője a push metódus, amely egy elemet ad egy tömbhöz. Például elfelejtettünk egy barackot hozzáadni:

var fruits = ["Alma", "Narancs"] fruits.push("Őszibarack"); // most van ["Apple", "Orange", "Peach"] alert("Utolsó tétel:"+gyümölcsök)

1. Hozzon létre egy tömbstílusokat elemekkel " Dzsessz”, “Blues”;
2. Hozzáadott érték " rock'n'roll«;
3. Cserélje le a második értéket a végétől a " Klasszikus". A végén egy tömböt kell kapnia: " Dzsessz”, ”Klasszikus”, ”rock'n'roll". A kódnak bármilyen tömbhosszra működnie kell;
4. Vonja ki az utolsó értéket a tömbből, és jelenítse meg az alert segítségével.

Megoldás

// 1 var styles = ["Jazz", "Bluez"] // 2 styles.push("Rock"n"Roll") // vagy: styles = "Rock"n"Roll" // 3 styles = "Classic " // 4 figyelmeztetés(styles.pop())

shift/unshift módszerek

A shift/unshift metódusok a tömb végétől működnek, de a shift segítségével is mozgathatjuk az elemeket felfelé ( a tömb első értéke az elemeltolással törlődik). Az unshift módszer lehetővé teszi, hogy a JavaScript elemet adjon hozzá egy tömbhöz a végétől:

var fruits = ["Apple", "Orange"] var apple = fruits.shift() // most már csak ["Orange"] fruits.unshift("Lemon") // most van ["Citrom", " Orange"] alert(gyümölcsök. hossza) // 2

Mind a shift, mind az unshift egyszerre több elemen is működhet:

var fruits = ["Alma"] fruits.push("Orange","Peach") fruits.unshift("Ananász","Lemon") // a tömb így néz ki: ["Ananász", "Citrom", " Apple ", "Orange", "Peach"]

Önmegvalósítási feladat

Írjon kódot az arr tömb véletlenszerű értékére:

var arr = ["Szilva", "Narancs", "Szamár", "Sárgarépa", "JavaScript"]

Megjegyzés: A minimumtól a maximális értékig (beleértve) a véletlen szám lekéréséhez szükséges kód a következő:

var rand = perc + Math.floor(Math.random()*(max.+1-perc))

Megoldás

Véletlenszerű számot kell kivonnunk 0 és arr.length-1 között (beleértve):

var arr = ["Szilva","Narancs","Szamár","Sárgarépa","JavaScript"] var rand = Math.floor(Math.random()*arr.length) alert(arr)

Iterálás egy tömbön keresztül

A JavaScriptben az iteráció egy tömbön keresztül for ciklussal történik:

var fruits = ["Ananász", "Citrom", "Alma", "Narancs", "Őszibarack"] for(var i=0; i

Önmegvalósítási feladat

Hozzon létre egy find(arr,value) függvényt, amely értéket talál egy adott tömbben, és visszaadja annak indexét, vagy -1-et, ha nem található érték.

Például:

arr = [ "teszt", 2, 1.5, false ] find(arr, "test") // 0 find(arr, 2) // 1 find(arr, 1.5) // 2 find(arr, 0) // -egy

Megoldás

Egy lehetséges megoldás így nézhet ki:

függvény find(tömb, érték) (for(var i=0; i

De ez nem igaz, mert az == nem határozza meg a különbséget 0 és hamis között.

Helyesebb a === használata, ha tömbökkel dolgozik JavaScriptben. Ezenkívül a legújabb ES5 szabvány tartalmazza az Array#indexOf függvényt. Ezzel egy ilyen függvényt definiálhatunk:

függvény find(tömb, érték) ( if (array.indexOf) return array.indexOf(value) for(var i=0; i

Még okosabb lenne, ha a find egy feltételen keresztül definiálná, hogy ellenőrizze, létezik-e az indexOf metódus.

Önmegvalósítási feladat

Hozzon létre egy filterNumeric(arr) függvényt, amely egy tömböt vesz fel, és egy új tömböt ad vissza, amely csak az arr numerikus értékeit tartalmazza.

Egy példa arra, hogyan kell ennek működnie:

arr = ["a", 1, "b", 2]; arr = filterNumeric(arr); // most arr =

Megoldás

A megoldás az, hogy ismételjük a tömböt, és hozzáadjuk az értékeket az új tömbhöz, ha azok numerikusak.

csatlakozni és szétválni

Néha szüksége van egy gyors módra a JavaScript-tömb karakterláncsá alakítására. Erre való a csatlakozási módszer.

Egy tömböt egy karakterláncba fűz össze a megadott határoló használatával:

var fruits = ["Citrom", "Alma", "Narancs", "Őszibarack"]; varstr = gyümölcsök.join(", "); alert(str);

A fordított transzformáció könnyen elvégezhető a split módszerrel:

var fruits = "Alma, narancs, őszibarack"; vararr = gyümölcsök.split(","); // Az arr most tartalmazza: ["Apple", "Orange", "Peach"] alert(arr);

Önmegvalósítási feladat

Az objektum tartalmazza a className tulajdonságot, amely az osztályneveket szóközzel elválasztva tartalmazza:

Írjon egy addClass(obj, cls) függvényt, amely hozzáadja a cls osztályt, de csak akkor, ha az nem létezik:

ddClass(obj, "new") // obj.className="új menü megnyitása" addClass(obj, "open") // változatlan (az osztály már létezik) addClass(obj, "me") // obj.className= " menü megnyitása new me" alert(obj.className) //

Megoldás

Az osztálynevet és a ciklust részekre kell választanunk. Ha az osztály nem található, akkor hozzáadódik.

A hurok kissé optimalizálva van a teljesítményhez:

függvény addClass(elem, cls) ( for(var c = elem.className.split(" "), i=c.length-1; i>=0; i--) ( if (c[i] == cls ) return ) elem.className += " "+cls ) var obj = ( osztálynév: "menü megnyitása" ) addClass(obj, "new") addClass(obj, "open") alert(obj.className) // menü megnyitása új

A fenti példában a c változó a ciklus elején van definiálva, utolsó indexe pedig i.

Maga a ciklus az ellenkező irányban kerül feldolgozásra, és az i>=0 feltétellel végződik. Mert az i>=0 ellenőrzés gyorsabb, mint az i . Ami a JavaScriptben felgyorsítja a tömbkeresést.

A hossz használata egy tömb levágásához

A hossz tulajdonság használatával a következőképpen vághat le egy tömböt:

Beállítod a hosszt, és a böngésző levágja a tömböt.

A tömb egy objektum, ami arra utal

Valójában a JavaScriptben a tömb egy objektum , automatikus hosszbeállítással és speciális módszerekkel.

Ez eltér a többi nyelv koncepciójától, ahol a tömbök a memória összefüggő szegmense. Ez is különbözik egy sor vagy verem alapú hivatkozási listától.

Nem numerikus tömbkulcsok

A gombok számok, de bármilyen nevük lehet:

arr = arr = 5 arr.prop = 10 // ne tedd ezt

A JavaScriptben a tömbök hash táblák, amelyek teljesítményelőnyeivel, de néhány hátrányával is járnak.

Például a push/pop csak a tömb legkülső elemein működik, tehát hihetetlenül gyorsak.

a push csak a végével működik:

var arr = ["Saját", "tömb"] arr.push("something") alert(arr) // string "tömb"

A shift/unshift metódusok lassúak, mert át kell számozni a teljes tömböt. Az illesztési módszer a számozást is megváltoztathatja:

Tehát a shift/unshift lassabb, mint a push/pop. Minél nagyobb a tömb, annál tovább tart a JavaScriptben a tömb rendezése.

Önmegvalósítási feladat

mi lesz az eredmény? Miért?

arr = ["a", "b"] arr.push(function() ( alert(this) )) arr() // ?

Megoldás

Mivel a tömbök objektumok, arr .. valójában egy metódushívás egy objektumhoz, például az obj módszer:

arr() // ugyanaz, mint az arr() // szintaktikailag hibás, de fogalmilag ugyanaz: arr.2() // átírva ugyanabban a stílusban, mint az obj.method() ez = arr ebben az esetben átkerül a függvénynek, így az arr tartalma ki van nyomtatva. arr = ["a", "b"] arr.push(function() ( alert(this) )) arr() // "a","b",function

Ritka tömbök, hossz leírás

A length tulajdonság lehetővé teszi, hogy ne egy tömb méretét kapja meg a JavaScriptben, hanem az utolsó indexet + 1 . Ez akkor fontos, ha ritka tömbökről van szó, az indexekben "résekkel".

A következő példában két elemet adunk az üres gyümölcsökhöz, de a hossz értéke 100 marad:

var fruits = // empty array fruits = "Peach" fruits = "Alma" alert(fruits.length) // 100 (de csak 2 elem van a tömbben)

Ha ritka tömböt próbál kiadni, a böngésző üres elemekként adja vissza a hiányzó indexek értékeit:

var fruits = // empty array fruits = "Peach" fruits = "Alma" alert(fruits) // ,Peach,Alma (vagy valami hasonló)

De egy tömb két kulccsal rendelkező objektum. A hiányzó értékek nem foglalnak helyet.

A ritka tömbök bizarr módon viselkednek, ha tömbmódszereket alkalmaznak rájuk. Fogalmuk sincs arról, hogy hiányoznak az indexek:

var fruits = fruits = "Peach" fruits = "Alma" alert(fruits.pop()) // pop "Alma" (9-es indexnél) alert(fruits.pop()) // meghatározatlan elem felbukkanása (a 8-as indexnél) )

Próbálja meg elkerülni a ritka tömböket. Amúgy a módszereik nem működnek normálisan. Ehelyett használja az Objektumot.

Eltávolítás egy tömbből

Mint tudjuk, a tömbök objektumok, ezért a delete segítségével eltávolíthatunk egy értéket:

var arr = ["Go", "to", "home"] delete arr // now arr = ["Go", undefined, "home"] alert(arr) // nincs beállítva

Látható, hogy az érték el lett távolítva, de nem úgy, ahogy szeretnénk, mert a tömb egy beállított elemet tartalmaz.

A delete operátor töröl egy kulcs-érték párt, és ennyi. Természetesen, mivel egy tömb csak egy hash, az eltávolított elem pozíciója meghatározatlanná válik.

Leggyakrabban el kell távolítanunk egy elemet anélkül, hogy "lyukakat" hagynánk az indexek között. Van egy másik módszer is, amely segít ebben.

splice módszer

A splice módszerrel eltávolíthatók és lecserélhetők az elemek a JavaScript többdimenziós tömbökben. A szintaxisa a következő:

arr.splice(index, deleteCount[, elem1, ..., elemN])

Törli a deleteCount elemet az indextől kezdve, majd beszúrja az elem1, ..., elemN elemet a helyére.

Nézzünk néhány példát:

var arr = ["Go", "to", "home"] arr.splice(1, 1) // 1 elem eltávolítása az 1. indextől kezdve alert(arr.join(",")) // ["Go " , "home"] (1 elem eltávolítva)

Így a splice segítségével eltávolíthat egy elemet egy tömbből. A tömbelemek számai eltolódnak, hogy kitöltsék a hiányt:

var arr = ["Go", "to", "home"] arr.splice(0, 1) // 1 elem eltávolítása a 0 indextől alert(arr) // a "to" lett az első elem

A következő példa az elemek cseréjét mutatja be:

A splice metódus eltávolított elemek tömbjét adja vissza:

var arr = ["Menj", "to", "otthon", "most"]; // az első 2 elem eltávolítása var remove = arr.splice(0, 2) alert(removed) // "Go", "to"<-- массив удаленных элементов splice может вставлять элементы, задайте 0 для deleteCount. var arr = ["Go", "to", "home"]; // со второй позиции // удаляем 0 // и вставляем "my", "sweet" arr.splice(2, 0, "my", "sweet") alert(arr) // "Go", "to", "my", "sweet", "home"

Ez a módszer negatív indexet is használhat, amely a tömb végétől számít:

var arr = // az -1 elemhez (utolsó előtti) // 0 elem eltávolítása, // és 3 és 4 beszúrása arr.splice(-1, 0, 3, 4) alert(arr) // 1,2,3, 4.5

Önmegvalósítási feladat

Az objektum tartalmazza a className tulajdonságot, amely az osztályneveket szóközzel elválasztva tartalmazza:

var obj = ( osztálynév: "menü megnyitása")

Írjon egy removeClass(obj, cls) függvényt, amely eltávolítja a cls osztályt, ha az adott:

removeClass(obj, "open") // obj.className="menu" removeClass(obj, "blabla") // változatlan (nincs eltávolítandó osztály)

Megoldás

Az osztálynevet részekre kell osztania, és egy cikluson keresztül ismételnie kell ezeket a részeket. Ha talál egyezést, azt eltávolítja az objektumok JavaScript-tömbjéből, majd visszaadja a végére.

Ezt optimalizáljuk egy kicsit:

függvény removeClass(elem, cls) ( for(var c = elem.className.split(" "), i=c.length-1; i>=0; i--) ( if (c[i] == cls ) c.splice(i,1) ) elem.className = c.join(" ") ) var obj = ( osztálynév: "menü megnyitása" ) removeClass(obj, "open") removeClass(obj, "blabla") alert (obj.className) // menü

A fenti példában a c változó a ciklus elején, az i pedig az utolsó indexére van állítva.

Maga a ciklus az ellenkező irányban hajtódik végre, és az i>=0 feltétellel végződik. Ennek az az oka, hogy az i>=0 gyorsabban kerül ellenőrzésre, mint az i. Ez felgyorsítja a tulajdonságkeresést c -ben.

szelet módszer

A tömb egy részét a slice(begin[, end]) metódussal bonthatja ki: var arr = ["Miért", "learn", "JavaScript"]; var arr2 = arr.slice(0,2) // 2 elemet vesz fel 0-tól kezdve alert(arr2.join(", ")) // "Miért, tanulj"

Vegye figyelembe, hogy ez a módszer nem változtatja meg a tömb elemeinek számát a JavaScriptben, hanem annak egy részét másolja.

Kihagyhatja a második argumentumot, hogy minden elem egy adott indextől induljon:

var arr = ["Miért", "tanulás", "JavaScript"]; var arr2 = arr.slice(1) // minden elemet elfogad 1-től alert(arr2.join(", ")) // "learn, JavaScript"

A módszer támogatja a negatív indexeket, akárcsak a String#slice .

fordított módszer

Egy másik hasznos módszer a fordított . Tegyük fel, hogy szeretném megszerezni a domain utolsó részét, például " com" tól től " my.site.com". Íme, hogyan kell csinálni:

var domain = "my.site.com" var last = domain.split(".").reverse() alert(last)

Vegye figyelembe, hogy a JavaScript tömbök egy összetett szintaxist (reverse()) támogatnak egy metódus meghívásához, majd egy elem kinyeréséhez a kapott tömbből.

Hosszabb hívásokat is létrehozhat, például a reverse() 0] arr.sort() alert(arr) // 1, 15, 2

Futtassa a fenti kódot. Megkapja a rendelést 1 , 15 , 2 . Ennek az az oka, hogy a metódus mindent sztringgé alakít, és alapértelmezés szerint a lexikográfiai sorrendet használja.