V této lekci se seznámíme s poli, naučíme se je vytvářet, provádět operace s jejich prvky a také se podíváme na základní metody a vlastnosti dostupné při práci s nimi.

Co je pole v JavaScriptu?

Pole je uspořádaný sběr hodnot. Hodnoty v této kolekci se nazývají elementy. Každý prvek v poli má své sériové číslo (číslo), které se nazývá index. Indexy jsou číslovány od 0.

Následující obrázek ukazuje číselné pole skládající se z 5 prvků. Prvky tohoto pole obsahují následující údaje: 123 (index 0), 7 (index 1), 50 (index 2), -9 (index 3), 24 (index 4).

Vytvoření (deklarace) pole

Vytváření polí v JavaScriptu se obvykle provádí pomocí pole doslovný.

Literál pole se skládá z hranatých závorek obsahujících seznam prvků oddělených čárkou.

Například:

Var empty = ; // prázdné pole var čísla = ; // číselné pole var arr = ; // pole obsahující různé datové typy

Hodnoty v poli JavaScript nemusí být stejného typu. Tito. Jedno pole může obsahovat hodnoty různých datových typů.

Ke konkrétnímu prvku pole se přistupuje pomocí jeho indexu. Tato operace se také nazývá operace indexování.

Například:

// vytvořte pole sestávající ze 3 prvků var smartphoneColors = ["Black", "White", "Grey"]; // zobrazí v konzole prohlížeče hodnoty prvků pole smartphoneColors s indexy 0 a 2 console.log("Hodnota prvku pole smartphonuColors s indexem 0: " + smartphoneColors); // "Hodnota prvku pole smartphoneColors s indexem 0: Černá" console.log("Hodnota prvku pole smartphoneColors s indexem 2: " + smartphoneColors); // "Hodnota prvku pole smartphoneColors s indexem 0: Gray" // změňte hodnotu prvku pole smartphoneColors s indexem 1 na "Red" smartphoneColors = "Red"; // ["Black", "Red", "Grey"] // nastaví prvek pole smartphoneColors s indexem 3 na hodnotu "Blue" smartphoneColors = "Blue"; // ["Černá", "Červená", "Šedá", "Modrá"]

Jako hodnoty prvků pole můžete použít nejen statické hodnoty, ale také výrazy:

Var délkaA = 7, šířkaA = 5; var bod = ;

Objekty lze použít jako hodnoty prvků pole.

Var body = [ (x1: 5, y1: 3), (x1: 7, y1: 10), (x1: 12; y1: 0) ]; // pole sestávající ze 3 objektů

Další způsob, jak vytvořit pole spočívá ve volání funkce konstruktoru Array.

Volání funkce konstruktoru bez argumentů se používá k vytvoření prázdného pole.

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

Tato metoda vytváření pole je ekvivalentní literálu.

Pokud zadáte číslo jako argument funkce konstruktoru, vytvoří pole, které se bude skládat ze zadaného počtu prvků. Navíc všechny tyto prvky budou mít nedefinovanou hodnotu.

Var arr = new Array(5); // pole skládající se z 5 prvků (hodnoty prvků nejsou definovány)

Pokud předáte funkci konstruktoru v závorkách několik hodnot nebo jednu nečíselnou hodnotu, vytvoří pole z argumentů, které jí byly předány.

Na rozdíl od mnoha jiných programovacích jazyků, pole v JavaScriptu automaticky mění svou velikost, tzn. jsou ze své podstaty dynamické. Taková pole nemusí mít žádné rozměry. Dalším charakteristickým rysem polí JavaScriptu je, že různé prvky stejného pole mohou obsahovat různé typy dat.

vlastnost length (délka pole)

Určení délky pole (počet prvků) se provádí pomocí vlastnosti length.

//vytvoří pole výpisem hodnot prvků ve funkci Array var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //přiřadí proměnnou lengthArray délce pole volumeHDDs var lengthArray = volumeHDDs.length;

Jak získat první prvek pole

Získání hodnoty prvního prvku pole se provede zadáním čísla 0 v hranatých závorkách tohoto pole:

//vytvoření pole sestávajícího ze 3 prvků var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //získání hodnoty prvního prvku pole var firstValue = volumeHDDs;

Jak získat poslední prvek pole

Hodnota posledního prvku pole se získá zadáním výrazu název_pole.délka-1 v hranatých závorkách tohoto pole:

//vytvoření pole sestávajícího ze 3 prvků var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //získání hodnoty posledního prvku pole var lastValue = volumeHDDs;

Iterace přes pole

Iterace přes prvky pole se provádí pomocí cyklu for.

Pojďme například iterovat všechny prvky pole a zobrazit jejich hodnoty v konzole prohlížeče (F12):

//vytvoření pole nameStudents, sestávajícího ze 4 prvků var nameStudents = new Array("Petya","Vasya","Kolya","Maxim"); // iterace prvků pole z 0 na délku pole-1 for (var i=0; i<= nameStudents.length-1; i++) { console.log(i+1 + " элемент массива = " + nameStudents[i]); }

Jaký je účel operátora mazání?

Operátor delete se nepoužívá k odstranění prvku z pole, ale k přiřazení nedefinované hodnoty danému prvku pole.

