V tejto lekcii sa zoznámime s poliami, naučíme sa ich vytvárať, vykonávať operácie s ich prvkami a tiež sa pozrieme na základné metódy a vlastnosti dostupné pri práci s nimi.

Čo je pole v JavaScripte?

Pole je usporiadaný zber hodnôt. Hodnoty v tejto kolekcii sa nazývajú elementy. Každý prvok v poli má svoje sériové číslo (číslo), ktoré sa nazýva index. Indexy sú číslované od 0.

Nasledujúci obrázok zobrazuje číselné pole pozostávajúce z 5 prvkov. Prvky tohto poľa obsahujú nasledujúce údaje: 123 (index 0), 7 (index 1), 50 (index 2), -9 (index 3), 24 (index 4).

Vytvorenie (deklarovanie) poľa

Vytváranie polí v JavaScripte sa zvyčajne vykonáva pomocou pole doslovný.

Literál poľa pozostáva z hranatých zátvoriek obsahujúcich zoznam prvkov oddelených čiarkou.

Napríklad:

Var empty = ; // prázdne pole var cisla = ; // číselné pole var arr = ; // pole obsahujúce rôzne typy údajov

Hodnoty v poli JavaScript nemusia byť rovnakého typu. Tie. Jedno pole môže obsahovať hodnoty rôznych typov údajov.

Ku konkrétnemu prvku poľa sa pristupuje pomocou jeho indexu. Táto operácia sa tiež nazýva operácia indexovania.

Napríklad:

// vytvorte pole pozostávajúce z 3 prvkov var smartphoneColors = ["Black", "White", "Grey"]; // zobrazí v konzole prehliadača hodnoty prvkov poľa smartphoneColors s indexmi 0 a 2 console.log("Hodnota prvku poľa smartphoneColors s indexom 0: " + smartphoneColors); // "Hodnota prvku poľa smartphoneColors s indexom 0: Čierna" console.log("Hodnota prvku poľa smartphoneColors s indexom 2: " + smartphoneColors); // "Hodnota prvku poľa smartphoneColors s indexom 0: Gray" // zmeňte hodnotu prvku poľa smartphoneColors s indexom 1 na "Red" smartphoneColors = "Red"; // ["Black", "Red", "Grey"] // nastavíme prvok poľa smartphoneColors s indexom 3 na hodnotu "Blue" smartphoneColors = "Blue"; // ["Čierna", "Červená", "Sivá", "Modrá"]

Ako hodnoty prvkov poľa môžete použiť nielen statické hodnoty, ale aj výrazy:

Dĺžka var.A = 7, šírkaA = 5; var bod = ;

Objekty možno použiť ako hodnoty prvkov poľa.

Var body = [ (x1: 5, y1: 3), (x1: 7, y1: 10), (x1: 12; y1: 0) ]; // pole pozostávajúce z 3 objektov

Ďalší spôsob, ako vytvoriť pole pozostáva z volania funkcie konštruktora Array.

Na vytvorenie prázdneho poľa sa používa volanie funkcie konštruktora bez argumentov.

Var empty = new Array(); // prázdne pole

Tento spôsob vytvárania poľa je ekvivalentný doslovnému.

Ak zadáte číslo ako argument funkcie konštruktora, vytvorí pole, ktoré bude pozostávať zo zadaného počtu prvkov. Navyše všetky tieto prvky budú mať nedefinovanú hodnotu.

Var arr = new Array(5); // pole pozostávajúce z 5 prvkov (hodnoty prvkov nie sú definované)

Ak funkcii konštruktora v zátvorkách odovzdáte niekoľko hodnôt alebo jednu nenumerickú hodnotu, z argumentov, ktoré jej boli odovzdané, vytvorí pole.

Na rozdiel od mnohých iných programovacích jazykov polia v JavaScripte automaticky menia svoju veľkosť, t.j. sú vo svojej podstate dynamické. Takéto polia nemusia mať žiadne rozmery. Ďalšou charakteristickou črtou polí JavaScriptu je, že rôzne prvky toho istého poľa môžu obsahovať rôzne typy údajov.

vlastnosť dĺžky (dĺžka poľa)

Určenie dĺžky poľa (počet prvkov) sa vykonáva pomocou vlastnosti length.

//vytvorte pole uvedením hodnôt prvkov vo funkcii Array var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //priraďte premennú lengthArray k dĺžke poľa volumeHDDs var lengthArray = volumeHDDs.length;

Ako získať prvý prvok poľa

Získanie hodnoty prvého prvku poľa sa vykonáva zadaním čísla 0 v hranatých zátvorkách tohto poľa:

//vytvorenie poľa pozostávajúceho z 3 prvkov var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //získanie hodnoty prvého prvku poľa var firstValue = volumeHDDs;

Ako získať posledný prvok poľa

Hodnota posledného prvku poľa sa získa zadaním výrazu názov_poľa.dĺžka-1 v hranatých zátvorkách tohto poľa:

//vytvorenie poľa pozostávajúceho z 3 prvkov var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //získanie hodnoty posledného prvku poľa var lastValue = volumeHDDs;

Iterácia cez pole

Iterácia cez prvky poľa sa vykonáva pomocou cyklu for.

Prejdime si napríklad všetky prvky poľa a zobrazme ich hodnoty v konzole prehliadača (F12):

//vytvorenie poľa nameStudents, pozostávajúceho zo 4 prvkov var nameStudents = new Array("Petya","Vasya","Kolya","Maxim"); // iterácia prvkov poľa z 0 na dĺžku poľa-1 for (var i=0; i<= nameStudents.length-1; i++) { console.log(i+1 + " элемент массива = " + nameStudents[i]); }

Aký je účel operátora vymazania?

Operátor delete sa používa nie na odstránenie prvku z poľa, ale na priradenie nedefinovanej hodnoty danému prvku poľa.

