Pole. Pole pohybující se podle hodnot

v javascriptu. Zde budeme pokračovat v seznámení s Arrays. Promluvme si o vlastnosti length – jak víte: kolik prvků obsahuje pole?

Pojďmě se učit přidat prvky na začátek a konec pole jsou metody unshift a push.

A také pomocí metod shift a pop můžeme odstranit položky také od začátku a konce Array!

Ve skutečnosti je pole objekt skládající se z určitého počtu různých prvků.

Vlastnost length vám sdělí počet prvků v poli.

Vezměme si například pole sedmi dnů v týdnu, které je nám známé z minulého tématu.

Pojďme zjistit a zobrazit počet prvků pole. Chcete-li to provést, jak vidíte v příkladu níže, musíte vytvořit proměnnou, jejíž hodnota bude polem, které nás zajímá, a pro kterou je naopak zadána vlastnost length.

array.length - tento kód nám udává počet prvků pole (kde pole - název pole) .

Do proměnné počet jsme tedy umístili číslo rovné počtu prvků pole.

Takto funguje vlastnost length.

Metoda push přidá prvek na konec pole.

Abyste mohli začít pracovat s metodami přidávání prvků, musíte vytvořit pole.

Níže jsem vytvořil pole "Friends" - friends .

Nyní potřebujeme přidat prvek, tedy ještě jeden název, na konec pole.

Existuje na to metoda push – přidá prvek na konec Array. Vypadá to takto:

Nasťa, Grigorij, Vjačeslav, Alexej, Jakov

Jacobe

Abychom otestovali metodu push ve výše uvedeném příkladu, vytiskli jsme počet prvků pole přátel pomocí vlastnosti length - bylo jich 5. Poté jsme vytiskli celé pole přátel a také poslední prvek pole .

Nyní můžete sami vidět, že prvek je přidán na konec pole!

unshift metoda - přidá prvek na začátek pole.

Zde se opět odkážeme na přátele Array.

Nyní musíme přidat prvek na začátek pole. Na to existuje metoda unshift.

Počet prvků v poli je 5

Boris, Nasťa, Grigorij, Vjačeslav, Alexej

Boris

Abychom otestovali fungování metody unshift, vypíšeme počet prvků pole přátel pomocí vlastnosti length, poté vytiskneme celé pole přátel a také první prvek pole (nezapomeňte, že číslování prvků Array začíná od 0) .

Nyní, jak můžete vidět, byl prvek přidán na začátek Array!

pop metoda - odstraňuje poslední prvek z pole.

A opět pracujeme s polem „Friends“.

Pomocí metody pop - odstranit poslední prvek z pole:

Nasťa, Grigorij, Vjačeslav

Vjačeslav

Pro ilustraci práce metody pop jsme opět zobrazili počet prvků pole pomocí vlastnosti length a poté zobrazili celé pole přátel - tentokrát bez odstraněného posledního prvku.

Také vyvedeno poslední prvek nově vytvořené Array . Abychom zobrazili poslední prvek pomocí vlastnosti length, vzali jsme celkový počet zbývajících prvků v poli (3) a odečetli od něj 1. Vypíšeme tedy poslední prvek pole s číslem 2. Ale toto je třetí prvek, protože číslování v poli začíná 0!!!

směnný způsob - odstraňuje první prvek z pole.

Před námi, stejně jako předtím, je pole "Friends".

S metodou řazení - odeberte první prvek z pole:

Počet prvků v poli je 3

Grigorij, Vjačeslav, Alexej

Gregory

A nakonec, abychom otestovali práci metody shift, zobrazili jsme počet prvků nově získaného pole pomocí vlastnosti length a poté zobrazili celé pole přátel – tentokrát bez odstraněného prvního prvku.

Také vyvedeno první prvek pole. Číslování v poli začíná od 0!!!

Dovolte mi, abych vám to připomněl a jen pro sebe zajímavý bod tento článek!

Abyste zjistili číslo/index posledního prvku pole, potřebujete z jeho prvků (tj. od ) Odečtěte jedničku!!!

Tomu jsme se již věnovali v tématu.

Dobrým způsobem, jak ilustrovat tento bod, by bylo pokračovat v příkladu od bodu, kdy jsme se podívali na pole sedmi dnů v týdnu.

Počet prvků ve dnech pole je 7

Číslo posledního prvku pole je číslo 6

Tímto příkladem jsme tedy zároveň znovu upozornili na skutečnost, že Číslování polí začíná od 0. A jak můžete vidět z tohoto příkladu, číslo 7. prvku pole je číslo 6.

Na konci tohoto tématu si také uděláme domácí úkol. A znovu, zkuste to vyřešit sami.

Domácí úkol pro odstranění z... a přidání prvků do pole v Javascriptu je následující:

1. Vytvořte pole s ovocem: pomeranč, banán, hruška.
2. Zobrazte, kolik ovoce aktuálně máte v poli.
3. Pomocí metod naučených v předchozí lekci přidejte dva druhy ovoce, jablko a ananas, na konec pole a grapefruit na začátek pole.
4. Zobrazte, kolik ovoce aktuálně máte v poli.
5. Pomocí metod naučených v předchozí lekci odstraňte poslední a první prvek z pole.
6. Zobrazte, kolik ovoce aktuálně máte v poli.

Pomeranč, banán, hruška

V košíku mám nyní 3 ovoce

Grapefruit, pomeranč, banán, hruška, jablko, ananas