Var namePlanets = new Array("Venuše","Merkur","Země","Mars"); odstranit jménoPlanety; pro (var i=0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }

Funkce pro práci s poli (metody objektů Array)

Objekt Array obsahuje následující metody (funkce) pro práci s poli:

• posun
• neřadit
• plátek
• spoj
• rozdělit
• zvrátit

Push metoda (přidání prvku na konec pole)

Metoda push je navržena tak, aby přidala prvek na konec pole. Hodnota tohoto prvku je určena jako parametr této metody. Výsledkem je, že metoda push vrací počet prvků v poli, přičemž bere v úvahu, co bylo přidáno.

Název VarPlanets = ["Venuše", "Merkur", "Země", "Mars"]; namePlanets.push("Jupiter"); // 5 console.log(namePlanets); // ["Venuše", "Merkur", "Země", "Mars", "Jupiter"]

metoda pop (odstranění posledního prvku z pole)

Metoda pop je navržena tak, aby odstranila poslední prvek z pole. Tato metoda nemá žádné parametry. Výsledkem je, že vrátí hodnotu posledního (odstraněného) prvku pole.

Název VarPlanets = ["Venuše", "Merkur", "Země", "Mars"]; namePlanets.pop(); // "Mars" console.log(namePlanets); // ["Venuše", "Merkur", "Země"]

Shift metoda (odstranění prvního prvku z pole)

Metoda posunu je navržena tak, aby odstranila první prvek z pole, tzn. prvek mající index 0. Všechny ostatní prvky pole jsou posunuty na začátek, tzn. pro každý z nich se index sníží o 1. Tato metoda jako výsledek vrátí hodnotu odstraněného prvku.

Název VarPlanets = ["Venuše", "Merkur", "Země", "Mars"]; namePlanets.shift(); // "Venuše" console.log(namePlanets); // ["Merkur", "Země", "Mars"]

metoda unshift (přidání prvku na začátek pole)

Metoda unshift je navržena tak, aby přidala prvek na začátek pole (před ostatní prvky). Hodnota tohoto prvku je určena jako parametr této metody. Výsledkem je, že tato metoda vrací počet prvků v poli, přičemž bere v úvahu, co bylo přidáno.

Var namePlanets = ["Merkur", "Země", "Mars", "Jupiter"]; namePlanets.unshift("Venuše"); // 5 console.log(namePlanets); // ["Venuše", "Merkur", "Země", "Mars", "Jupiter"]

metoda slice (kopírování části pole)

Metoda slice je navržena tak, aby kopírovala část pole. Nezmění však původní pole, ale jako výsledek vrátí nové pole sestávající z vybraných prvků.

Metoda slice má 2 parametry:

• 1 parametr (povinný) - je určen k označení indexu prvku, od kterého se má začít kopírovat prvky;
• Parametr 2 (nepovinný) - je určen k označení indexu prvku, do kterého je nutné kopírovat (v tomto případě není zahrnut v novém poli). Pokud jej nezadáte, budou zkopírovány prvky až do konce zadaného pole.

var namePlanets = ["Venuše", "Merkur", "Země", "Mars", "Jupiter"]; var newNamePlanets = namePlanets.slice(2, 4); // ["Země", "Mars"]

Splice metoda (změna obsahu pole)

Metoda splice je navržena tak, aby změnila obsah pole. Lze jej použít jak k přidání prvků do pole, tak k jejich odstranění.

Syntaxe metody spojování je:

Array.splice(startIndex, deleteCount [, prvek1[, prvek2[, ...]]]); /* startIndex (povinné) – počáteční index prvku, od kterého se má začít měnit pole. Pokud jako startIndex zadáte číslo větší, než je délka pole, bude počáteční index nastaven na konec pole. Pokud jako startIndex zadáte záporné číslo, bude se počáteční prvek počítat od konce. deleteCount (povinné) – číslo udávající, kolik prvků je třeba z pole odstranit. Pokud prvky není nutné z pole odstraňovat, musí být deleteCount nastaveno na 0. Poté musíte zadat alespoň jeden nový prvek, který se má do pole přidat. Pokud jako deleteCount zadáte číslo, které překročí počet zbývajících prvků v poli, počínaje startIndex, pak v tomto případě budou stále odstraněny (tj. všechny prvky do konce pole, počínaje počátečním indexem) prvek1, prvek2, ... (volitelné) - prvky, které je třeba přidat do pole. */

Příklady použití metody spojování.

Použití metody splice k odstranění některých prvků z pole.

Název VarPlanets = ["Venuše", "Merkur", "Země", "Mars"]; namePlanets.splice(2, 2); //["Země", "Mars"] console.log(namePlanets); // ["Venuše", "Merkur"]

Pomocí metody splice odeberete prvek z pole a přidáte k němu nové.

Název VarPlanets = ["Venuše", "Merkur", "Země", "Mars"]; namePlanets.splice(1, 1, "Uran", "Neptun", "Saturn"); // ["Merkur"] console.log(namePlanets); // ["Venuše", "Uran", "Neptun", "Saturn", "Země", "Mars"]

Použití metody splice pouze k přidání nových prvků do pole.

Var namePlanets = ["Jupiter", "Saturn", "Uran"]; namePlanets.splice(0, 0, "Venuše", "Merkur", "Země", "Mars"); // console.log(namePlanets); // ["Venuše", "Merkur", "Země", "Mars", "Jupiter", "Saturn", "Uran"]