Var namePlanets = new Array("Venuša","Merkúr","Zem","Mars"); vymazať názovPlanety; pre (var i=0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }

Funkcie na prácu s poľami (metódy objektov poľa)

Objekt Array obsahuje nasledujúce metódy (funkcie) na prácu s poľami:

• posun
• nevyraďovať
• plátok
• spájať
• rozdeliť
• obrátene

Push metóda (pridanie prvku na koniec poľa)

Metóda push je navrhnutá tak, aby pridala prvok na koniec poľa. Hodnota tohto prvku je špecifikovaná ako parameter tejto metódy. Výsledkom je, že metóda push vráti počet prvkov v poli, berúc do úvahy, čo bolo pridané.

Názov VarPlanets = ["Venuša", "Merkúr", "Zem", "Mars"]; namePlanets.push("Jupiter"); // 5 console.log(namePlanets); // ["Venuša", "Merkúr", "Zem", "Mars", "Jupiter"]

metóda pop (odstránenie posledného prvku z poľa)

Metóda pop je navrhnutá tak, aby odstránila posledný prvok z poľa. Táto metóda nemá žiadne parametre. V dôsledku toho vráti hodnotu posledného (odstráneného) prvku poľa.

Názov VarPlanets = ["Venuša", "Merkúr", "Zem", "Mars"]; namePlanets.pop(); // "Mars" console.log(namePlanets); // ["Venuša", "Ortuť", "Zem"]

Metóda Shift (odstránenie prvého prvku z poľa)

Metóda posunu je určená na odstránenie prvého prvku z poľa, t.j. prvok s indexom 0. Všetky ostatné prvky poľa sú posunuté na začiatok, t.j. pre každý z nich sa index zníži o 1. Táto metóda ako výsledok vráti hodnotu odstráneného prvku.

Názov VarPlanets = ["Venuša", "Merkúr", "Zem", "Mars"]; namePlanets.shift(); // "Venuša" console.log(namePlanets); // ["Merkúr", "Zem", "Mars"]

metóda unshift (pridanie prvku na začiatok poľa)

Metóda unshift je navrhnutá na pridanie prvku na začiatok poľa (pred ostatné prvky). Hodnota tohto prvku je špecifikovaná ako parameter tejto metódy. Výsledkom je, že táto metóda vráti počet prvkov v poli, berúc do úvahy, čo bolo pridané.

Názov VarPlanets = ["Merkúr", "Zem", "Mars", "Jupiter"]; namePlanets.unshift("Venuša"); // 5 console.log(namePlanets); // ["Venuša", "Merkúr", "Zem", "Mars", "Jupiter"]

metóda slice (kopírovanie časti poľa)

Metóda slice je navrhnutá tak, aby kopírovala časť poľa. Nezmení však pôvodné pole, ale ako výsledok vráti nové pole pozostávajúce z vybraných prvkov.

Metóda rezu má 2 parametre:

• 1 parameter (povinný) - je určený na označenie indexu prvku, od ktorého sa má začať kopírovať prvky;
• Parameter 2 (voliteľný) - je určený na označenie indexu prvku, do ktorého je potrebné kopírovať (v tomto prípade nie je zahrnutý v novom poli). Ak ho nešpecifikujete, skopírujú sa prvky až do konca zadaného poľa.

var namePlanets = ["Venuša", "Merkúr", "Zem", "Mars", "Jupiter"]; var newNamePlanets = namePlanets.slice(2, 4); // ["Zem", "Mars"]

Splice metóda (zmena obsahu poľa)

Metóda spájania je navrhnutá na zmenu obsahu poľa. Môže sa použiť na pridávanie prvkov do poľa aj na ich odstránenie.

Syntax metódy spájania je:

Array.splice(startIndex, deleteCount [, prvok1[, prvok2[, ...]]]); /* startIndex (povinné) – počiatočný index prvku, od ktorého sa má začať meniť pole. Ak ako startIndex zadáte číslo väčšie ako je dĺžka poľa, počiatočný index bude nastavený na koniec poľa. Ak zadáte záporné číslo ako počiatočný index, počiatočný prvok sa bude počítať od konca. deleteCount (povinné) - číslo označujúce, koľko prvkov je potrebné z poľa odstrániť. Ak nie je potrebné vymazať prvky z poľa, potom deleteCount musí byť nastavené na 0. Potom musíte zadať aspoň jeden nový prvok, ktorý sa má pridať do poľa. Ak zadáte číslo ako deleteCount, ktoré prekročí počet zostávajúcich prvkov v poli, počnúc od startIndex, potom sa v tomto prípade aj tak vymažú (t. j. všetky prvky po koniec poľa, počnúc od počiatočného indexu) prvok1, prvok2, ... (voliteľné) - prvky, ktoré je potrebné pridať do poľa. */

Príklady použitia metódy spájania.

Použitie metódy spájania na odstránenie niektorých prvkov z poľa.

Názov VarPlanets = ["Venuša", "Merkúr", "Zem", "Mars"]; namePlanets.splice(2, 2); //["Zem", "Mars"] console.log(namePlanets); // ["Venuša", "Ortuť"]

Použitie metódy splice na odstránenie prvku z poľa a pridanie nových prvkov do poľa.

Názov VarPlanets = ["Venuša", "Merkúr", "Zem", "Mars"]; namePlanets.splice(1, 1, "Urán", "Neptún", "Saturn"); // ["Merkúr"] console.log(namePlanets); // ["Venuša", "Urán", "Neptún", "Saturn", "Zem", "Mars"]

Použitie metódy spájania iba na pridanie nových prvkov do poľa.