Nyní mám v košíku 6 druhů ovoce

Pomeranč, banán, hruška, jablko

V košíku mám nyní 4 ovoce

Pole

pole je uspořádaný soubor hodnot. Hodnoty v poli se nazývají prvky a každý prvek je charakterizován číselnou pozicí v poli, která se nazývá index. Pole v JavaScriptu jsou bez typu: prvky pole mohou být libovolného typu a různé prvky stejného pole mohou mít různé typy. Prvky pole mohou být dokonce objekty nebo jiná pole, což vám umožní vytvářet složité datové struktury, jako jsou pole objektů a pole polí.

Indexy pole JavaScript jsou založené na nule a používají 32bitová celá čísla – první prvek pole má index 0. Pole v JavaScriptu jsou dynamická: mohou růst a zmenšovat se podle potřeby; není potřeba deklarovat pevné velikosti polí při jejich vytváření nebo znovu alokovat paměť, když se jejich velikosti změní.

Pole v JavaScriptu jsou specializovanou formou objektů a indexy polí znamenají o něco víc než jen názvy vlastností, které jsou shodou okolností celá čísla.

Vytváření polí

Nejjednodušší způsob, jak vytvořit pole, je pomocí literálu, což je jednoduchý seznam prvků pole v hranatých závorkách oddělených čárkami. Hodnoty v literálu pole nemusí být konstanty – mohou to být libovolné výrazy, včetně objektových literálů:

var prázdný = ; // Prázdné pole var čísla = ; // Pole s pěti číselnými prvky var misc = [ 1.1, true, "a", ]; // 3 prvky různých typů + koncová čárka var base = 1024; var tabulka = ; // Pole s proměnnými var arrObj = [, ]; // 2 pole uvnitř obsahující objekty

Syntaxe literálu pole umožňuje volitelnou koncovou čárku, tzn. literál [,] odpovídá poli se dvěma prvky, nikoli třemi.

Dalším způsobem, jak vytvořit pole, je zavolat konstruktor pole(). Konstruktor můžete zavolat třemi různými způsoby:

Volání konstruktoru bez argumentů:

Var arr = new Array();

V tomto případě bude vytvořeno prázdné pole ekvivalentní literálu.

Zavolejte konstruktor s jediným číselným argumentem určujícím délku pole:

Var arr = new Array(10);

V tomto případě se vytvoří prázdné pole zadané délky. Tuto formu volání konstruktoru Array() lze použít k předběžnému přidělení paměti pro pole, pokud je předem znám počet jeho prvků. Všimněte si, že to neukládá žádné hodnoty do pole.

Explicitně určete v konstruktoru volání hodnot prvních dvou nebo více prvků pole nebo jednoho nečíselného prvku:

Var arr = new Array(5, 4, 3, 2, 1, "test");

V tomto případě se argumenty konstruktoru stanou hodnotami prvků nového pole. Použití literálů pole je téměř vždy jednodušší než použití konstruktoru Array() jako je tento.

Čtení a zápis prvků pole

Prvky pole jsou přístupné pomocí . Vlevo od závorek musí být odkaz na pole. V závorkách musí být libovolný výraz, který vrací nezápornou celočíselnou hodnotu. Tato syntaxe je vhodná pro čtení i zápis hodnoty prvku pole. Proto jsou platná všechna následující prohlášení JavaScriptu:

// Vytvořte pole s jedním prvkem var arr = ["world"]; // Přečtení prvku 0 var value = arr; // Zápis hodnoty do prvku 1 arr = 3.14; // Zápis hodnoty do prvku 2 i = 2; arr[i] = 3; // Zapíše hodnotu do prvku 3 arr = "hello"; // Čtení prvků 0 a 2, zápis hodnoty do prvku 3 arr] = arr;

Dovolte mi připomenout, že pole jsou specializovaný druh objektů. Hranaté závorky používané pro přístup k prvkům pole fungují přesně jako hranaté závorky používané pro přístup k vlastnostem objektu. Interpret JavaScriptu převede číselné indexy v závorkách na řetězce – index 1 se změní na řetězec „1“ – a poté řetězce použije jako názvy vlastností.

Na převodu číselných indexů na řetězce není nic zvláštního: totéž lze provést s běžnými objekty:

var obj = (); // Vytvořte jednoduchý objekt obj = "one"; // Indexujte jej celými čísly

Zvláštností polí je, že při použití názvů vlastností, které jsou nezáporná celá čísla, pole automaticky určují hodnotu vlastnosti délka. Například pole arr bylo vytvořeno výše s jediným prvkem. Poté přiřadil hodnoty svým prvkům na indexech 1, 2 a 3. V důsledku těchto operací se hodnota vlastnosti length pole změnila na 4.

Měli byste jasně rozlišovat mezi indexy polí a názvy vlastností objektů. Všechny indexy jsou názvy vlastností, ale pouze vlastnosti s názvy reprezentovanými celými čísly jsou indexy. Všechna pole jsou objekty a můžete k nim přidávat vlastnosti s libovolnými názvy. Pokud se však dotknete vlastností, které jsou indexy pole, pole odpoví aktualizací hodnoty vlastnosti length podle potřeby.

Vezměte prosím na vědomí, že je povoleno používat záporná a neceločíselná čísla jako indexy pole. V tomto případě jsou čísla převedena na řetězce, které se používají jako názvy vlastností.

Přidávání a odebírání prvků pole