metoda join (převod pole na řetězec)

Metoda join je navržena tak, aby spojila všechny prvky pole do řetězce.

Syntaxe metody spojení:

Array.join(); /* oddělovač (volitelný) – oddělovač, který se používá jako spojovací řetězec mezi každým prvkem pole. Pokud tento parametr není zadán, bude jako spojovací řetězec použit ",". Pokud jako parametr zadáte prázdný řetězec, nebudou prvky pole ve vráceném řetězci ničím odděleny */

Var bobule = ["Hrozny", "Hrozny", "Rybíz", "Šípek"]; var bobuleStr1 = bobule.join(); // "Hrozny, Hrozny, Rybíz, Šípky" var berriesStr2 = berries.join(""); // "HroznyHroznyRybíz" var berriesStr3 = berries.join(", "); // "Hrozny, Hrozny, Rybíz, Šípky" var berriesStr4 = berries.join(" + "); // "Hrozny + Hrozny + Rybíz + Šípky"

Pokud jako oddělovač použijete jiný než řetězec, bude převeden na řetězec.

Var bobule = ["Hrozny", "Hrozny", "Rybíz", "Šípek"]; var berriesStr1 = berries.join(false); // "GrapesfalseGrapesfalseCurrantfalseRosehip" var berriesStr2 = berries.join(4/2); // "Grapes2Grapes2Currant2Rose Hip" Prvky pole, které mají hodnotu null nebo undefined jako hodnotu, budou přetypovány na prázdný řetězec. var arr = ; var arrStr = arr.join(", "); // "0, 5, -4"

Převod řetězce na pole - rozdělení

Metoda rozdělení je navržena tak, aby převáděla řetězec na pole. Tato metoda má jeden parametr, pomocí kterého můžete zadat řetězec, na základě kterého bude tento řetězec rozdělen do pole řetězců.

Var strElementComputers = "Systémová jednotka, monitor, klávesnice, myš, reproduktory, tiskárna"; var elementComputers = strElementComputers.split(", "); console.log("Počet prvků v poli: " + prvekPočítače.délka); pro (var i=0; i<= elementComputers.length-1; i++) { console.log(i + " элемент массива = " + elementComputers[i]); }

Změna pořadí prvků pole v opačném pořadí - obráceně

Zpětná metoda je navržena tak, aby změnila pořadí prvků pole v opačném pořadí.

Var namePlanets = new Array("Venuše","Merkur","Země","Mars"); namePlanets.reverse(); console.log("Počet prvků v poli: " + názevPlanets.length); pro (var i=0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }

Třídění prvků pole - sort

Metoda řazení se používá k řazení prvků pole. Ve výchozím nastavení tato metoda třídí pole jako řetězce.

Var namePlanets = new Array("Venuše","Merkur","Země","Mars"); namePlanets.sort(); console.log("Počet prvků v poli: " + názevPlanets.length); pro (var i=0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }

21.06.2017 ve 12:17

Chcete-li vypočítat velikost pole objektů v JavaScriptu, použijte vlastnost length pole.

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

Pole v javascriptu mohou mít chybějící indexy. Například

Var arr = ; arr = "první"; arr = "druhý";

Vlastnost length vrací maximální index pole + 1. tzn. v uvedeném příkladu délka = 5.

Výpočet počtu prvků v poli v javascriptu

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

Příklad použití

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

Můžete také přiřadit hodnotu vlastnosti length. To vám umožní zkrátit délku existujícího pole.

Var arr = ["první", "druhý", "třetí"]; arr.length = 2; console.log(arr); // ["první vteřina"]

Výpočet velikosti pole v bajtech v javascriptu

Pole jsou běžné objekty, takže výpočet velikosti pole v bajtech se neliší od výpočtu velikosti jakéhokoli jiného objektu. Javascript bohužel neposkytuje API pro výpočet velikosti, takže si to budete muset spočítat sami. To se provádí následovně: projdeme všechny vlastnosti objektu; pokud je vlastnost primitivního typu, přidáme k celkovému výsledku velikost instance tohoto typu; pokud vlastnost obsahuje objekt, rekurzivně vypočítáme jeho velikost.

Funkce sizeOf(obj) ( var bytes = 0; if(obj !== null && obj !== undefined) ( switch(typeof obj) ( case "number": bytes += 8; break; case "string": bytes += obj.length * 2; break; case "boolean": bytes += 4; break; case "object": for(var key in obj) ( bytes += sizeOf(obj); ) break; ) ) return bytes ;);

Metoda není přesná a má mnoho problémů - například existuje možnost přechodu do nekonečné smyčky.

Poslední aktualizace: 26.03.2018

Objekt Array představuje pole a poskytuje řadu vlastností a metod, pomocí kterých můžeme s polem manipulovat.

Inicializace pole

Prázdné pole můžete vytvořit pomocí hranatých závorek nebo konstruktoru Array:

Uživatelé Var = new Array(); var lidi = ; console.log(users); // Pole console.log(people); //Pole

Okamžitě můžete inicializovat pole s určitým počtem prvků:

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

Můžete definovat pole a přidávat do něj nové prvky:

Uživatelé Var = new Array(); uživatelé = "Tom"; uživatelé = "Kate"; console.log(users); // "Tom" console.log(users); //nedefinováno

Nezáleží na tom, že ve výchozím nastavení je pole vytvořeno s nulovou délkou. Pomocí indexů můžeme nahradit jeden nebo jiný prvek v poli na konkrétním indexu.

délka

Chcete-li zjistit délku pole, použijte vlastnost length:

Var ovoce = new Array(); ovoce = "jablka"; ovoce = "hrušky"; ovoce = "švestky"; document.write("V poli fruit " + fruit.length + " element:
"); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

Ve skutečnosti bude délka pole indexem posledního prvku plus jedna. Například:

Uživatelé Var = new Array(); // v poli je 0 prvků users = "Tom"; uživatelé = "Kate"; uživatelé = "Sam"; for(var i=0; i

Výstup z prohlížeče:

Tom Kate undefined undefined Sam

Navzdory tomu, že jsme nepřidali prvky pro indexy 2 a 3, délka pole bude v tomto případě číslo 5. Prostě prvky s indexy 2 a 3 budou mít hodnotu undefined .

Kopírování pole. plátek()

Kopírování pole může být mělké nebo mělké (mělká kopie) a hluboké (hluboká kopie).

Pro mělké kopírování stačí přiřadit proměnné hodnotu jiné proměnné, která ukládá pole:

Uživatelé Var = ["Tom", "Sam", "Bill"]; console.log(users); // ["Tom", "Sam", "Bill"] var people = users; // mělké kopírování lidí = "Mike"; // změna druhého prvku console.log(users); // ["Tom", "Mike", "Bill"]

V tomto případě bude proměnná people po zkopírování ukazovat na stejné pole jako proměnná users. Při změně prvků v lidech se tedy změní i prvky v uživatelích, protože ve skutečnosti jde o stejné pole.

Toto chování není vždy žádoucí. Například chceme, aby proměnné po zkopírování ukazovaly na samostatná pole. A v tomto případě můžete použít hluboké kopírování pomocí metody slice():

Uživatelé Var = ["Tom", "Sam", "Bill"]; console.log(users); // ["Tom", "Sam", "Bill"] var people = users.slice(); // deep copy people = "Mike"; // změna druhého prvku console.log(users); // ["Tom", "Sam", "Bill"] console.log(people); // ["Tom", "Mike", "Bill"]

V tomto případě budou proměnné po zkopírování ukazovat na různá pole a můžeme je měnit odděleně od sebe.

Metoda slice() také umožňuje zkopírovat část pole:

Uživatelé Var = ["Tom", "Sam", "Bill", "Alice", "Kate"]; var people = users.slice(1, 4); console.log(people); // ["Sam", "Bill", "Alice"]

Metodě slice() jsou předány počáteční a koncové indexy, které se používají k načítání hodnot z pole. To znamená, že v tomto případě výběr do nového pole přejde z indexu 1 na index 4, bez zahrnutí. A protože indexování pole začíná od nuly, nové pole bude obsahovat druhý, třetí a čtvrtý prvek.

TAM()

Metoda push() přidá prvek na konec pole:

Var ovoce = ; fruit.push("jablka"); ovoce.push("hrušky"); fruit.push("švestky"); ovoce.push("třešeň","meruňka
"); document.write(ovoce); // jablka, hrušky, švestky, třešně, meruňky

pop()

Metoda pop() odstraní poslední prvek z pole:

Var ovoce = ["jablka", "hrušky", "švestky"]; var lastFruit = ovoce.pop(); // extrahujte poslední prvek z pole document.write(lastFruit + "
"); document.write("V poli fruit " + fruit.length + " prvek:
"); for(var i=0; i ");

Výstup z prohlížeče:

Švestky Pole ovoce má 2 prvky: jablka hrušky

posun()

Metoda shift() načte a odstraní první prvek z pole:

Var ovoce = ["jablka", "hrušky", "švestky"]; var firstFruit = ovoce.shift(); document.write(firstFruit + "
"); document.write("V poli fruit " + fruit.length + " prvek:
"); for(var i=0; i ");

Výstup z prohlížeče:

Jablka Pole ovoce má 2 prvky: hrušky švestky

unshift()

Metoda unshift() přidá na začátek pole nový prvek:

Var ovoce = ["jablka", "hrušky", "švestky"]; fruit.unshift("meruňky"); dokument.zapisovat(ovoce);

Výstup z prohlížeče:

Meruňky, jablka, hrušky, švestky

Odebrání prvku podle indexu. spoj ()

Metoda splice() odstraňuje prvky na konkrétním indexu. Například odstranění prvků ze třetího indexu:

Uživatelé Var = ["Tom", "Sam", "Bill", "Alice", "Kate"]; var delete = users.splice(3); console.log(smazáno); // [ "Alice", "Kate" ] console.log(users); // [ "Tom", "Sam", "Bill" ]

Metoda řezu vrátí odstraněné prvky.

V tomto případě dojde k odstranění od začátku pole. Pokud předáte záporný index, bude smazání provedeno od konce pole. Například odstraníme poslední prvek:

Uživatelé Var = ["Tom", "Sam", "Bill", "Alice", "Kate"]; var smazáno = users.splice(-1); console.log(smazáno); // [ "Kate" ] console.log(users); // [ "Tom", "Sam", "Bill", "Alice" ]

Další verze metody umožňuje zadat koncový index pro odstranění. Například smažeme první až třetí index:

Uživatelé Var = ["Tom", "Sam", "Bill", "Alice", "Kate"]; var delete = users.splice(1,3); console.log(smazáno); // [ "Sam", "Bill", "Alice" ] console.log(users); // [ "Tom", "Kate" ]

Jiná verze metody spojování umožňuje vkládat nové prvky místo odstraněných prvků:

Uživatelé Var = ["Tom", "Sam", "Bill", "Alice", "Kate"]; var delete = users.splice(1,3, "Ann", "Bob"); console.log(smazáno); // [ "Sam", "Bill", "Alice" ] console.log(users); // [ "Tom", "Ann", "Bob", "Kate" ]

V tomto případě odstraníme tři prvky z 1. až 3. indexu a místo nich vložíme dva prvky.

spojit()

Metoda concat() se používá ke kombinování polí:

Var ovoce = ["jablka", "hrušky", "švestky"]; var zelenina = ["rajčata", "okurky", "brambory"]; var produkty = ovoce.concat(zelenina); for(var i=0; i< products.length; i++) document.write(products[i] + "
");

V tomto případě není nutné kombinovat pouze pole stejného typu. Jsou možné různé typy:

Var ovoce = ["jablka", "hrušky", "švestky"]; var ceny = ; var produkty = ovoce.concat(ceny);

připojit se()

Metoda join() spojuje všechny prvky pole do jednoho řetězce:

Var ovoce = ["jablka", "hrušky", "švestky", "meruňky", "broskve"]; var fruitString = fruit.join(", "); document.write(fruitString);

Metodě join() se předá oddělovač mezi prvky pole. V tomto případě se jako oddělovač použije čárka a mezera (", ").

seřadit ()

Metoda sort() seřadí pole ve vzestupném pořadí:

Var ovoce = ["jablka", "hrušky", "švestky", "meruňky", "broskve"]; ovoce.sort(); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

Výstup z prohlížeče:

Meruňky hrušky broskve švestky jablka

zvrátit()

Metoda reverse() obrátí pole zpět:

Var ovoce = ["jablka", "hrušky", "švestky", "meruňky", "broskve"]; fruit.reverse(); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

Výstup z prohlížeče:

Broskve meruňky švestky hrušky jablka

V kombinaci s metodou sort() můžete pole seřadit v sestupném pořadí:

Var ovoce = ["jablka", "hrušky", "švestky", "meruňky", "broskve"]; ovoce.sort().reverse(); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

Výstup z prohlížeče:

Jablka švestky broskve hrušky meruňky

Nalezení indexu prvku

Metody indexOf() a lastIndexOf() vracejí index prvního a posledního zahrnutí prvku do pole. Například:

Var ovoce = ["jablka", "hrušky", "švestky", "jablka", "hrušky"]; var firstIndex = fruit.indexOf("jablka"); var lastIndex = fruit.lastIndexOf("jablka"); var otherIndex = fruit.indexOf("třešně"); document.write(firstIndex); // 0 document.write(lastIndex); // 3 document.write(otherIndex); // -1

firstIndex má hodnotu 0, protože první zahrnutí řádku „jablka“ v poli je na indexu 0 a poslední je na indexu 3.

Pokud prvek není v poli, pak v tomto případě metody indexOf() a lastIndexOf() vrátí hodnotu -1.

každý()

Metoda every() kontroluje, zda všechny prvky splňují určitou podmínku:

Čísla var = [ 1, -12, 8, -4, 25, 42]; funkce podmínka (hodnota, index, pole) ( var výsledek = nepravda; if (hodnota > 0) ( výsledek = pravda; ) návrat výsledek; ); var předán = čísla.každý(podmínka); dokument.zapis(prošel); // Nepravdivé

Metodě every() je předána funkce představující podmínku jako parametr. Tato funkce má tři parametry:

Podmínka funkce (hodnota, index, pole) ( )

Parametr value představuje aktuální iterovaný prvek pole, parametr index představuje index tohoto prvku a parametr pole předává odkaz na pole.

V této funkci můžeme zkontrolovat, zda předaná hodnota prvku vyhovuje nějaké podmínce. V tomto příkladu například zkontrolujeme každý prvek pole, zda je větší než nula. Pokud je větší, vrátíme hodnotu true , to znamená, že prvek podmínku splňuje. Pokud je méně, pak vraťte false - prvek nesplňuje podmínku.

Výsledkem je, že když je zavolána metoda numbers.every(condition), iteruje všechny prvky pole čísel a předává je jeden po druhém do funkce podmínky. Pokud tato funkce vrátí hodnotu true pro všechny prvky, pak metoda every() vrátí hodnotu true. Pokud alespoň jeden prvek neodpovídá podmínce, pak metoda every() vrátí false .

nějaký()

Metoda some() je podobná metodě every(), pouze kontroluje, zda alespoň jeden prvek odpovídá podmínce. A v tomto případě metoda some() vrací true . Pokud v poli nejsou žádné prvky odpovídající podmínce, vrátí se false:

Čísla var = [ 1, -12, 8, -4, 25, 42]; funkce podmínka(hodnota, index, pole) ( var výsledek = nepravda; if (hodnota === 8) (výsledek = pravda; ) vrátit výsledek; ); var předán = čísla.nějaká(podmínka); // skutečný

filtr()

Metoda filter(), stejně jako some() a every() , přijímá funkci podmínky. Ale zároveň vrací pole těch prvků, které splňují tuto podmínku:

Čísla var = [ 1, -12, 8, -4, 25, 42]; funkce podmínka (hodnota, index, pole) ( var výsledek = nepravda; if (hodnota > 0) ( výsledek = pravda; ) návrat výsledek; ); var filtrovanaCísla = čísla.filtr(podmínka); for(var i=0; i< filteredNumbers.length; i++) document.write(filteredNumbers[i] + "
");

Výstup z prohlížeče:

1 8 25 42

forEach() a map()

Metody forEach() a map() iterují prvky a provádějí s nimi určité operace. Chcete-li například vypočítat druhé mocniny čísel v poli, můžete použít následující kód:

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

Ale pomocí metody forEach() můžete tuto konstrukci zjednodušit:

Čísla var = [1, 2, 3, 4, 5, 6]; function square(value, index, array) ( var result = value * value; document.write("Druhá mocnina čísla " + hodnota + " je " + výsledek + "
"); ); čísla.proKaždý(čtverec);

Metoda forEach() bere jako parametr stejnou funkci, do které se při iteraci přes prvky předá aktuální iterovaný prvek a provádějí se s ním operace.

Metoda map() je podobná metodě forEach; také bere jako parametr funkci, která provádí operace s prvky pole, ale metoda map() vrací nové pole s výsledky operací s prvky pole.

Použijme například metodu map k výpočtu druhých mocnin čísel v poli:

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

Funkce předaná metodě map() přijme aktuální iterovaný prvek, provede s ním operace a vrátí nějakou hodnotu. Tato hodnota pak přejde do výsledného squareArray

V tomto článku se podíváme na standardní pole JavaScriptu s číselnými indexy. Pole jsou deklarována pomocí hranatých závorek:

var ovoce = ["Jablko", "Pomeranč", "Osel"]

Chcete-li extrahovat prvek, umístěte jeho index do hranatých závorek. První index 0:

var fruits = ["Jablko", "Pomeranč", "Osel"] alert(ovoce) alert(ovoce) alert(ovoce)

Můžeme také získat délku pole JavaScript:

var fruits = ["Jablko", "Pomeranč", "Osel"] alert(fruits.length)

Jejda! Vytvořili jsme pole se dvěma plody a oslem. Nyní musíme odstranit osla.

metody pop a push

Metoda pop v JavaScriptu odebere prvek z pole a vrátí jej.

Následující příklad ukazuje, jak je "Osel" načten z pole:

var fruits = ["Apple", "Orange", "Donkey"] alert("Odstraňuji "+fruits.pop()) // Nyní máme pouze ["Apple","Orange"] alert("Nyní" velikost pole: "+fruits.length) // osel odstraněn

Všimněte si, že pop upravuje samotné pole.

Popovým protějškem je metoda push, která přidává prvek do pole. Zapomněli jsme například přidat broskev:

var fruits = ["Jablko", "Pomeranč"] fruits.push("Peach"); // nyní máme upozornění ["Apple", "Orange", "Peach"] ("Poslední prvek:"+ovoce)

1. Vytvořte řadu stylů s prvky “ Jazz”, “Blues”;
2. Přidejte hodnotu " Rock'n'Roll«;
3. Nahraďte druhou hodnotu od konce hodnotou " Klasický". Měli byste skončit s polem: " Jazz”, ”Klasický”, ”Rock'n'Roll" Kód by měl fungovat pro libovolnou délku pole;
4. Načtěte poslední hodnotu z pole a zobrazte ji pomocí výstrahy .

Řešení

// 1 var styles = ["Jazz", "Bluez"] // 2 styles.push("Rock"n"Roll") // or: styles = "Rock"n"Roll" // 3 styly = "Classic" " // 4 alert(styles.pop())

Metody řazení/neřazení

Metody shift/unshift fungují na konci pole, ale můžete také použít shift k posunutí prvků nahoru ( první hodnota pole se odstraní posunutím prvků). Metoda unshift umožňuje JavaScriptu přidat prvek do pole od konce:

var fruits = ["Jablko", "Pomeranč"] var jablko = fruits.shift() // nyní máme pouze ["Pomeranč"] fruits.unshift("Lemon") // nyní máme ["Lemon", " Orange"] alert(fruits.length) // 2

Řazení i vyřazování může fungovat na více prvcích najednou:

var fruits = ["Apple"] fruits.push("Pomeranč","Peach") fruits.unshift("Ananas","Lemon") // pole nyní vypadá takto: ["Ananas", "Lemon", "Jablko" ", "Pomeranč", "Peach"]

Samostatně spravovaný úkol

Napište kód pro zobrazení náhodné hodnoty z pole arr prostřednictvím výstrahy:

var arr = ["Švestka","Pomeranč","Osel","Mrkev","JavaScript"]

Poznámka: Kód pro získání náhodného čísla od minimální po maximální hodnotu (včetně) je následující:

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

Řešení

Potřebujeme extrahovat náhodné číslo od 0 do arr.length-1 (včetně):

var arr = ["Švestka","Oranžová","Osel","Mrkev","JavaScript"] var rand = Math.floor(Math.random()*arr.length) alert(arr)

Iterace přes pole

V JavaScriptu se iterace polem provádí pomocí cyklu for:

var ovoce = ["ananas", "citron", "jablko", "pomeranč", "broskev"] for(var i=0; i

Samostatně spravovaný úkol

Vytvořte funkci find(arr,value), která najde hodnotu v daném poli a vrátí její index nebo -1, pokud se hodnota nenajde.

Například:

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

Řešení

Možné řešení může vypadat takto:

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

To je ale nesprávné, protože == nedefinuje rozdíl mezi 0 a false .

Při práci s poli v JavaScriptu je správnější použít ===. Nejnovější standard ES5 navíc obsahuje funkci Array#indexOf. S ním můžeme definovat funkci takto:

funkce find(pole, hodnota) (​if (pole.indexOf) vrátí pole.indexOf(hodnota) for(var i=0; i

Ještě chytřejší by bylo definovat find s podmínkou pro kontrolu, zda metoda indexOf existuje.

Samostatně spravovaný úkol

Vytvořte funkci filterNumeric(arr), která vezme pole a vrátí nové pole obsahující pouze číselné hodnoty z arr .

Příklad, jak by to mělo fungovat:

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

Řešení

Řešením je iterovat pole a přidat hodnoty do nového pole, pokud jsou číselné.

spojit a rozdělit

Někdy potřebujete rychlý způsob, jak převést pole JavaScriptu na řetězec. K tomu slouží metoda spojení.

Zřetězí pole do řetězce pomocí daného oddělovače:

var ovoce = ["Citron","Jablko","Pomeranč","Peach"]; var str = fruits.join(", "); alert(str);

Zpětnou konverzi lze snadno provést pomocí metody rozdělení:

var ovoce = "Jablko, Pomeranč, Broskev"; var arr = fruits.split(","); // arr nyní obsahuje ["Apple", "Orange", "Peach"] alert(arr);

Samostatně spravovaný úkol

Objekt obsahuje vlastnost className, která obsahuje názvy tříd oddělené mezerami:

Napište funkci addClass(obj, cls), která přidá třídu cls , ale pouze v případě, že neexistuje:

ddClass(obj, "new") // obj.className="open menu new" addClass(obj, "open") // žádné změny (třída již existuje) addClass(obj, "me") // obj.className= výstraha "otevřít nabídku nový mě" (obj.className) //

Řešení

Musíte rozdělit className a smyčku na části. Pokud třída není nalezena, je přidána.

Smyčka byla mírně optimalizována pro zvýšení výkonu:

funkce 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) // otevřít nabídku Nový

Ve výše uvedeném příkladu je proměnná c definována na začátku cyklu a její poslední index je nastaven na i .

Samotný cyklus je zpracováván v opačném směru a končí podmínkou i>=0. Protože i>=0 se kontroluje rychleji než i . Co v JavaScriptu zrychluje vyhledávání v poli.

Použití délky k oříznutí pole

Pomocí vlastnosti length můžete pole zkrátit takto:

Zadáte délku a prohlížeč pole zkrátí.

Pole je objekt, tak co to znamená?

Ve skutečnosti je pole v JavaScriptu objektem s automatickým nastavením délky a speciálními metodami.

To se liší od konceptu v jiných jazycích, kde pole představují souvislý segment paměti. To se také liší od fronty nebo zásobníku založeného na propojených seznamech.

Nenumerické klávesy pole

Klíče jsou čísla, ale mohou mít libovolný název:

arr = arr = 5 arr.prop = 10 // toto nedělejte

V JavaScriptu jsou pole hashovací tabulky, které mají výkonnostní výhody, ale také určité nevýhody.

Například push/pop funguje pouze na nejvzdálenějších prvcích pole, takže jsou neuvěřitelně rychlé.

push funguje pouze s koncem:

var arr = ["Moje", "pole"] arr.push("něco") alert(arr) // řetězec "pole"

Metody shift/unshift jsou pomalé, protože potřebují přečíslovat celé pole. Způsob spojování může také způsobit změnu číslování:

Takže shift/unshift je pomalejší než push/pop . Čím větší je pole, tím déle trvá JavaScriptu seřadit pole.

Samostatně spravovaný úkol

Jaký bude výsledek? Proč?

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

Řešení

Protože pole jsou objekty, arr .. je ve skutečnosti volání metody na objektu, jako je obj metoda:

arr() // stejné jako arr() // syntakticky nesprávné, ale koncepčně stejné: arr.2() // přepsáno stejným stylem jako obj.method() this = arr je v tomto případě předáno funkci, takže se vytiskne obsah arr. arr = ["a", "b"] arr.push(function() ( alert(this) )) arr() // "a","b",funkce

Řídká pole, popis délky

Vlastnost length umožňuje získat nikoli velikost pole v JavaScriptu, ale poslední index + 1. To je důležité, když mluvíme o řídkých polích s „mezery“ v indexech.

V následujícím příkladu přidáme dva prvky do prázdného ovoce, ale hodnota délky zůstane 100:

var fruits = // prázdné pole fruits = "Peach" fruits = "Apple" alert(fruits.length) // 100 (ale v poli jsou pouze 2 prvky)

Pokud se pokusíte o výstup řídkého pole, prohlížeč vrátí chybějící hodnoty indexu jako prázdné prvky:

var fruits = // prázdné pole fruits = "Peach" fruits = "Apple" alert(ovoce) // ,Peach,Apple (nebo něco takového)

Ale pole je objekt se dvěma klíči. Chybějící hodnoty nezabírají místo.

Řídká pole se chovají divně, když jsou na ně aplikovány metody pole. Netuší, že chybí indexy:

var fruits = fruits = "Peach" fruits = "Apple" alert(fruits.pop()) // pop "Apple" (do indexu 9) alert(fruits.pop()) // vyskočí blíže nespecifikovaný prvek (na index 8 )

Snažte se vyhnout řídkým polím. V každém případě jejich metody nebudou fungovat normálně. Místo toho použijte Object.

Odebrání z pole

Jak víme, pole jsou objekty, takže k odstranění hodnoty můžeme použít delete:

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

Můžete vidět, že hodnota je odstraněna, ale ne tak, jak bychom chtěli, protože pole obsahuje blíže nespecifikovaný prvek.

Operátor delete odstraní pár klíč–hodnota a je to. Přirozeně, protože pole je pouze hash, pozice odstraněného prvku se stane nedefinovanou.

Nejčastěji potřebujeme odstranit prvek, aniž bychom mezi indexy nechali „díry“. Existuje ještě jedna metoda, která nám s tím pomůže.

metoda spojování

Metoda splice může odstranit prvky a nahradit je ve vícerozměrných polích JavaScriptu. Jeho syntaxe je:

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

Odebere prvek deleteCount počínaje indexem a poté na jeho místo vloží prvky elem1, ..., elemN.

Podívejme se na několik příkladů:

var arr = ["Go", "to", "home"] arr.splice(1, 1) // odstranění 1 prvku počínaje indexem 1 alert(arr.join("")) // ["Go " , "home"] (1 prvek odstraněn)

Takže můžete použít splice k odstranění jednoho prvku z pole. Čísla prvků pole se posunou tak, aby vyplnily prostor:

var arr = ["Go", "to", "home"] arr.splice(0, 1) // odstranění 1 prvku, počínaje indexem 0 alert(arr) // "to" se stalo prvním prvkem

Následující příklad ukazuje, jak nahradit prvky:

Metoda splice vrací pole odstraněných prvků:

var arr = ["Jít", "do", "domů", "teď"]; // odstranění prvních 2 prvků 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"

Tato metoda může také používat záporný index, který se počítá od konce pole:

var arr = // pro prvek -1 (předposlední) // odeberte 0 prvků, // a vložte 3 a 4 arr.splice(-1, 0, 3, 4) alert(arr) // 1,2,3, 4.5

Samostatně spravovaný úkol

Objekt obsahuje vlastnost className, která obsahuje názvy tříd oddělené mezerami:

var obj = (název třídy: "otevřená nabídka")

Napište funkci removeClass(obj, cls), která odstraní třídu cls, pokud je zadána:

removeClass(obj, "open") // obj.className="menu" removeClass(obj, "blabla") // žádné změny (není žádná třída k odstranění)

Řešení

Musíte rozdělit className na části a procházet těmito částmi. Pokud je nalezena shoda, je odstraněna z pole objektů JavaScriptu a poté přidána zpět na konec.

Pojďme to trochu optimalizovat:

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") výstraha (obj.className) // menu

Ve výše uvedeném příkladu je proměnná c nastavena na začátek cyklu a i je nastavena na její poslední index.

Samotný cyklus běží v opačném směru a končí podmínkou i>=0. To se děje, protože i>=0 se kontroluje rychleji než i . Což urychluje vyhledávání vlastností v c .

plátkovou metodou

Část pole můžete extrahovat pomocí metody slice(begin[, end]): var arr = ["Proč", "učit se", "JavaScript"]; var arr2 = arr.slice(0,2) // přebírá 2 prvky, počínaje 0 alert(arr2.join(", ")) // "Proč, učit se"

Upozorňujeme, že tato metoda nemění počet prvků v poli v JavaScriptu, ale zkopíruje jeho část.

Druhý argument můžete vynechat, abyste získali všechny prvky začínající na konkrétním indexu:

var arr = ["Proč", "učit se", "JavaScript"]; var arr2 = arr.slice(1) // přebírá všechny prvky počínaje 1 alert(arr2.join(", ")) // "learn, JavaScript"

Metoda podporuje záporné indexy, stejně jako String#slice .

reverzní metoda

Další užitečnou metodou je reverzní . Řekněme, že chci získat poslední část domény jako " com" z " my.site.com" Jak na to:

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

Všimněte si, že pole JavaScriptu podporují složitou syntaxi (reverse()) pro volání metody a následné načtení prvku z výsledného pole.

Můžete vytvářet delší volání, jako je reverse() 0] arr.sort() alert(arr) // 1, 15, 2

Spusťte výše uvedený kód. Dostanete objednávku 1, 15, 2. Je to proto, že metoda vše převede na řetězec a ve výchozím nastavení používá lexikografické pořadí.