Názov VarPlanets = ["Jupiter", "Saturn", "Urán"]; namePlanets.splice(0, 0, "Venuša", "Merkúr", "Zem", "Mars"); // console.log(namePlanets); // ["Venuša", "Merkúr", "Zem", "Mars", "Jupiter", "Saturn", "Urán"]

metóda join (prevod poľa na reťazec)

Metóda join je navrhnutá na spojenie všetkých prvkov poľa do reťazca.

Syntax metódy spojenia:

Array.join(); /* oddeľovač (voliteľný) - oddeľovač, ktorý sa používa ako spojovací reťazec medzi každým prvkom poľa. Ak tento parameter nie je zadaný, ako spojovací reťazec sa použije ",". Ak zadáte prázdny reťazec ako parameter, prvky poľa vo vrátenom reťazci nebudú oddelené ničím */

Var bobule = ["Hrozno", "Hrozno", "Ríbezle", "Šípka"]; var berriesStr1 = berries.join(); // "Hrozno, hrozno, ríbezle, šípky" var berriesStr2 = berries.join(""); // "HroznoHroznoRíbezľaRosehip" var berriesStr3 = berries.join(", "); // "Hrozno, hrozno, ríbezle, šípky" var berriesStr4 = berries.join(" + "); // "Hrozno + Hrozno + Ríbezle + Šípky"

Ak ako oddeľovač použijete nereťazec, skonvertuje sa na reťazec.

Var bobule = ["Hrozno", "Hrozno", "Ríbezle", "Šípka"]; var berriesStr1 = berries.join(false); // "GrapesfalseGrapesfalseCurrantfalseRosehip" var berriesStr2 = berries.join(4/2); // "Grapes2Grapes2Currant2Rose Hip" Prvky poľa, ktoré majú hodnotu null alebo undefined ako hodnotu, budú prenesené do prázdneho reťazca. var arr = ; var arrStr = arr.join(", "); // "0, 5, -4"

Konverzia reťazca na pole - rozdelenie

Metóda split je navrhnutá tak, aby konvertovala reťazec na pole. Táto metóda má jeden parameter, pomocou ktorého môžete zadať reťazec, na základe ktorého sa tento reťazec rozdelí na pole reťazcov.

Var strElementComputers = "Systémová jednotka, monitor, klávesnica, myš, reproduktory, tlačiareň"; var elementComputers = strElementComputers.split(", "); console.log("Počet prvkov v poli: " + prvokPočítače.dĺžka); pre (var i=0; i<= elementComputers.length-1; i++) { console.log(i + " элемент массива = " + elementComputers[i]); }

Zmena poradia prvkov poľa v opačnom poradí - naopak

Obrátená metóda je navrhnutá na zmenu poradia prvkov poľa v opačnom poradí.

Var namePlanets = new Array("Venuša","Merkúr","Zem","Mars"); namePlanets.reverse(); console.log("Počet prvkov v poli: " + názovPlanety.dĺžka); pre (var i=0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }

Triedenie prvkov poľa - triedenie

Metóda triedenia sa používa na triedenie prvkov poľa. Štandardne táto metóda triedi pole ako reťazce.

Var namePlanets = new Array("Venuša","Merkúr","Zem","Mars"); namePlanets.sort(); console.log("Počet prvkov v poli: " + názovPlanety.dĺžka); pre (var i=0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }

21.06.2017 o 12:17 hod

Na výpočet veľkosti poľa objektov v JavaScripte použite vlastnosť length poľa.

Var arr = ["prvý", "druhý"]; console.log(arr.length); // 2

Polia v javascripte môžu mať chýbajúce indexy. Napríklad

Var arr = ; arr = "prvý"; arr = "druhý";

Vlastnosť length vracia maximálny index poľa + 1. t.j. v uvedenom príklade dĺžka = 5.

Výpočet počtu prvkov v poli v javascripte

Array.prototype.count = function())( var vysledok = 0; for(var i = 0; i< this.length; i++) if (this[i] != undefined) result++; return result; }

Príklad použitia

Var arr = ; arr = "prvý"; arr = "druhý"; console.log(arr.count()); //2

Môžete tiež priradiť hodnotu vlastnosti length. To vám umožní zmenšiť dĺžku existujúceho poľa.

Var arr = ["prvý", "druhý", "tretí"]; arr.length = 2; console.log(arr); // ["prvy druhý"]

Výpočet veľkosti poľa v bajtoch v javascripte

Polia sú bežné objekty, takže výpočet veľkosti poľa v bajtoch sa nelíši od výpočtu veľkosti akéhokoľvek iného objektu. Bohužiaľ, javascript neposkytuje API na výpočet veľkosti, takže si ju budete musieť vypočítať sami. Robí sa to takto: prejdeme všetky vlastnosti objektu, ak je vlastnosť primitívneho typu, k celkovému výsledku pridáme veľkosť inštancie tohto typu, ak vlastnosť obsahuje objekt, rekurzívne vypočítame jeho veľkosť.

Funkcia sizeOf(obj) ( var bytes = 0; if(obj !== null && obj !== undefined) ( switch(typeof obj) ( case "number": bytes += 8; break; case "reťazec": bajtov += dĺžka objektu * 2; zlom; veľkosť písmen "boolean": bajty += 4; zlom; veľkosť písmen "objekt": for(kľúč var v obj) ( bajty += sizeOf(obj); ) break; ) ) návrat bajtov ;);

Metóda nie je presná a má veľa problémov - napríklad existuje možnosť prechodu do nekonečnej slučky.

Posledná aktualizácia: 26.03.2018

Objekt Array predstavuje pole a poskytuje množstvo vlastností a metód, pomocou ktorých môžeme s poľom manipulovať.

Inicializácia poľa

Prázdne pole môžete vytvoriť pomocou hranatých zátvoriek alebo konštruktora Array:

Var users = new Array(); var ludia = ; console.log(users); // Pole console.log(people); // Pole