Již jsme viděli, že nejjednodušší způsob, jak přidat prvky do pole, je přiřadit hodnoty novým indexům. Metodu můžete také použít k přidání jednoho nebo více prvků na konec pole. tam():

Var arr = ; // Vytvořte prázdné pole arr.push("nula"); // Přidání hodnoty na konec arr.push("one",2); // Přidejte další dvě hodnoty

Prvek můžete také přidat na konec pole přiřazením hodnoty prvku arr. Chcete-li vložit prvek na začátek pole, můžete použít metodu unshift(), který přesune stávající prvky v poli na vyšší pozice indexu.

Prvky pole lze odstranit pomocí operátoru delete, stejně jako běžné vlastnosti objektu:

Var arr = ; smazat arr; 2 v arr; // false, index pole 2 není definován arr.length; // 3: Operátor delete nemění vlastnost length pole

Odebrání prvku je podobné (ale mírně odlišné) jako přiřazení nedefinovaného prvku. Všimněte si, že použití operátoru delete na prvek pole nezmění hodnotu vlastnosti length ani neposune prvky s vyššími indexy dolů, aby zaplnily prázdnotu po odstraňovaném prvku.

Je také možné odstranit prvky na konci pole jednoduchým přiřazením nové hodnoty vlastnosti length. Pole mají metodu pop()(opak push()), který zmenší délku pole o 1 a vrátí hodnotu odstraněného prvku. Existuje také metoda posun()(opak metody unshift()), která odstraní prvek na začátku pole. Na rozdíl od operátoru delete posouvá metoda shift() všechny prvky dolů na pozici pod jejich aktuálními indexy.

Nakonec existuje víceúčelová metoda spoj (), který umožňuje vkládat, odebírat a nahrazovat prvky polí. Mění hodnotu vlastnosti length a podle potřeby posouvá prvky pole s nižšími nebo vyššími indexy. Všechny tyto metody probereme o něco později.

Vícerozměrná pole

JavaScript nepodporuje „skutečná“ vícerozměrná pole, ale je příjemné je simulovat pomocí polí polí. Pro přístup k datovému prvku v poli polí stačí použít operátor dvakrát.

Předpokládejme například, že proměnná matice je pole polí čísel. Každý prvek matice[x] je polem čísel. Pro přístup ke konkrétnímu číslu v poli můžete použít výraz matice[x][y]. Následuje konkrétní příklad, kdy se jako násobící tabulka používá dvourozměrné pole:

// Vytvoření vícerozměrného pole var table = new Array(10); // V tabulce je 10 řádků pro(var i = 0; i

Metody třídy pole

Standard ECMAScript 3 definuje řadu užitečných funkcí pro práci s poli jako součást Array.prototype , které jsou dostupné jako metody libovolného pole. Tyto metody budou představeny v následujících podkapitolách.

metoda join().

Metoda Array.join() převede všechny prvky pole na řetězce, zřetězí je a vrátí výsledný řetězec. Jako volitelný argument metody můžete předat řetězec, který bude použit k oddělení prvků ve výsledném řetězci. Pokud není zadán oddělovací řetězec, použije se čárka. Výsledkem následujícího fragmentu je například řetězec „1,2,3“:

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

metoda reverse().

Metoda Array.reverse() obrátí pořadí prvků v poli a vrátí přeuspořádané pole. Permutace se provádí přímo na původním poli, tzn. tato metoda nevytváří nové pole s přeuspořádanými prvky, ale přeskupuje je v již existujícím poli. Například následující fragment, který používá metody reverse() a join() má za následek řetězec "3,2,1":

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

metoda sort().

Metoda Array.sort() seřadí prvky v původním poli a vrátí seřazené pole. Pokud je metoda sort() volána bez argumentů, řazení se provádí v abecedním pořadí (prvky jsou v případě potřeby dočasně převedeny na řetězce pro porovnání). Nedefinované prvky se přesunou na konec pole.

Chcete-li třídit v jiném než abecedním pořadí, můžete předat porovnávací funkci jako argument metodě sort(). Tato funkce nastavuje, který z jejích dvou argumentů má být v seřazeném seznamu první. Pokud musí první argument předcházet druhému, musí porovnávací funkce vrátit záporné číslo. Pokud má první argument následovat za druhým v seřazeném poli, musí funkce vrátit číslo větší než nula. A pokud jsou dvě hodnoty ekvivalentní (tj. jejich pořadí není důležité), porovnávací funkce by měla vrátit 0:

Var arr = ; arr.sort(); // Abecední pořadí: 1111, 222, 33, 4 arr.sort(function(a,b) ( // Číselné pořadí: 4, 33, 222, 1111 return ab; // Vrátí hodnotu 0 // v závislosti na pořadí řazení a a b)); // Seřadit pozpátku, od největšího po nejmenší arr.sort(function(a,b) (return b-a));

Všimněte si, jak pohodlné je v tomto úryvku použít nepojmenovanou funkci. Porovnávací funkce je použita pouze zde, takže není třeba ji pojmenovávat.

metoda concate().

Metoda Array.concat() vytvoří a vrátí nové pole obsahující prvky původního pole, na kterém byla zavolána metoda concat() a hodnoty všech argumentů předávaných metodě concat(). Pokud je některý z těchto argumentů sám polem, jeho prvky se přidají do vráceného pole. Je však třeba poznamenat, že neexistuje žádná rekurzivní transformace pole polí na jednorozměrné pole. Metoda concat() nemění původní pole. Níže uvádíme několik příkladů:

Var arr = ; arr.concat(4, 5); // Návrat arr.concat(); // Vrátí arr.concat(,) // Vrátí arr.concat(4, ]) // Vrátí ]

metoda slice().

Metoda Array.slice() vrací řez nebo podpole zadaného pole. Dva argumenty metody definují začátek a konec vráceného fragmentu. Vrácené pole obsahuje prvek, jehož číslo je zadáno v prvním argumentu, plus všechny následující prvky až po prvek, jehož číslo je zadáno ve druhém argumentu (ale bez něj).

Pokud je zadán pouze jeden argument, vrácené pole obsahuje všechny prvky od počáteční pozice do konce pole. Pokud je některý z argumentů záporný, určuje číslo prvku vzhledem ke konci pole. Argument -1 tedy odpovídá poslednímu prvku pole a argument -3 odpovídá třetímu prvku pole od konce. Zde jsou nějaké příklady:

Var arr = ; arr slice(0,3); // Vrátí arr.slice(3); // Vrátí arr.slice(1,-1); // Vrátí arr.slice(-3,-2); // Vrátit se

metoda splice().

Metoda Array.splice() je obecná metoda, která vkládá nebo odstraňuje prvky pole. Na rozdíl od metod slice() a concat() metoda splice() upravuje původní pole, na kterém byla volána. Všimněte si, že metody splice() a slice() mají velmi podobné názvy, ale provádějí zcela odlišné operace.

Metoda splice() může odstranit prvky z pole, vložit nové prvky nebo provést obojí současně. Prvky pole jsou posunuty podle potřeby, aby vytvořily souvislou sekvenci po inzerci nebo deleci.

První argument metody splice() určuje pozici v poli, ze které bude provedeno vložení a/nebo odstranění. Druhý argument určuje počet prvků, které mají být odstraněny (vyříznuty) z pole. Pokud je druhý argument vynechán, budou odstraněny všechny prvky pole od zadaného pole až do konce pole. Metoda splice() vrací pole odstraněných prvků nebo (pokud nebyly odstraněny žádné prvky) prázdné pole.

První dva argumenty metody splice() určují prvky pole, které mají být odstraněny. Po těchto argumentech může následovat libovolný počet volitelných argumentů, které určují prvky, které mají být vloženy do pole, počínaje pozicí zadanou v prvním argumentu.

Var arr = ; arr.splice(4); // Vrátí , arr = arr.splice(1,2); // Vrátí , arr = arr.splice(1,1); // Vrátí ; arr = arr =; arr.splice(2,0,"a","b"); // Vrátí ; arr=

metody push() a pop().

Metody push() a pop() umožňují, aby se s poli zacházelo jako se zásobníky. Metoda push() přidá jeden nebo více nových prvků na konec pole a vrátí jeho novou délku. Metoda pop() provede obrácenou operaci – odstraní poslední prvek pole, zkrátí délku pole a vrátí hodnotu, kterou odstranil. Všimněte si, že obě tyto metody upravují původní pole, nevytvářejí jeho upravenou kopii.

metody unshift() a shift().

Metody unshift() a shift() se chovají podobně jako push() a pop(), až na to, že vkládají a odebírají prvky na začátek pole, nikoli na konec. Metoda unshift() posouvá stávající prvky směrem k vyšším indexům, aby se uvolnilo místo, přidá prvek nebo prvky na začátek pole a vrátí novou délku pole. Metoda shift() odstraní a vrátí první prvek pole, přičemž všechny následující prvky posune o jednu pozici dolů, aby se zaplnilo volné místo na začátku pole.

S poli lze manipulovat pomocí různých metod poskytovaných konstruktorem pole.

metody pop/push a shift/unshift

Zvažte metody pop() a push(). Tyto metody umožňují, aby se s poli zacházelo jako se zásobníky. Zásobník je datová struktura, ve které je přístup k prvkům organizován podle principu LIFO (anglicky last in - first out, "last in - first out"). Princip stohu lze přirovnat ke stohu talířů: chcete-li vzít druhý shora, musíte odstranit ten horní. Jak to funguje je znázorněno na obrázku:

Vraťme se tedy k metodám push() a pop(). Metoda push() přidá jeden nebo více nových prvků na konec pole a vrátí jeho novou délku. Metoda pop() odstraní poslední prvek pole, zkrátí délku pole a vrátí hodnotu, kterou odstranil. Všimněte si, že obě tyto metody upravují pole na místě, místo aby vytvořily jeho upravenou kopii.

var foo = ; // foo: foo.push(1,2); // foo: Vrátí 2 foo.pop(); // foo: Vrátí 2 foo.push(3); // foo: Vrátí 2 foo.pop(); // foo: Vrátí 3 foo.push(); // foo: ] Vrátí 2 foo.pop() // foo: Vrátí foo.pop(); // foo: Vrátí 1 var ovoce = ["hrušky", "banány", "jablka"]; var sbíral = ovoce.pop(); document.write("Utrhl jsi mi" + vybral); Snaž se "

Metody shift() a unshift() se chovají podobně jako pop() a push(), kromě toho, že vkládají a odebírají prvky na začátek pole. Metoda unshift() posouvá existující prvky směrem k vyšším indexům, aby uvolnila místo pro nové prvky, přidá jeden nebo více prvků na začátek pole a vrátí novou délku pole. Metoda shift() odstraní první prvek pole a vrátí jeho hodnotu, přičemž posune všechny následující prvky tak, aby zabíraly místo na začátku pole.

Var f = ; // f: f.unshift(1); // f: Vrací: 1 f.unshift(22); // f: Vrací: 2 f.shift(); // f: Vrací: 22 f.unshift(3,); // f:,1] Vrací: 3 f.shift(); // f:[,1] Vrací: 3 f.shift(); // f: Vrací: f.shift(); // f: Vrátí: 1

metoda spojení

Metoda Array.join() se používá ke spojení prvků pole do jednoho řetězce. Metodě můžete předat volitelný argument řetězce, který bude použit k oddělení prvků v řetězci. Pokud není oddělovač zadán, bude výchozím oddělovacím znakem při volání metody čárka.

Var a = ["Vítr","Déšť","Požár"]; var myVar1 = a.join(); //"Wind, Rain, Fire" var myVar2 = a.join(", "); //"Vítr, déšť, oheň" var myVar3 = a.join(" + "); //"Vítr + déšť + oheň" document.write(myVar1 + "
" + myVar2 + "
" + myVar3); Zkuste »

Metoda Array.join() je inverzní k metodě String.split(), která vytváří pole rozdělením řetězce na části.

obrácená metoda

Metoda Array.reverse() obrátí pořadí prvků v poli a vrátí pole s přeuspořádanými prvky. Tato metoda nevytváří nové pole s přeuspořádanými prvky, ale mění jejich pořadí v již existujícím poli.

Var myArr = ["jeden", "dva", "tři"]; document.write(myArr.reverse()); Snaž se "

concate metoda

Metoda Array.concat() vytvoří a vrátí nové pole obsahující prvky původního pole, na kterém byla zavolána metoda concat(), postupně doplněné hodnotami všech argumentů předávaných metodě concat(). Pokud je některý z těchto argumentů sám o sobě polem, budou přidány všechny jeho prvky. Názvy polí se používají jako argumenty a jsou specifikovány v pořadí, ve kterém mají být jejich prvky zřetězeny.

Var a = ; a.concat(4, 5) //Vrátí a.concat(); //stejné - vrátí a.concat(,) //Vrátí

způsob řazení

Metoda Array.sort() seřadí prvky pole na místě a vrátí seřazené pole. Pokud je metoda sort() volána bez argumentu, seřadí prvky pole abecedně (dočasně je převede na řetězce pro účely porovnání). Jako argument může metoda sort() používat porovnávací funkci, která určuje pořadí řazení prvků.

Var a = ["Kiwi", "Pomeranče", "Hrušky"]; a.sort(); vars = a.join(", "); //Pomeranče, Hrušky, Kiwi document.write(s); //příklad s čísly var myArr = ; myArr.sort(); document.write(myArr); //1,10,2 Vyzkoušet »

Pravděpodobně jste čekali, že od řazení čísel uvidíte trochu jiný výsledek. K tomuto řazení dochází, protože metoda sort() třídí prvky tak, že je převádí na řetězce. Pořadí, které dostanou, je tedy řetězec – koneckonců „10“

Chcete-li třídit v jiném než abecedním pořadí, můžete předat porovnávací funkci jako argument metodě sort(). Je však třeba poznamenat, že porovnávací funkci si budeme muset napsat sami. Tato funkce musí mít dva parametry, protože určuje, který z jejích dvou argumentů se má objevit jako první v seřazeném seznamu. Aby bylo snazší pochopit a napsat takovou funkci, existuje několik pravidel, podle kterých bude pořadí prvků určeno:

• Pokud musí první argument předcházet druhému, porovnávací funkce vrátí záporné číslo (pokud a
• Pokud musí první argument následovat za druhým, pak porovnávací funkce vrátí kladné číslo (pokud a > b)
• Pokud jsou dvě hodnoty ekvivalentní (tj. jejich pořadí není důležité), porovnávací funkce vrátí 0 (pokud a == b)

Pro srovnání funkce používá prvky pole jako své argumenty:

Funkce foo(a,b) ( //definuje testovací funkci if (a b) return 1; return 0; //if a == b ) var a = ; a.sort(foo); //jako argument je předán pouze název funkce document.write(a.join(", ")); //zkratka stejná var a = ; a.sort(funkce(a,b) ( //použití anonymní funkce návrat a - b; //funkce vrátí 0 )); dokument.zapis(a); //1,2,5,10 Vyzkoušet »

První položka v příkladu je napsána tímto způsobem, aby bylo snazší pochopit, jak to funguje. Všimněte si, jak pohodlné je použití anonymní funkce v druhém úryvku. Volá se pouze jednou, takže není třeba ji pojmenovávat.

Poznámka: Pokud jsou v poli nedefinované prvky, přesunou se na konec pole.

plátkovou metodou

Metoda Array.slice() se používá ke zkopírování zadaného řezu z pole a vrátí nové pole obsahující zkopírované prvky. Původní pole se nemění.

Syntaxe metody:

název_pole.slice(začátek, konec);

Název_pole by měl být nahrazen názvem pole, ze kterého chcete extrahovat konkrétní sadu prvků pro nové pole. Metoda přebírá dva argumenty, které definují začátek a konec vrácené části pole. Metoda zkopíruje část pole začínající od začátku do konce, bez konce. Pokud je zadán pouze jeden argument, vrácené pole bude obsahovat všechny prvky od zadané pozice do konce pole. Můžete použít záporné indexy - počítají se od konce pole.

Var arr = ; arr slice(0,3); //Vrátí arr.slice(3); //Vrátí arr.slice(1,-1); //Vrátí arr.slice(-3,-2); //Vrátí se

metoda spojování

Metoda Array.splice() je obecná metoda pro práci s poli. Upravuje pole na místě, místo aby vracelo nové upravené pole, jak to dělají metody slice() a concat(). Metoda splice může odstranit prvky z pole, vložit nové prvky, nahradit prvky - jeden po druhém a současně. Vrátí pole sestávající z odstraněných prvků, pokud nebyl odstraněn žádný z prvků, vrátí prázdné pole.

Syntaxe metody:

název_pole.splice(index , počet, prvek1, ..., prvekN);

První argument určuje index v poli, od kterého se má začít vkládat nebo mazat prvky. Druhý argument určuje počet prvků, které mají být odstraněny z pole počínaje indexem uvedeným v prvním argumentu, pokud je druhý argument 0, nebudou odstraněny žádné prvky. Pokud je druhý argument vynechán, všechny prvky pole se odstraní ze zadaného indexu až do konce pole. Při použití záporného čísla pozice budou prvky počítány od konce pole.

Var ovoce = ["pomeranče", "jablka", "hrušky", "hrozny"]; var smazáno = ovoce.splice(2,2); //vrací ["hrušky", "hrozny"] document.write(deleted); var arr = ; arr.splice(4); // Vrátí ; pole se stalo: arr.splice(1,2); // Vrátí ; pole se stalo: arr.splice(1,1); // Vrátí ; pole se stalo: Zkuste »

První dva argumenty metody splice() určují prvky pole, které mají být odstraněny. Po těchto dvou argumentech může následovat libovolný počet dalších argumentů určujících prvky, které mají být vloženy do pole, počínaje pozicí zadanou prvním argumentem.

Var ovoce = ["pomeranče", "jablka"]; ovoce.splice(2,0, "vodní melouny"); //vrátí document.write(ovoce); //staly se ["pomeranče", "jablka", "vodní melouny"] var arr = ; arr.splice(2,0,"a","b"); // Vrátí ; stalo se arr.splice(2,2,); //Vrátí ["a","b"]; stalo se ,3,4,5] Zkuste »

Stojí za zmínku, že na rozdíl od concat() metoda splice() nerozděluje pole předaná jako argumenty na samostatné prvky. To znamená, že pokud je do metody k vložení předáno pole, vloží pole samotné, nikoli prvky tohoto pole.

metoda toString

Metoda toString() převádí prvky pole na řetězec pomocí čárky jako oddělovacího znaku.

Var arr = ["Mléko","Chléb","Sušenky"]; var jídlo = arr.toString(); dokument.psát(jídlo); //Milk,Bread,Cookie Try »

Všimněte si, že metoda vrací stejný řetězec jako metoda join(), když je volána bez argumentů.

indexOf a lastIndexOf

Metoda indexOf vrací index prvku, jehož hodnota je rovna hodnotě předané metodě jako argument.

Syntaxe metod indexOf() a lastIndexOf():

název_pole.indexOf(prvek_hledání, index) název_pole.lastIndexOf(prvek_hledání, index)

První argument metody udává hodnotu prvku, jehož index má být nalezen, druhý argument (nepovinný) udává index, od kterého bude hledání zahájeno. Pokud existuje více stejných výskytů, vybere se nejmenší (první) index. Pokud prvek s požadovanou hodnotou není nalezen, metoda vrátí -1. Uvnitř metody se pro vyhledávání používá striktní srovnání (===).

Var a = ; a.indexOf(3); //vrátí 2 a.indexOf(3,4); //vrací 6 a.indexOf(35); //vrací -1: žádný prvek s touto hodnotou a.indexOf(2); // jeden

Metoda lastIndexOf() také vrací index prvku, jehož hodnota se rovná hodnotě předané metodě jako argument. Jediný rozdíl je v tom, že metoda lastIndexOf() vybírá nejvyšší (poslední) index.

Var a = ; a.lastIndexOf(3); //vrátí 7 a.lastIndexOf(35); //vrací -1: žádný prvek s touto hodnotou a.lastIndexOf(2); // 6

Metody iterátoru

Níže popsané metody jsou iterátory. Všechny moderní prohlížeče pro práci s poli mají metody, které jsou navrženy tak, aby iterovaly prvky a prováděly na nich různé akce. Jsou to metody forEach(), map(), filter(), every(), some, reduction() a reductionRight().

Iterují prvky pole od 0 do délky - 1, a pokud prvek existuje, předají jej funkci obsluhy zpětného volání.

pro každého

Syntaxe metody:

název_pole.forEach(zpětné volání, thisArg)

Prvním argumentem je funkce zpětného volání, kterou bude metoda forEach() volat pro každý prvek pole. Implementaci funkce volaného handleru musíte napsat sami. Volaná funkce musí mít tři parametry: první parametr bere jako argument - hodnotu prvku pole, druhý - index prvku a třetí - samotné pole. Pokud však chcete použít pouze hodnoty prvků pole, můžete napsat funkci pouze s jedním parametrem. Druhý argument - thisArg (nepovinný) bude předán jako hodnota this.

Var arr = ; funkce foo(hodnota) ( ​​var suma = hodnota * toto; return document.write(sum + "
"); ) arr.forEach(foo, 5); //druhý argument bude předán jako hodnota this //příklad se třemi parametry var a = ; a.forEach(function(el, idx, a) ( document.write( "a["+idx+"] = "+el+" v ["+a+"]
"); )); Snaž se "

filtr

Syntaxe metody:

název_pole.filter(zpětné volání, tentoObjekt)

Metoda filter() vytvoří a vrátí nové pole, které bude obsahovat pouze ty prvky pole, pro které funkce zpětného volání vrátí hodnotu true.

Function isBig(element, index, array) ( //vrací čísla, která jsou větší nebo rovna 10 return (prvek >= 10); //pokud je hodnota prvku větší nebo rovna 10, výraz vrátí true ) var filter = .filter(isBig) ; //filtrovaný

mapa

Metoda map() vytvoří a vrátí nové pole, které se bude skládat z výsledků volání funkce callback(item, idx, ar) pro každý prvek pole.

Var a = ; var b = a.map(funkce(položka, idx, arr) ( vrátit položku * položku; )); // b =

každý a někteří

Metoda every() vrátí hodnotu true, pokud pro všechny prvky pole zadaná funkce použitá k jejich kontrole vrátí hodnotu true.

Metoda some() vrátí hodnotu true, pokud během testu v zadané funkci jeden nebo více prvků vrátí hodnotu true.

Var a = ; a.every(function(x) ( return x 10; )) //true: jedno číslo > 10

snížit a snížitVpravo

Syntaxe metody:

název_pole.reduce(zpětné volání, počátečníHodnota) název_pole.redukovatRight(zpětné volání, počátečníHodnota)

Metoda reduction() aplikuje zadanou funkci (zpětné volání) na dvě hodnoty v poli najednou, prochází prvky zleva doprava, přičemž zachovává mezivýsledek.

Argumenty funkce zpětného volání: (previousValue, currentItem, index, pole)

• previousValue – návratový výsledek funkce zpětného volání (aka mezivýsledek)
• currentItem - aktuální prvek pole (prvky jsou seřazeny postupně zleva doprava)
• index - index aktuálního prvku
• pole – pole, které se má zpracovat

initialValue (inicializační hodnota) - objekt použitý jako první argument prvního volání funkce zpětného volání. Jednoduše řečeno, hodnota previousValue při prvním volání je rovna initialValue. Pokud neexistuje žádná initialValue, pak se rovná prvnímu prvku pole a iterace začíná od druhého:

Var a = ; function foo(prevNum,curNum) ( sum = prevNum + curNum; alert(sum); return sum; ) var result = a.reduce(foo, 0); dokument.zapis(vysledek); Snaž se "

Podívejme se, jak tento příklad funguje. První argumenty funkce foo jsou:

• prevNum = 0 (protože initialValue je 0)
• curNum = 1 (aktuální prvek je 1. prvek pole)

1 se přičte k číslu 0. Tento výsledek (součet: 1) bude předán jako prevNum při příštím spuštění funkce. A tak dále, dokud není dosaženo posledního prvku. Vrácený výsledek je součet z posledního běhu, což je 15 (1+2+3+4+5).

Metoda reductionRight funguje podobně jako metoda snížení, ale iteruje pole zprava doleva:

Var a = ["h","o","m","e"]; function bar(prevStr, curItem) ( return prevStr + curItem; ) document.write(a.reduceRight(bar)); //emoh

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, vlož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 pole a vrátí jej.

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

var fruits = ["Apple", "Orange", "Donkey"] alert("Mažu "+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í položka:"+ovoce)

1. Vytvořte styly pole s prvky “ Jazz”, “Blues”;
2. Přidaná hodnota " 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. Extrahujte 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())

způsoby řazení/neřazení

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

var fruits = ["Apple", "Orange"] var apple = fruits.shift() // nyní máme pouze ["Orange"] fruits.unshift("Lemon") // nyní máme ["Lemon", " Orange"] alert (ovoce. délka) // 2

Řazení i neřazení mohou fungovat na více prvcích současně:

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

Úkol k seberealizaci

Napište kód pro upozornění na náhodnou hodnotu z pole arr:

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 mezi 0 a 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 přes pole provádí pomocí cyklu for:

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

Úkol k seberealizaci

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

Například:

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

Řešení

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

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

Ale to není pravda, 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 pomocí podmínky pro kontrolu, zda metoda indexOf existuje.

Úkol k seberealizaci

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 join.

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

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

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

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

Úkol k seberealizaci

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") // nezměněno (třída již existuje) addClass(obj, "me") // obj.className= " otevřít nabídku new me" alert(obj.className) //

Řešení

Potřebujeme oddělit className a smyčku na části. Pokud třída není nalezena, je přidána.

Smyčka je mírně optimalizována pro výkon:

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á smyčka je zpracovávána v opačném směru a končí podmínkou i>=0 . Protože kontrola i>=0 je rychlejší než i . Což v JavaScriptu urychluje vyhledávání polí.

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

Pomocí vlastnosti length můžete oříznout pole takto:

Nastavíte délku a prohlížeč pole ořízne.

Pole je objekt, což 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 jsou pole souvislým segmentem paměti. To se také liší od propojeného seznamu založeného na frontě nebo zásobníku.

Nenumerické klávesy pole

Klíče jsou čísla, ale mohou mít libovolné názvy:

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

V JavaScriptu jsou pole hashovacími tabulkami s jejich výkonnostními výhodami, ale také některými nevýhodami.

Například push/pop fungují 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á v JavaScriptu seřadit pole.

Úkol k seberealizaci

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 objektu, jako je obj metoda:

arr() // stejné jako arr() // syntakticky špatné, 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é, pokud jde o řídká pole 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í hodnoty chybějících indexů jako prázdné prvky:

var ovoce = // prázdné pole ovoce = "broskev" ovoce = upozornění na "jablko" (ovoce) // ,broskev,jablko (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í bizarně, když jsou na ně aplikovány metody pole. Netuší, že chybí indexy:

var fruits = fruits = "Peach" fruits = "Apple" alert(fruits.pop()) // pop "Apple" (na indexu 9) alert(fruits.pop()) // pop an nespecifikovaný prvek (na indexu 8 )

Snažte se vyhnout řídkým polím. Každopádně jejich metody nebudou normálně fungovat. Místo toho použijte Object .

Odebrání z pole

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

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

Můžete vidět, že hodnota je odstraněna, ale ne tak, jak bychom chtěli, protože pole obsahuje nenastavený 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])

Odstraní 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 položka odstraněna)

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

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

Úkol k seberealizaci

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

var obj = ( className: "otevřít nabídku" )

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

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

Řešení

Musíte rozdělit className na části a iterovat tyto části pomocí smyčky. Pokud je nalezena shoda, je odstraněna z pole objektů JavaScript 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) // nabídka

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 se provádí v opačném směru a končí podmínkou i>=0 . Je to 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"

Všimněte si, ž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řijímá všechny prvky začínající na 1 alert(arr2.join(", ")) // "learn, JavaScript"

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

obrácená metoda

Další užitečnou metodou je reverzní . Řekněme, že chci získat poslední část domény, např. 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é extrahování 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í.

Zásobník umožňuje odkazovat na data historie změn hodnot proměnných. Základem programování je popis dat a algoritmů. Zásobník je základem pro přenos řízení mezi funkcemi, organizování rekurze a odkazů na parametry. Syntaxe a sémantika JavaScriptu prostřednictvím metod pole push() a pop() umožňují manipulaci s významem a zohlednění časového faktoru. Zvláštnost jazyka prohlížeče a jeho logika nám umožňují pohlédnout jinak na možnosti faktoru času.

Datové pole a logika jeho vzniku

Stačí deklarovat proměnnou. Je snadné vytvořit pole proměnných. Algoritmus, který používá data, je statické a jednoduché řešení problému. Klasická manipulace s daty:

• popsat (vytvořit) proměnnou;
• přiřadit hodnotu;
• změnit hodnotu;
• odstranit proměnnou.

Funkce push() a pop() umožňují změnit povahu proměnných a jejich použití. Myšlenka zásobníku se od svého narození nezměnila, ale zvláštnost JS jako jazyka prohlížeče a moderní koncepce programování vám umožňuje vzít v úvahu časový faktor a dát dynamiku dat.

Function value") - přidat něco na konec pole. Function - extrahovat poslední prvek pole. Při přidávání se ukazatel v kontextu push / pop přesune na přidaný prvek, při extrahování - na předposlední prvek a poslední prvek je výsledkem operace.

Stoh talířů – tradiční popis stohu v JavaScriptu – nabývá nového významu. Nechť je proměnná vždy pole. Pole je ve skutečnosti sbírka proměnných, ale pokud vezmeme v úvahu proměnnou jako pole, můžete se podívat na dynamiku změn jejích hodnot odlišně.

Pohybujte se po hodnotách

Podstata stacku - přišel poslední, odešel první. Nelze načíst hodnotu mimo daný příkaz. Přísným dodržováním tohoto pravidla, s ohledem na hodnoty celého pole jako na jednu proměnnou, můžete získat dynamiku změn hodnot této proměnné v průběhu času.

V tomto příkladu je přidání hodnot JS array.push(...) jednou posloupností akcí, načítání hodnot pole JS pop() je další posloupností. Obě možnosti spolu souvisí. To znamená, že aktivní prvek mění svou hodnotu nejen v čase, ale i v logice své změny.

Rekurze a dynamika hodnot

Pokud se funkce může volat sama a bezpečně plnit svůj účel, je to plná funkčnost. Jednoduchým příkladem je tabulka. V tabulce mohou být další tabulky. A každá tabulka obsahuje řádky, sloupce a buňky. Každá buňka může obsahovat tabulku. Více buněk podle řádku nebo sloupce lze sloučit do jedné buňky, která může obsahovat tabulku. Tabulka v buňce může mít buňku se dvěma nebo více tabulkami.

V klasickém programovacím stylu je prakticky nemožné implementovat to, co bylo řečeno, ale v rekurzivním je to elementární. Pokud vám funkčnost algoritmu pro práci s tabulkou umožňuje implementovat se uvnitř jakékoli buňky, pak se jedná o push pole JS. V JavaScriptu má tento „trik“ zvláštní význam. Tabulky jsou vlastní aplikace. Strom stránky (DOM) je dílo na stránce.

Manipulátory visí na prvcích DOM (značkách stránky). Jedna možnost je, když takový psovod vystřelí jednou, úplně jiná možnost je, když se může volat mnohokrát. V kontextu všech handlerů všech prvků stránky se získá dynamika stránky v čase.

Push/pop a rekurze jsou trochu jinou představou o logice stránky: vše se mění tak, jak je to v aktuální situaci požadováno, a není to předem naprogramováno ve formě sekvenčního zpracování akcí návštěvníků.