Okamžite môžete inicializovať pole s určitým počtom prvkov:

Var users = new Array("Tom", "Bill", "Alice"); var ľudia = ["Sam", "John", "Kate"]; console.log(users); // ["Tom", "Bill", "Alice"] console.log(people); // ["Sam", "John", "Kate"]

Môžete definovať pole a pridávať doň nové prvky:

Var users = new Array(); užívatelia = "Tom"; užívatelia = "Kate"; console.log(users); // "Tom" console.log(users); // nedefinované

Nezáleží na tom, že pole je štandardne vytvorené s nulovou dĺžkou. Pomocou indexov môžeme nahradiť jeden alebo iný prvok v poli na konkrétnom indexe.

dĺžka

Ak chcete zistiť dĺžku poľa, použite vlastnosť length:

Var ovocie = new Array(); ovocie = "jablká"; ovocie = "hrušky"; ovocie = "slivky"; document.write("V poli ovocie " + prvok fruit.length + ":
"); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

V skutočnosti bude dĺžka poľa index posledného prvku plus jedna. Napríklad:

Var users = new Array(); // v poli je 0 prvkov users = "Tom"; užívatelia = "Kate"; užívatelia = "Sam"; for(var i=0; i

Výstup z prehliadača:

Tom Kate nedefinovaný nedefinovaný Sam

Napriek tomu, že sme nepridali prvky pre indexy 2 a 3, dĺžka poľa bude v tomto prípade číslo 5. Len prvky s indexmi 2 a 3 budú mať hodnotu undefined .

Kopírovanie poľa. plátok ()

Kopírovanie poľa môže byť plytké alebo plytké (plytká kópia) a hlboké (hlboká kópia).

Na plytké kopírovanie stačí priradiť premennej hodnotu inej premennej, ktorá ukladá pole:

Používatelia var = ["Tom", "Sam", "Bill"]; console.log(users); // ["Tom", "Sam", "Bill"] var people = users; // plytké kopírovanie ľudí = "Mike"; // zmena druhého prvku console.log(users); // ["Tom", "Mike", "Bill"]

V tomto prípade bude premenná ľudia po skopírovaní ukazovať na rovnaké pole ako premenná users. Preto sa pri zmene prvkov v ľuďoch zmenia aj prvky v používateľoch, keďže v skutočnosti ide o to isté pole.

Toto správanie nie je vždy žiaduce. Napríklad chceme, aby premenné po skopírovaní ukazovali na samostatné polia. A v tomto prípade môžete použiť hlboké kopírovanie pomocou metódy slice():

Používatelia var = ["Tom", "Sam", "Bill"]; console.log(users); // ["Tom", "Sam", "Bill"] var people = users.slice(); // deep copy people = "Mike"; // zmena druhého prvku console.log(users); // ["Tom", "Sam", "Bill"] console.log(people); // ["Tom", "Mike", "Bill"]

V tomto prípade po skopírovaní budú premenné ukazovať na rôzne polia a môžeme ich meniť oddelene od seba.

Metóda slice() vám tiež umožňuje skopírovať časť poľa:

Používatelia var = ["Tom", "Sam", "Bill", "Alice", "Kate"]; var people = users.slice(1, 4); console.log(people); // ["Sam", "Bill", "Alice"]

Metóde slice() sa odovzdá počiatočný a koncový index, ktoré sa používajú na získanie hodnôt z poľa. To znamená, že v tomto prípade výber do nového poľa prechádza z indexu 1 na index 4, bez toho. A keďže indexovanie poľa začína od nuly, nové pole bude obsahovať druhý, tretí a štvrtý prvok.

TAM()

Metóda push() pridá prvok na koniec poľa:

Var ovocie = ; ovocie.push("jablka"); ovocie.push("hrušky"); ovocie.push("slivky"); ovocie.push("čerešňa","marhuľa
"); document.write(ovocie); // jablká, hrušky, slivky, čerešne, marhule

pop()

Metóda pop() odstráni posledný prvok z poľa:

Var ovocie = ["jablká", "hrušky", "slivky"]; var lastFruit = ovocie.pop(); // extrahujte posledný prvok z poľa document.write(lastFruit + "
"); document.write("V poli fruit " + fruit.length + " prvok:
"); for(var i=0; i ");

Výstup z prehliadača:

Slivky Pole ovocia má 2 prvky: jablká hrušky

posun()

Metóda shift() načíta a odstráni prvý prvok z poľa:

Var ovocie = ["jablká", "hrušky", "slivky"]; var prveOvocie = ovocie.shift(); document.write(firstFruit + "
"); document.write("V poli fruit " + fruit.length + " prvok:
"); for(var i=0; i ");

Výstup z prehliadača:

Jablká Pole ovocia má 2 prvky: hrušky slivky

unshift()

Metóda unshift() pridá na začiatok poľa nový prvok:

Var ovocie = ["jablká", "hrušky", "slivky"]; ovocie.unshift("marhule"); dokument.písať(ovocie);

Výstup z prehliadača:

Marhule, jablká, hrušky, slivky

Odstránenie prvku podľa indexu. spoj ()

Metóda splice() odstraňuje prvky na konkrétnom indexe. Napríklad odstránenie prvkov z tretieho indexu:

Používatelia var = ["Tom", "Sam", "Bill", "Alice", "Kate"]; var delete = users.splice(3); console.log(zmazané); // [ "Alice", "Kate" ] console.log(users); // [ "Tom", "Sam", "Bill" ]

Metóda rezu vráti odstránené prvky.

V tomto prípade dôjde k vymazaniu od začiatku poľa. Ak zadáte záporný index, vymazanie sa vykoná od konca poľa. Napríklad odstránime posledný prvok:

Používatelia var = ["Tom", "Sam", "Bill", "Alice", "Kate"]; var delete = users.splice(-1); console.log(zmazané); // [ "Kate" ] console.log(users); // [ "Tom", "Sam", "Bill", "Alice" ]

Ďalšia verzia metódy vám umožňuje zadať koncový index na vymazanie. Napríklad vymažeme prvý až tretí index:

Používatelia var = ["Tom", "Sam", "Bill", "Alice", "Kate"]; var delete = users.splice(1,3); console.log(zmazané); // [ "Sam", "Bill", "Alice" ] console.log(users); // [ "Tom", "Kate" ]

Iná verzia metódy spájania umožňuje vkladať nové prvky namiesto odstránených prvkov:

Používatelia var = ["Tom", "Sam", "Bill", "Alice", "Kate"]; var delete = users.splice(1,3, "Ann", "Bob"); console.log(zmazané); // [ "Sam", "Bill", "Alice" ] console.log(users); // [ "Tom", "Ann", "Bob", "Kate" ]

V tomto prípade vymažeme tri prvky z 1. až 3. indexu a namiesto nich vložíme dva prvky.

concat()

Metóda concat() sa používa na kombinovanie polí:

Var ovocie = ["jablká", "hrušky", "slivky"]; var zelenina = ["paradajky", "uhorky", "zemiaky"]; var produkty = ovocie.concat(zelenina); for(var i=0; i< products.length; i++) document.write(products[i] + "
");

V tomto prípade nie je potrebné kombinovať iba polia rovnakého typu. Možné sú rôzne typy:

Var ovocie = ["jablká", "hrušky", "slivky"]; var ceny = ; var produkty = ovocie.concat(ceny);

pripojiť sa ()

Metóda join() spája všetky prvky poľa do jedného reťazca:

Var ovocie = ["jablká", "hrušky", "slivky", "marhule", "broskyne"]; var fruitString = fruit.join(", "); document.write(fruitString);

Metóde join() sa odovzdáva oddeľovač medzi prvkami poľa. V tomto prípade sa ako oddeľovač použije čiarka a medzera (", ").

zoradiť ()

Metóda sort() triedi pole vo vzostupnom poradí:

Var ovocie = ["jablká", "hrušky", "slivky", "marhule", "broskyne"]; ovocie.triedit(); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

Výstup z prehliadača:

Marhule hrušky broskyne slivky jablká

obrátiť ()

Metóda reverse() obráti pole dozadu:

Var ovocie = ["jablká", "hrušky", "slivky", "marhule", "broskyne"]; fruit.reverse(); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

Výstup z prehliadača:

Broskyne marhule slivky hrušky jablká

V kombinácii s metódou sort() môžete pole zoradiť v zostupnom poradí:

Var ovocie = ["jablká", "hrušky", "slivky", "marhule", "broskyne"]; ovocie.triedit().obrátiť(); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

Výstup z prehliadača:

Jablká slivky broskyne hrušky marhule

Nájdenie indexu prvku

Metódy indexOf() a lastIndexOf() vracajú index prvého a posledného zahrnutia prvku do poľa. Napríklad:

Var ovocie = ["jablká", "hrušky", "slivky", "jablká", "hrušky"]; var firstIndex = fruit.indexOf("jablka"); var lastIndex = fruit.lastIndexOf("jablka"); var otherIndex = fruit.indexOf("čerešne"); document.write(firstIndex); // 0 document.write(lastIndex); // 3 document.write(otherIndex); // -1

firstIndex má hodnotu 0, pretože prvé zahrnutie riadku "jablká" v poli je na indexe 0 a posledné je na indexe 3.

Ak prvok nie je v poli, potom v tomto prípade metódy indexOf() a lastIndexOf() vrátia hodnotu -1.

každý()

Metóda every() kontroluje, či všetky prvky zodpovedajú určitej podmienke:

Čísla var = [ 1, -12, 8, -4, 25, 42]; funkcia podmienka (hodnota, index, pole) ( var vysledok = nepravda; if (hodnota > 0) ( vysledok = pravda; ) vratit vysledok; ); var prešiel = čísla.každý(podmienka); dokument.zapis(uspel); // nepravda

Metóde every() sa odovzdá funkcia predstavujúca podmienku ako parameter. Táto funkcia má tri parametre:

Podmienka funkcie (hodnota, index, pole) ( )

Parameter value predstavuje aktuálny prvok poľa, ktorý sa iteruje, parameter index predstavuje index tohto prvku a parameter poľa odovzdáva odkaz na pole.

V tejto funkcii môžeme skontrolovať, či odovzdaná hodnota prvku spĺňa nejakú podmienku. Napríklad v tomto príklade kontrolujeme každý prvok poľa, či je väčší ako nula. Ak je väčšia, vrátime hodnotu true , teda prvok spĺňa podmienku. Ak je menej, vráťte hodnotu false - prvok nespĺňa podmienku.

Výsledkom je, že keď je zavolaná metóda numbers.every(condition), iteruje cez všetky prvky poľa čísel a jeden po druhom ich odovzdá funkcii podmienky. Ak táto funkcia vráti hodnotu true pre všetky prvky, potom metóda every() vráti hodnotu true. Ak aspoň jeden prvok nevyhovuje podmienke, potom metóda every() vráti false .

nejaký ()

Metóda some() je podobná metóde every(), len kontroluje, či aspoň jeden prvok zodpovedá podmienke. A v tomto prípade metóda some() vráti true . Ak v poli nie sú žiadne prvky zodpovedajúce podmienke, vráti sa false:

Čísla var = [ 1, -12, 8, -4, 25, 42]; funkcia podmienka (hodnota, index, pole) ( var vysledok = nepravda; if (hodnota === 8) ( vysledok = pravda; ) vrate vysledok; ); var prešiel = čísla.niektoré(podmienka); // pravda

filter()

Metóda filter(), podobne ako some() a every() , akceptuje funkciu podmienky. Zároveň však vráti pole prvkov, ktoré spĺňajú túto podmienku:

Čísla var = [ 1, -12, 8, -4, 25, 42]; funkcia podmienka (hodnota, index, pole) ( var vysledok = nepravda; if (hodnota > 0) ( vysledok = pravda; ) vratit vysledok; ); var filtrovaneCisla = cisla.filter(podmienka); for(var i=0; i< filteredNumbers.length; i++) document.write(filteredNumbers[i] + "
");

Výstup z prehliadača:

1 8 25 42

forEach() a map()

Metódy forEach() a map() iterujú prvky a vykonávajú s nimi určité operácie. Napríklad na výpočet druhej mocniny čísel v poli môžete použiť nasledujúci kód:

Čísla var = [1, 2, 3, 4, 5, 6]; for(var i = 0; i "); }

Ale pomocou metódy forEach() môžete túto konštrukciu zjednodušiť:

Čísla var = [1, 2, 3, 4, 5, 6]; funkcia square(hodnota, index, pole) ( var výsledok = hodnota * hodnota; document.write("Druhá mocnina čísla " + hodnota + " je " + výsledok + "
"); ); čísla.pre každého(štvorec);

Metóda forEach() berie ako parameter rovnakú funkciu, do ktorej sa pri iterácii po prvkoch odovzdáva aktuálny iterovaný prvok a vykonávajú sa s ním operácie.

Metóda map() je podobná metóde forEach, berie tiež ako parameter funkciu, ktorá vykonáva operácie s prvkami poľa, ale metóda map() vracia nové pole s výsledkami operácií s prvkami poľa.

Použime napríklad metódu mapy na výpočet druhých mocnín čísel v poli:

Čísla var = [1, 2, 3, 4, 5, 6]; funkcia square(hodnota, index, pole) ( návrat výsledok = hodnota * hodnota; ); var squareArray = čísla.mapa(štvorec); document.write(squareArray);

Funkcia odovzdaná metóde map() prijme aktuálny prvok, ktorý sa iteruje, vykoná s ním operácie a vráti nejakú hodnotu. Táto hodnota potom prejde do výsledného squareArray

V tomto článku sa pozrieme na štandardné polia JavaScriptu s číselnými indexmi. Polia sú deklarované pomocou hranatých zátvoriek:

var fruits = ["Jablko", "Pomaranč", "Osol"]

Ak chcete extrahovať prvok, umiestnite jeho index do hranatých zátvoriek. Prvý index 0:

var fruits = ["Jablko", "Pomaranč", "Osol"] upozornenie (ovocie) upozornenie (ovocie) upozornenie (ovocie)

Môžeme tiež získať dĺžku poľa JavaScript:

var fruits = ["Jablko", "Pomaranč", "Osol"] upozornenie(ovocie.dĺžka)

Ojoj! Vytvorili sme pole s dvoma plodmi a oslom. Teraz musíme odstrániť osla.

pop a push metódy

Metóda pop v JavaScripte odstráni prvok z poľa a vráti ho.

Nasledujúci príklad ukazuje, ako sa „Osol“ získava z poľa:

var fruits = ["Apple", "Orange", "Donkey"] alert("Odstraňujem "+fruits.pop()) // Teraz máme len ["Apple","Orange"] alert("Teraz veľkosť poľa: "+fruits.length) // somár odstránený

Všimnite si, že pop upravuje samotné pole.

Popovým náprotivkom je metóda push, ktorá do poľa pridáva prvok. Zabudli sme napríklad pridať broskyňu:

var ovocie = ["Jablko", "Pomaranč"] fruits.push("Peach"); // teraz máme upozornenie ["Apple", "Orange", "Peach"] ("Posledný prvok:"+ovocie)

1. Vytvorte rad štýlov s prvkami “ Jazz”, “Blues”;
2. Pridajte hodnotu " Rock'n'Roll«;
3. Nahraďte druhú hodnotu od konca hodnotou " klasické". Mali by ste skončiť s poľom: " Jazz”, ”klasické”, ”Rock'n'Roll" Kód by mal fungovať pre akúkoľvek dĺžku poľa;
4. Získajte poslednú hodnotu z poľa a zobrazte ju prostredníctvom upozornenia.

Riešenie

// 1 var styles = ["Jazz", "Bluez"] // 2 styles.push("Rock"n"Roll") // or: styles = "Rock"n"Roll" // 3 štýly = "Classic" " // 4 upozornenie(styles.pop())

Metódy radenia/vyraďovania

Metódy shift/unshift fungujú na konci poľa, ale môžete použiť aj shift na posunutie prvkov nahor ( prvá hodnota poľa sa odstráni posunutím prvkov). Metóda unshift umožňuje JavaScriptu pridať prvok do poľa od konca:

var fruits = ["Apple", "Orange"] var apple = fruits.shift() // teraz máme len ["Orange"] fruits.unshift("Lemon") // teraz máme ["Lemon", " Orange"] alert(fruits.length) // 2

Radenie aj radenie môžu fungovať na viacerých prvkoch naraz:

var fruits = ["Apple"] fruits.push("Pomaranč","Peach") fruits.unshift("Ananás","Lemon") // teraz pole vyzerá takto: ["Ananás", "Lemon", "Jablko", "Pomaranč", "Peach"]

Samostatne spravovaná úloha

Napíšte kód na zobrazenie náhodnej hodnoty z poľa arr prostredníctvom upozornenia:

var arr = ["Slivka","Pomaranč","Osol","Mrkva","JavaScript"]

Poznámka: Kód na získanie náhodného čísla od minimálnej po maximálnu hodnotu (vrátane) je nasledujúci:

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

Riešenie

Potrebujeme extrahovať náhodné číslo od 0 do arr.length-1 (vrátane):

var arr = ["Slivka","Pomaranč","Osol","Mrkva","JavaScript"] var rand = Math.floor(Math.random()*arr.length) alert(arr)

Iterácia cez pole

V JavaScripte sa iterácia cez pole vykonáva pomocou cyklu for:

var ovocie = ["ananás", "citrón", "jablko", "pomaranč", "broskyňa"] pre (var i=0; i

Samostatne spravovaná úloha

Vytvorte funkciu find(arr,value), ktorá nájde hodnotu v danom poli a vráti jej index alebo -1, ak sa hodnota nenájde.

Napríklad:

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

Riešenie

Možné riešenie môže vyzerať takto:

funkcia find(pole, hodnota) (​for(var i=0; i

To je však nesprávne, pretože == nedefinuje rozdiel medzi 0 a false .

Pri práci s poľami v JavaScripte je správnejšie použiť ===. Najnovší štandard ES5 navyše obsahuje funkciu Array#indexOf. Pomocou neho môžeme definovať funkciu takto:

funkcia find(pole, hodnota) (​if (pole.indexOf) vráti pole.indexOf(hodnota) for(var i=0; i

Ešte inteligentnejšie by bolo definovať find s podmienkou na kontrolu, či metóda indexOf existuje.

Samostatne spravovaná úloha

Vytvorte funkciu filterNumeric(arr), ktorá vezme pole a vráti nové pole obsahujúce iba číselné hodnoty z arr .

Príklad, ako by to malo fungovať:

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

Riešenie

Riešením je iterovať pole a pridať hodnoty do nového poľa, ak sú číselné.

spojiť a rozdeliť

Niekedy potrebujete rýchly spôsob, ako previesť pole JavaScript na reťazec. Na to slúži metóda spájania.

Spája pole do reťazca pomocou daného oddeľovača:

var ovocie = ["Citrón","Jablko","Pomaranč","Peach"]; var str = fruits.join(", "); alert(str);

Spätná konverzia sa dá ľahko vykonať pomocou metódy delenia:

var ovocie = "Jablko, pomaranč, broskyňa"; var arr = fruits.split(","); // arr teraz obsahuje ["Apple", "Orange", "Peach"] alert(arr);

Samostatne spravovaná úloha

Objekt obsahuje vlastnosť className, ktorá obsahuje názvy tried oddelené medzerami:

Napíšte funkciu addClass(obj, cls), ktorá pridá triedu cls , ale iba ak neexistuje:

ddClass(obj, "new") // obj.className="open menu new" addClass(obj, "open") // žiadne zmeny (trieda už existuje) addClass(obj, "me") // obj.className= upozornenie "otvoriť menu new me" (obj.className) //

Riešenie

Musíte rozdeliť názov triedy a slučku na časti. Ak sa trieda nenájde, pridá sa.

Slučka bola mierne optimalizovaná na zvýšenie výkonu:

function 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 = ( className: "open menu" ) addClass(obj, "new") addClass(obj, "open") alert(obj.className) // otvorenie ponuky Nový

Vo vyššie uvedenom príklade je premenná c definovaná na začiatku cyklu a jej posledný index je nastavený na i .

Samotný cyklus je spracovaný v opačnom smere a končí podmienkou i>=0. Pretože i>=0 sa kontroluje rýchlejšie ako i . Čo v JavaScripte zrýchľuje vyhľadávanie v poli.

Použitie dĺžky na orezanie poľa

Pomocou vlastnosti length môžete pole skrátiť takto:

Zadáte dĺžku a prehliadač pole skráti.

Pole je objekt, tak čo to znamená?

V skutočnosti je pole v JavaScripte objektom s automatickým nastavením dĺžky a špeciálnymi metódami.

Toto sa líši od konceptu v iných jazykoch, kde polia predstavujú súvislý segment pamäte. Toto sa tiež líši od frontu alebo zásobníka založeného na prepojených zoznamoch.

Nenumerické klávesy poľa

Kľúče sú čísla, ale môžu mať ľubovoľný názov:

arr = arr = 5 arr.prop = 10 // nerobte to

V JavaScripte sú polia hašovacie tabuľky, ktoré majú výkonnostné výhody, ale aj určité nevýhody.

Napríklad push/pop funguje len na najvzdialenejších prvkoch poľa, takže sú neuveriteľne rýchle.

push funguje iba s koncom:

var arr = ["Moje", "pole"] arr.push("niečo") alert(arr) // reťazec "pole"

Metódy shift/unshift sú pomalé, pretože potrebujú prečíslovať celé pole. Metóda spájania môže tiež spôsobiť zmenu číslovania:

Takže shift/unshift sú pomalšie ako push/pop . Čím väčšie je pole, tým dlhšie trvá JavaScriptu triedenie poľa.

Samostatne spravovaná úloha

Aký bude výsledok? prečo?

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

Riešenie

Keďže polia sú objekty, arr .. je vlastne volanie metódy na objekt, ako je obj metóda:

arr() // to isté ako arr() // syntakticky nesprávne, ale koncepčne rovnaké: arr.2() // prepísané rovnakým štýlom ako obj.method() this = arr sa v tomto prípade odovzdá funkcii, takže obsah arr sa vytlačí. arr = ["a", "b"] arr.push(function() ( alert(this) )) arr() // "a","b",function

Riedke polia, popis dĺžky

Vlastnosť length vám umožňuje získať nie veľkosť poľa v JavaScripte, ale posledný index + 1. Toto je dôležité, keď hovoríme o riedkych poliach s „medzerami“ v indexoch.

V nasledujúcom príklade pridáme k prázdnym ovocím dva prvky, ale hodnota dĺžky zostane 100:

var fruits = // prázdne pole fruits = "Peach" fruits = "Apple" alert(fruits.length) // 100 (ale v poli sú len 2 prvky)

Ak sa pokúsite o výstup riedkeho poľa, prehliadač vráti chýbajúce hodnoty indexu ako prázdne prvky:

var fruits = // prázdne pole fruits = "Peach" fruits = "Apple" alert (ovocie) // ,Peach,Apple (alebo niečo podobné)

Ale pole je objekt s dvoma kľúčmi. Chýbajúce hodnoty nezaberajú miesto.

Zriedkavé polia sa správajú zvláštne, keď sa na ne aplikujú metódy polí. Netušia, že chýbajú indexy:

var fruits = fruits = "Peach" fruits = "Apple" alert(fruits.pop()) // pop "Apple" (na index 9) alert(fruits.pop()) // vyskočí nešpecifikovaný prvok (na index 8 )

Pokúste sa vyhnúť riedkym poliam. V každom prípade ich metódy nebudú fungovať normálne. Namiesto toho použite Objekt.

Odstránenie z poľa

Ako vieme, polia sú objekty, takže na odstránenie hodnoty by sme mohli použiť delete:

var arr = ["Go", "to", "home"] delete arr // now arr = ["Go", undefined, "home"] alert(arr) // notdefined

Môžete vidieť, že hodnota je odstránená, ale nie tak, ako by sme chceli, pretože pole obsahuje nešpecifikovaný prvok.

Operátor delete odstráni pár kľúč – hodnota a je to. Prirodzene, keďže pole je iba hash, pozícia odstráneného prvku sa stane nedefinovanou.

Najčastejšie potrebujeme odstrániť prvok bez toho, aby sme medzi indexmi nechali „diery“. Je tu ešte jedna metóda, ktorá nám s tým pomôže.

spájacia metóda

Metóda spájania môže odstrániť prvky a nahradiť ich vo viacrozmerných poliach JavaScriptu. Jeho syntax je:

arr.splice(index, deleteCount[, prvok1, ..., prvokN])

Odstráni prvok deleteCount začínajúci na indexe a potom na jeho miesto vloží prvky elem1, ..., elemN.

Pozrime sa na niekoľko príkladov:

var arr = ["Go", "to", "home"] arr.splice(1, 1) // odstránenie 1 prvku od indexu 1 alert(arr.join("")) // ["Go " , "home"] (1 prvok odstránený)

Takže môžete použiť splice na odstránenie jedného prvku z poľa. Čísla prvkov poľa sú posunuté tak, aby vyplnili priestor:

var arr = ["Go", "to", "home"] arr.splice(0, 1) // odstránenie 1 prvku, počnúc indexom 0 alert(arr) // "to" sa stalo prvým prvkom

Nasledujúci príklad ukazuje, ako nahradiť prvky:

Metóda spájania vracia pole odstránených prvkov:

var arr = ["Choď", "do", "domov", "teraz"]; // odstránenie prvých 2 prvkov 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"

Táto metóda môže použiť aj záporný index, ktorý sa počíta od konca poľa:

var arr = // pre prvok -1 (predposledný) // odstráňte 0 prvkov, // a vložte 3 a 4 arr.splice(-1, 0, 3, 4) alert(arr) // 1,2,3, 4.5

Samostatne spravovaná úloha

Objekt obsahuje vlastnosť className, ktorá obsahuje názvy tried oddelené medzerami:

var obj = (názov triedy: "otvoriť menu")

Napíšte funkciu removeClass(obj, cls), ktorá odstráni triedu cls, ak je zadaná:

removeClass(obj, "open") // obj.className="menu" removeClass(obj, "blabla") // žiadne zmeny (neexistuje žiadna trieda na odstránenie)

Riešenie

Musíte rozdeliť className na časti a prechádzať cez tieto časti. Ak sa nájde zhoda, odstráni sa z poľa objektov JavaScript a potom sa pridá späť na koniec.

Poďme to trochu optimalizovať:

function 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 = ( className: "open menu" ) removeClass(obj, "open") removeClass(obj, "blabla") upozornenie (obj.className) // menu

Vo vyššie uvedenom príklade je premenná c nastavená na začiatku cyklu a i je nastavená na svoj posledný index.

Samotný cyklus prebieha v opačnom smere a končí podmienkou i>=0. Toto sa robí, pretože i>=0 sa kontroluje rýchlejšie ako i . Čo urýchľuje vyhľadávanie vlastností v c .

plátková metóda

Časť poľa môžete extrahovať pomocou metódy slice(begin[, end]): var arr = ["Prečo", "učiť sa", "JavaScript"]; var arr2 = arr.slice(0,2) // má 2 prvky, počnúc 0 alert(arr2.join(", ")) // "Prečo, učiť sa"

Upozorňujeme, že táto metóda nemení počet prvkov v poli v JavaScripte, ale skopíruje časť z neho.

Druhý argument môžete vynechať, aby ste získali všetky prvky začínajúce na konkrétnom indexe:

var arr = ["Prečo", "učiť sa", "JavaScript"]; var arr2 = arr.slice(1) // preberá všetky prvky od 1 upozornenia(arr2.join(", ")) // "learn, JavaScript"

Metóda podporuje záporné indexy, rovnako ako String#slice .

reverzná metóda

Ďalšou užitočnou metódou je reverzná metóda. Povedzme, že chcem získať poslednú časť domény ako " com“ od “ my.site.com" Postup:

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

Všimnite si, že polia JavaScript podporujú komplexnú syntax (reverse()) na volanie metódy a následné načítanie prvku z výsledného poľa.

Môžete vytvárať dlhšie hovory ako reverse() 0] arr.sort() alert(arr) // 1, 15, 2

Spustite vyššie uvedený kód. Dostanete objednávku 1, 15, 2. Je to preto, že metóda konvertuje všetko na reťazec a štandardne používa lexikografické poradie.