Jednoduchý příklad vytvoření pole v javascriptu. Všechny způsoby iterace polem v JavaScriptu. Jaký je účel operátora mazání?

JavaScript, stejně jako jiné programovací jazyky, používá pro práci s poli různé metody.

Metody zjednodušují konstrukci logiky a její implementaci ve skriptu.

Níže jsou uvedeny základní metody pro práci s poli v JS.

TAM

Metoda push() přidá hodnotu na konec pole.

Nechť arr = ; arr.push(312); console.log(arr); // →

pop

Metoda pop() odstraní poslední prvek z pole nebo vrátí jeho hodnotu.

Nechť arr = ; arr.pop(); console.log(arr); // →

Pomocí schopnosti získat hodnotu posledního prvku pole jako příklad můžeme získat formát obrázku:

Nechat img = "https://example.com/img/nazev.png"; let format = img.split(".").pop(); console.log(format); // → png console.log(img.split(".")); // → ["https://example", "com/img/name", "png"]

neřadit

Metoda unshift() přidá prvek na začátek pole.

Nechť arr = ; arr.unshift(312); console.log(arr); // →

posun

Metoda shift() odstraní první prvek z pole.

Nechť arr = ; arr.shift(); console.log(arr); // → ;

Musíte pochopit, že při použití metod shift a unshift mění každý prvek pole svůj index. To může zpomalit provádění programu, pokud je pole velké.

rozdělit

Metoda split() se používá k transformaci řetězce na pole. Rozdělit rozdělí řetězec podle zadaného parametru.

Nechť str = "Anya, Máša, Saša, Dáša"; // toto je řetězec let arr = str.split(", "); console.log(arr); // → ["Anya", "Masha", "Sasha", "Dasha"] je pole

připojit se

Metoda join() kombinuje prvky pole do řetězce pomocí oddělovače zadaného v parametru.

Nechť arr = ["Notpad++", "Sulime", "VSCode"]; // toto je pole let str = arr.join(", "); console.log("Editory kódu: " + str); // → "Editory kódu: Notpad++, Sublime, VSCode"

plátek

Metoda slice() vytvoří nové pole, do kterého zkopíruje prvky ze zdroje, počínaje prvkem s indexem prvního parametru předaným metodě až po prvek s indexem druhého parametru.

Například: slice(3, 7) vrátí prvky s indexy 3, 4, 5, 6. Prvek s indexem 7 nebude zahrnut do pole.

Pokud je parametr se zápornou hodnotou předán slice(), vrátí nové pole s počtem prvků zadaným v parametru, ale již převzatých z konce původního pole.

Metoda slice nemění původní pole.

Zde je několik příkladů metody slice() v akci:

Nechť arr = ["A", "B", "C", "D", "E", "F", "G"]; // Vrátí pole obsahující prvky s indexy od 2 do 5 console.log(arr.slice(2, 5)); // → ["C", "D", "E"] // Vrátí nové pole obsahující prvky s indexy od 3 do arr.length console.log(arr.slice(3)); // → ["D", "E", "F", "G"] // Vrátí kopii původního pole console.log(arr.slice()); // → ["A", "B", "C", "D", "E", "F", "G"] // Vrátí nové pole skládající se z posledních tří prvků původního console.log (arr.slice (-3)); // → ["E", "F", "G"]

spoj

Metoda splice() upravuje obsah pole odstraněním existujících prvků a/nebo přidáním nových.

Syntax:

Array.splice(start, deleteCount[, item1[, item2[, ...]]])

Parametry:

• start- Index, od kterého se má začít měnit pole. Pokud je větší než délka pole, skutečný index bude nastaven na délku pole. Pokud je záporné, určuje index prvku od konce.
• deleteCount- Celé číslo udávající počet starých prvků, které mají být z pole odstraněny. Pokud je deleteCount 0, nebudou odstraněny žádné prvky. V tomto případě musíte zadat alespoň jeden nový prvek. Pokud je deleteCount větší než počet prvků zbývajících v poli počínaje začátkem indexu, budou odstraněny všechny prvky až do konce pole.
• položkaN- Volitelné parametry. Prvky, které mají být přidány do pole. Pokud nezadáte žádný prvek, splice() jednoduše odstraní prvky z pole.

Návratová hodnota

Popis

Pokud se počet prvků určený k vložení liší od počtu prvků, které mají být odstraněny, pole po volání změní délku.

Nechť arr = ["Barca", "Šachtar", "Manchester United", "Milán", "Real", "Ajax", "Juventus"]; nech nax = arr.splice(2, 3); arr.splice(2, 3); console.log(nax); // → ["Manchester United", "Milan", "Real"] console.log(arr); // → ["Barca", "Šachtar"] arr.splice(1, 0, "Zenit", "CSKA", "Spartak"); console.log(arr); // → [Barça, Zenit, CSKA, Spartak, Šachtar]

zvrátit

Metoda reverse() obrátí pořadí prvků pole. V důsledku toho se první prvek pole stane posledním a poslední prvek prvním.

Nechť arr = ; console.log(arr.reverse()); // → console.log(["Alice", "BG", "GO", "DDT"].reverce()); // → ["DDT", "GO", "BG", "Alice"]

mapa

Metoda map() prochází prvky pole, provádí s nimi zadané akce a vrací kopii pole se změněnými prvky.

V níže uvedeném příkladu ke každému prvku pole přidáme hodnotu indexu tohoto prvku (7 + 0, 2 + 1, 15 + 2, 4 + 3, 31 + 4):

Nechť arr = ; let testMap = arr.map((prvek, index) => prvek + index); console.log(testMap); //

nebo vynásobte každou hodnotu pole, například 12

Nechť arr = ; let testMap = arr.map(a => a * 12); console.log(testMap); // →

filtr

Metoda filter() se používá k filtrování polí. Iteruje polem a vrací pouze ty prvky, které splňují danou podmínku.

Vyfiltrujme například hodnoty pole čísel a ponecháme pouze ty, které jsou větší než 21

Nechť arr = ; let testFilter = arr.filter(prvek => prvek > 21); console.log(testFilter); // →

Vezměte prosím na vědomí, že 21 nebylo zahrnuto ve výsledku pole, protože podmínkou bylo vrátit něco, co je větší než 21. Aby bylo 21 zahrnuto do pole, nastavili jsme podmínku jako větší nebo rovnou: element >= 21

snížit

Metoda reduction() postupně prochází prvky pole a shromažďuje mezivýsledek podle funkce zadané v podmínce funkce. V konečném výsledku vrátí pouze jednu hodnotu.

Tato metoda se často používá k nalezení součtu všech čísel v poli. Příklad:

Nechť arr = ; nech summa = arr.reduce((acc, element) => acc + element); console.log(součet); // → 370

třídit

Metoda sort() se používá k řazení prvků pole podle zadaných parametrů.

Příklad – vezmeme pole čísel a seřadíme je vzestupně:

Nechť arr = ; let testSortArr = arr.sort((a, b) => a - b); console.log(testSortArr); // →

zahrnuje

Metoda include() určuje, zda pole obsahuje konkrétní prvek, v závislosti na tom vrací true nebo false.

Příklad použití include() .

Zde je logický výraz:

Nechť zvíře = "pes"; if (zvíře == "kočka" || zvíře == "pes" || zvíře == "lev" || zvíře == "kůň") ( // ........ )

Pomocí metody include to můžete napsat takto:

Nechť zvíře = "pes"; const animals = ["kočka", "pes", "lev", "kůň"]; if (animals.includes(animal)) ( // ........... )

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

Metody pop/push a shift/unshift

Podívejme se na metody pop() a push(). Tyto metody umožňují pracovat s poli, jako by to byly 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 fungování stohu lze přirovnat ke stohu talířů: chcete-li vzít druhý shora, musíte odstranit horní. Jak to funguje je znázorněno na obrázku:

A tak se vraťme 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. Stojí za zmínku, že obě tyto metody upravují pole na místě, spíše než 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("Vybral jsi mě" + vybral);

Zkuste »

Metody shift() a unshift() se chovají v podstatě stejně jako pop() a push(), až na to, že vkládají a odebírají prvky na začátek pole. Metoda unshift() posouvá existující prvky na větší indexy, aby se vytvořil prostor pro nové prvky, přidává jeden nebo více prvků na začátek pole a vrací 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 volné 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ě lze předat volitelný argument řetězce, který bude použit k oddělení prvků v řetězci. Pokud není oddělovač zadán, výchozím oddělovacím znakem při volání metody bude čárka.
Var a = ["Vítr","Déšť","Požár"]; var myVar1 = a.join(); //"Vítr,Déšť,Požár" 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 fragmenty.

obrácená metoda

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

Zkuste »

metoda concat

Metoda Array.concat() vytvoří a vrátí nové pole obsahující prvky původního pole, na kterém bylo zavoláno concat(), postupně rozšířené o hodnoty všech argumentů předávaných concat(). Pokud je některý z těchto argumentů sám 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 kombinovány.

Var a = ; a.concat(4, 5) //Vrátí a.concat(); //totéž - 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() zavolána bez argumentu, seřadí prvky pole v abecedním pořadí (dočasně je převede na řetězce, aby se provedlo porovnání). Metoda sort() může mít porovnávací funkci jako argument, který určuje pořadí řazení prvků.

Var a = ["Kiwi", "Pomeranče", "Hrušky"]; a.sort(); var s = 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. Proto se jejich pořadí ukáže jako ř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 počítat s tím, že porovnávací funkci si budete muset napsat sami. Tato funkce musí mít dva parametry, protože nastavuje, který z jejích dvou argumentů se má v seřazeném seznamu objevit jako první. 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)

Funkce foo(a,b) ( //definuje kontrolní 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(", ")); //napiš totéž stručněji var a = ; a.sort(funkce(a,b) ( //použití anonymní funkce návrat a - b; //funkce vrátí hodnotu 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 ve druhém fragmentu. 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é sekce 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 používá dva argumenty, které určují začátek a konec vráceného 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

spojová metoda

Metoda Array.splice() je univerzální metoda pro práci s poli. Upravuje pole na místě, místo aby vracelo nové upravené pole, jako 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ý prvek, vrátí prázdné pole.

Syntaxe metody:

Název_pole.splice(index, množství, prvek1, ..., prvekN);

První argument určuje index v poli, od kterého se má začít vkládat nebo odebírat prvky. Druhý argument určuje počet prvků, které by měly být odstraněny z pole počínaje indexem zadaným v prvním argumentu, pokud je druhý argument 0, nebudou odstraněny žádné prvky. Pokud je druhý argument vynechán, budou odstraněny všechny prvky pole od zadaného indexu až po konec 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í určenou prvním argumentem.

Var ovoce = ["pomeranče", "jablka"]; ovoce.splice(2,0, "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 jednotlivé prvky. To znamená, že pokud je metodě předáno pole k vložení, 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,Cookies Try »

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

indexOf a lastIndexOf

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

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 je třeba najít, druhý argument (nepovinný) udává index, od kterého začne hledání. Pokud existuje několik 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); //návrat 2 a.indexOf(3,4); //návrat 6 a.indexOf(35); //návrat -1: neexistuje žádný prvek s touto hodnotou a.indexOf(2); // 1

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á největší (poslední) index.

Var a = ; a.lastIndexOf(3); //návrat 7 a.lastIndexOf(35); //návrat -1: neexistuje žádný prvek s touto hodnotou a.lastIndexOf(2); // 6

Iterační metody

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

Iterují prvky pole počínaje 0 až po délku - 1, a pokud prvek existuje, předají jej funkci obsluhy zpětného volání.

pro každého

Syntaxe metody:

Název Array.forEach(zpětné volání, thisArg)

První argument určuje funkci 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 potřebujete použít pouze hodnoty prvků pole, můžete napsat funkci pouze s jedním parametrem. Druhý argument - thisArg (volitelný) 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 tohoto //příkladu se třemi parametry var a = ; a.forEach(function(el, idx, a) ( dokument .write( "a["+idx+"] = "+el+" v ["+a+"]
"); )); Zkuste »

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.

Funkce isBig(prvek, index, pole) ( //vrátí čísla, která jsou větší nebo rovna 10 vrátí (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 =

všechny a některé

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 jeden nebo více prvků během testování v zadané funkci 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ého volání na dvě hodnoty v poli najednou, přičemž prochází prvky zleva doprava, přičemž ukládá mezivýsledek.

argumenty funkce zpětného volání: (předchozíHodnota, aktuálníPoložka, index, pole)

• previousValue – vrácený výsledek funkce zpětného volání (známý také jako mezivýsledek)
• currentItem - aktuální prvek pole (prvky jsou seřazeny v pořadí zleva doprava)
• index - index aktuálního prvku
• pole - zpracované pole

initialValue je 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 hledání 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);

Zkuste »

• 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 nedosáhne posledního prvku. Vrácený výsledek, součet z posledního běhu, bude 15 (1+2+3+4+5).

Metoda reductionRight funguje podobně jako metoda snížení, ale prochází polem zprava doleva:

Pole jsou jedním z nejčastěji používaných typů proměnných, které vám umožňují uložit mnoho sekvenčních hodnot na „jedno místo“. Pokud však jde o JavaScript, je zde prostor pro zlepšení.

V tomto článku se podíváme na tři málo známé techniky, které lze použít při práci s poli.

1. Přidání uživatelských vlastností do polí

Pokud k nalezení definice pole v jazyce JavaScript použijete vyhledávání, většina zdrojů uvede, že tento typ hodnoty proměnné je reprezentován jako objekt.

Obecně řečeno, mnoho věcí, se kterými se v JavaScriptu setkáváme, jsou objekty. Bylo by spravedlivé poznamenat, že jazyk také obsahuje „primitivní“ datové typy, ale jejich hodnoty se nějak používají ve vlastnostech uvnitř objektů.

2. Přístup k prvkům pole v rámci smyčky

Protože indexy pole mohou nabývat pouze kladných hodnot, počítání začíná od nuly. Tento index můžeme později použít k přístupu k prvku pole v dané iteraci smyčky.

ECMAScript6 zavedl způsob, jak procházet polem bez použití indexů, ale pomocí nové smyčky for...of.

Smyčka for...of je navržena tak, aby procházela prvky pole bez ovlivnění indexu prvku.

Var ary = ["pomeranč","jablko","liči"]; for (let item of ary)( console.log(item); ) // "oranžová", "jablko", "liči" Pro srovnání: výstup indexů položek ve smyčce for. var ary = ["pomeranč","jablko","liči"]; for (var item = 0; item< ary.length; item++){ console.log(item); } // 0, 1, 2

3. Počet prvků není rozměr pole

Když mluvíme o velikosti pole, obvykle si to představujeme jako počet prvků v něm uložených. Ve skutečnosti to není tak úplně pravda – vlastnost length se počítá v závislosti na maximálním indexu prvku.

Vlastnost délky je velmi nejednoznačná. Chcete-li to ověřit, podívejte se na následující manipulace:

Var ary = ; ary.length = 3; console.log(ary.length); // 3 ary = "abcd"; console.log(ary.length); // 6

V posledním příkladu stačilo umístit prvek na pátou pozici, čímž se délka pole stala 6. Pokud si myslíte, že indexy od 0 do 4 se budou vytvářet automaticky, jste na omylu. To lze zkontrolovat pomocí operátoru in.

Var ary = ; ary.length = 3; console.log(ary.length); // 3 ary = "abcd"; console.log(ary.length); // 6 console.log(0 in ary); // nepravda

V tomto případě by bylo spravedlivé nazvat pole ary "řídké".

Můžeme také manipulovat s vlastností length, abychom ořízli pole. Níže uvedený příklad ukazuje „ztrátu“ prvku na indexu 5 snížením vlastnosti length pole ary.

Var ary = ; ary.length = 3; console.log(ary.length); // 3 ary = "abcd"; console.log(ary.length); // 6 ary.length = 2; console.log(ary.length); // 2 console.log(ary); // nedefinováno

V tomto článku se podíváme na pole JavaScript a jeho součásti. JavaScript je ideální pro programování. Ve skutečnosti implementuje jazyk ECMAScript (standard ECMA-262).

Kde se používá JavaScript? Používá se jako vestavěný jazyk k definování cesty programu k předmětu aplikace. Lze jej nalézt v prohlížečích, kde se používá jako skriptovací jazyk, díky kterému jsou webové stránky interaktivní.

Nejdůležitějšími architektonickými vlastnostmi tohoto produktu jsou dynamické a slabé psaní, automatická správa paměti, dokonalé programování a prvotřídní objektové funkce.

JavaScript byl obecně ovlivněn různými důvody, protože během vývoje chtěli vytvořit jazyk podobný Javě, ale programátorům snadno použitelný. Mimochodem, jazyk JavaScript nevlastní žádná společnost ani organizace, čímž se liší od řady programovacích stylů používaných webovými vývojáři.

Je třeba poznamenat, že JavaScript je registrovaná ochranná známka společnosti Oracle Corporation.

Co je pole?

Pole je takové, které ukládá očíslované hodnoty. Každá taková hodnota se nazývá komponenta pole a číslice, ke které je komponenta přidružena, se nazývá index. Pole JavaScriptu je nezadané. To znamená, že části pole mohou být libovolného typu a různé části patřící do stejného pole mají zcela odlišné typy.

Pole JavaScriptu je navíc dynamické, což znamená, že není potřeba deklarovat pevnou velikost. Koneckonců, můžete kdykoli přidat nové podrobnosti.

Výroba pole

Pomocí JavaScriptu není vytvoření pole vůbec obtížné. Jsou na to dvě metody. První zahrnuje vytvoření pole pomocí literálu - hranaté závorky, uvnitř kterých je seznam částí oddělených čárkami.

• var prázdný = ; //prázdné pole;
• var čísla = ; //pole s pěti digitálními součástkami;
• var diff = ; //pole se třemi prvky různých typů.

Hodnoty zde obvykle nemusí být jednoduché (řetězce a čísla). Mohou to být také jakékoli jiné výrazy, například předmětové literály, jiné funkce a pole.

Druhý způsob, jak vytvořit pole, je zavolat Array() designer. Pozvat ho můžete třemi způsoby:

• Volání návrháře bez argumentů: var b - new Array(). To zajišťuje vytvoření prázdného pole, ekvivalentního prázdnému literálu.
• Konstruktor explicitně specifikuje hodnotu n komponent pole: var b = new Array (1, 3, 5, 8, “string”, true). V tomto případě je návrháři předložen seznam argumentů, které jsou převedeny na součásti nového pole. Argumenty se zapisují do pole v místě, kde jsou specifikovány.
• Vymezení oblasti pro následné přiřazení hodnot. To se provádí zadáním při identifikaci pole jedno číslo uzavřené v závorkách: var b = new Array(5). Tato metoda identifikace spočívá v přidělení požadovaného počtu komponent do pole (každá z nich je uvedena jako nedefinovaná) s možností následného přiřazení hodnot během procesu prezentace. Tento formulář se obvykle používá k předběžnému přidělení pole Javascript, jehož délka je předem známa.

Zápis, čtení a přidávání detailů pole

Ke komponentám pole můžete přistupovat pomocí operátoru. Mimochodem, všechny komponenty v JavaScriptu, počínaje nulou, jsou očíslovány. Pro získání požadovaného prvku je jeho číslo uvedeno v Podrobnosti lze zpravidla změnit. A abyste mohli do pole přidat JavaScript, stačí přiřadit novou hodnotu.

Je třeba poznamenat, že pole JavaScriptu mohou ukládat libovolný počet prvků jakéhokoli druhu.

Délka pole

Víme tedy, že délka pole je obecně zajímavý fenomén. Pojďme se na to podívat blíže. Všechna pole, ať už vytvořená pomocí návrháře Array() nebo odhalená prostřednictvím literálu pole, mají specifickou vlastnost length, která udává celkový počet uložených prvků. Protože pole může obsahovat nedefinované části (označené jako undefined), přesnější vyjádření je: kvalita délky je vždy o jednu větší než největší číslo (index) komponenty pole. Kvalita délky se upravuje automaticky a zůstává přesná, když se v poli objeví nové díly.

Chcete-li, aby se objevila konečná složka pole, můžete použít vlastnost length.

Poslední část má index o jednu menší, než je velikost pole. Odpočítávání totiž vždy začíná od nuly. Ach, ten JavaScript! Délka pole závisí na přesném počtu prvků. Pokud tedy nevíte, kolik by jich mělo být, ale potřebujete získat přístup ke konečnému prvku pole, musíte použít zápis: v.length - 1.

Iterování přes podrobnosti pole

Velmi často se vlastnost length používá k iteraci přes detaily pole ve smyčce:

• var ovoce = [“jahoda”, “broskev”, “jablko”, “banán”];
• for(var I = 0; i< fruits.lenght; i++);
• document.write(ovoce[i] + "...").

V tomto příkladu se zdá, že komponenty jsou umístěny souvisle a začínají první částí s indexem nula. Pokud tomu tak není, musíte před voláním každého prvku pole zkontrolovat, zda je definován.

Smyčka se také někdy používá k inicializaci komponent.

Pěstujte a zkracujte pole

Zajímalo by mě, jak přidat řetězec do pole pomocí JavaScriptu? Jak pracujeme s poli, kvalita délky se automaticky zlepšuje, proto se o to musíme postarat sami. Je potřeba si zapamatovat jeden detail – vlastnost length je nejen čitelná, ale i zapisovatelná. Pokud je kvalitě délky přiřazena hodnota, která je menší než aktuální, pole se zmenší na zadanou velikost. Všechny komponenty, které nejsou v novém rozsahu indexů, jsou vyřazeny a jejich hodnoty jsou ztraceny, i když je později vrácena délka – hodnoty se neobnoví.

Je docela snadné vymazat pole takto: foo.length = 0.

Pokud je kvalita délky větší než její aktuální hodnota, na konci pole se objeví nové neidentifikované části, které jej zvětší na požadovanou velikost.

Odstranění částí vzoru

Operátor delete určuje nedefinovanou hodnotu v komponentě pole, ale ta nadále existuje. Pokud potřebujete odstranit prvek pole JavaScript, aby se zbývající části přesunuly do volného prostoru, musíte použít jednu z poskytnutých metod pole. Metoda Array.shift() eliminuje první komponentu, pop() eliminuje finální komponentu a metoda splice() eliminuje jednu nebo řadu komponent kdekoli v poli.

Vícerozměrná pole

Zdá se, že jsme na to trochu přišli. Dvourozměrná pole jsou tím, co musíme dále zvážit. Pamatujete si, že pole JavaScriptu mohou obsahovat další prvky jako komponenty? Tato funkce se používá k vytváření vícerozměrných polí. Chcete-li navštívit komponenty v řadě polí, jednoduše použijte hranaté závorky dvakrát.

Asociativní pole

Nyní se podívejme, jak ochranná známka JavaScript používá asociativní pole. K tomu se musíme podívat do teorie: asociativní pole se někdy nazývají hashovací tabulky. Díky nim se místo indexů používají řetězce. Použití takových konstrukcí připomíná použití názvu vlastnosti jednoduchého objektu, ale v této verzi při provádění práce ve formátu pole. Protože JavaScript postrádá způsoby, jak pracovat s asociativními poli, používají se mnohem méně často než běžná pole. Je třeba poznamenat, že mohou být stále užitečné pro ukládání dat a usnadňují zapamatování podrobností, ke kterým je třeba přistupovat.

Výstup pole

Co se nyní o JavaScriptu dozvíme? Zobrazení pole v dialogovém okně (na obrazovce monitoru) a také zobrazení hodnot komponent pole.

Pokud potřebujete zobrazit hodnoty všech komponent v programu, je vhodné použít příkaz for. Zajímavé je, že proměnná čítače pravidel for se používá jako index komponenty pole.

Čištění

Chcete-li filtrovat pole JavaScriptu, musíte resetovat jeho délku na nulu:

• var myArray = ;
• myArray.length = 0.

• clear: function() (;
• this.length = 0;
• vrátit toto;

Přidávání a odebírání komponent

Pokračujme ve studiu tohoto zajímavého jazyka JavaScript. Prvek pole lze odstranit nebo přidat stejným způsobem jako běžné vlastnosti jiných objektů. Existují však určité rozdíly: přidáním číselných vlastností lze změnit kvalitu délky a úpravou vlastnosti délky lze číselné kvality odstranit. V zásadě je algoritmus pro nastavení kvalit pro pole následující:

• Při přidávání neznámé digitální vlastnosti i, je-li délka rovna nebo menší než i, je délka definována jako i+1.
• Když se změní kvalita délky, provedou se následující akce: pokud je přiřazená hodnota menší než nula, je vyvolána chyba RangeError. Všechny číselné kvality a indexy, které se rovnají nové délce a které jsou větší, jsou odstraněny.

Obecně platí, že odstranění prvku pole JavaScript není obtížné. Koneckonců, i když nastavujete délku, musíte z ní odstranit „extra“ komponenty. To vede k možnosti vymazání pole. Pokud přiřazená proměnná prázdného nového pole z nějakého důvodu nevyhovuje a je nutné přenastavit tu aktuální, stačí její kvalitě délky přiřadit hodnotu nula.

metody unshift, shift, pop a push

Přestože se komponenty pole upravují ručně, mnoho lidí k tomu doporučuje používat vestavěné metody. Je to tato nuance, která zaručuje správnou hodnotu kvality délky a absenci mezer v poli. Mimochodem, správná kvalita délky bude odpovídat počtu komponentů.

Metoda push přesune předané části na konec pole. Metoda pop vrátí koncovou komponentu a odstraní ji.

Obecně platí, že v Internet Exploreru mladším než osmá verze může unshift v jiných prohlížečích vracet nedefinovanou hodnotu délky. Je tedy lepší nespoléhat se na hodnotu vrácenou z nesměny.

Přidávání a odstraňování částí uprostřed pole

Pokud potřebuji odstranit pole JavaScriptu, co mám dělat? Je známo, že metoda spojování má podpis Array.prototype.splice.

Odebere komponenty deleteCount z pole, počínaje indikátorem start. Pokud jsou předány více než dva argumenty, pak všechny následující argumenty v poli jsou umístěny místo eliminovaných. Je-li začátek záporný, pak index, od kterého bude výběr pokračovat, bude roven délce + začátku. Pole je vráceno z odstraněných prvků.

Ve skutečnosti můžete pomocí metody splice odebrat komponenty ze středu pole nebo přidat libovolný počet komponent kdekoli v poli.

V nejjednodušší verzi, pokud potřebujete odstranit komponentu s indexem i, musíte požádat o metodu spojení z pole s parametry i a 1.

V zásadě je druhý parametr metody splice volitelný, ale chování funkce s jedním argumentem je v každém prohlížeči jiné.

Například ve Firefoxu, v nejnovějších variantách Opery, v Safari a v Chrome budou odstraněny všechny detaily až do konce pole.

Žádná komponenta nebude v IE odstraněna. V prvních variantách Opery nelze předvídat chování - jedna část se startem indexu - 1 bude odstraněna, proto je vždy potřeba předat této metodě alespoň dvě komponenty.

Klíče

Samozřejmě, když se učíte JavaScript, měli byste mít na paměti také asociativní pole, jak již bylo zmíněno dříve. Jedná se o abstraktní typ informace (rozhraní k datovému úložišti), který umožňuje ukládat páry ve tvaru „(klíč, hodnota)“ a podporovat operace přidání páru, stejně jako mazání a vyhledávání páru. podle klíče:

NAJÍT (klávesa).

INSERT (hodnota, klíč).

ODSTRANIT (klávesa).

Předpokládá se, že dva páry s podobnými klíči nelze uložit do asociativního pole. V páru k + v se v nazývá hodnota spojená s klíčem k. Sémantika a názvy výše uvedených operací se mohou v různých implementacích takových polí lišit.

Akce FIND (key) tedy vrací hodnotu přidruženou k danému klíči nebo nějaký konkrétní objekt UNDEF indikující, že k danému klíči není přiřazena žádná hodnota. Další dvě akce nevrací nic (kromě toho, zda byla operace úspěšná).

Obecně je z hlediska rozhraní vhodné považovat asociativní pole za jednoduché pole, ve kterém lze jako indexy použít nejen celá čísla, ale také hodnoty jiných typů - například řetězce.

Mimochodem, podpora pro taková pole je dostupná v mnoha programovacích jazycích na vysoké úrovni, jako je PHP, Perl, Ruby, Python, Tcl, JavaScript a další. Pro jazyky, které nemají vestavěné nástroje pro práci s asociativními poli, bylo vytvořeno kolosální množství implementací ve formě knihoven.

Příkladem asociativního pole je telefonní seznam. V této verzi má význam komplex „F. I. O. + adresa“ a klíčem je telefonní číslo. Jedno telefonní číslo má jednoho vlastníka, ale jedna osoba může vlastnit několik čísel.

Asociativní rozšíření

Je třeba poznamenat, že mezi nejznámější rozšíření patří následující:

• KAŽDÝ - „projít“ všechny uložené páry.
• CLEAR - odstranění všech záznamů.
• MIN - najděte pár s nejmenší hodnotou klíče.
• MAX - najděte pár s největší hodnotou klíče.

Poslední dvě možnosti vyžadují, aby byla na klávesách uvedena akce porovnání.

Implementace asociativních polí

Existuje mnoho různých implementací asociativního pole. Nejběžnější implementace může být založena na jednoduchém poli, jehož komponenty jsou páry (hodnota, klíč). Chcete-li urychlit vyhledávací operace, můžete seřadit komponenty daného pole podle klíče a provést vyhledávání pomocí Ale tím se prodlouží doba potřebná k přidání nového páru, protože bude nutné „oddělit“ komponenty pole, aby se nový záznam zabalil do prázdné buňky, která se objeví.

Nejznámější implementace jsou ty, které jsou založeny na různých vyhledávacích stromech. Například v typické čtečce C++ STL je mapový kontejner implementován na základě černého mahagonového stromu. Styly Ruby, Tcl, Python používají jeden typ hashovací tabulky. Existují další implementace.

Obecně platí, že každá implementace má své nevýhody a výhody. Je důležité, aby všechny tři akce byly provedeny jak v průměru, tak v nejhorší nuanci za období O(log n), kde n je aktuální počet ukládaných párů. U odpovídajících vyhledávacích stromů (včetně černo-červených stromů) je tato podmínka splněna.

Je známo, že implementace založené na hashovacích tabulkách mají průměrnou dobu O(1), což je lepší než implementace založené na vyhledávacích stromech. To samozřejmě nezaručuje rychlé provádění jednotlivých operací: nejhorší případ INSERT čas je O(n). Proces INSERT běží dlouhou dobu, když faktor plnění dosáhne svého nejvyššího bodu a index hashovací tabulky je třeba rekonstruovat.

Mimochodem, tyto hash listy jsou špatné, protože na jejich základě nelze provádět rychlé dodatečné akce MAX, MIN a algoritmus pro procházení všech uložených párů v sestupném nebo vzestupném pořadí klíčů.

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 začínají na nule a používají 32bitová celá čísla – první prvek pole má index 0. Pole JavaScriptu jsou dynamická: mohou se zvětšovat a zmenšovat podle potřeby; není potřeba deklarovat pevné velikosti polí při jejich vytváření nebo znovu alokovat paměť, když se jejich velikost 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 použít literál, což je jednoduchý seznam prvků pole oddělený čárkami ohraničený hranatými závorkami. 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 vložit 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 volat třemi různými způsoby:

Zavolejte konstruktor 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ě zadejte hodnoty prvních dvou nebo více prvků pole nebo jednoho nečíselného prvku ve volání konstruktoru:

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().

Prvky pole pro čtení a zápis

K prvkům pole se přistupuje pomocí operátoru. Nalevo od závorek musí být odkaz na pole. Uvnitř závorek musí být libovolný výraz, který vrací nezápornou celočíselnou hodnotu. Tato syntaxe je užitečná pro čtení i zápis hodnoty prvku pole. Proto jsou platné všechny následující pokyny pro JavaScript:

// Vytvořte pole s jedním prvkem var arr = ["world"]; // Přečtení prvku 0 var value = arr; // Zapište hodnotu do prvku 1 arr = 3,14; // Zapište hodnotu do prvku 2 i = 2; arr[i] = 3; // Zapište hodnotu do prvku 3 arr = "hello"; // Přečteme prvky 0 a 2, zapíšeme hodnotu do prvku 3 arr] = arr;

Dovolte mi připomenout, že pole jsou specializovaný typ objektu. Hranaté závorky používané pro přístup k prvkům pole fungují přesně stejně 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éž můžete udělat s běžnými objekty:

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

Věc na polích je, že když použijete názvy vlastností, které jsou nezáporná celá čísla, pole automaticky určí hodnotu vlastnosti délka. Například výše jsme vytvořili pole arr s jední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.

Indexy v poli byste měli jasně odlišit od názvů 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řidat 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 jako indexy pole lze použít záporná a neceločíselná čísla. 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 existující prvky v poli na pozice s vyššími indexy.

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

Var arr = ; smazat arr; 2 v arr; // false, index 2 v poli 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é hodnoty tomuto 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 se vyplnilo prázdné místo po odstranění 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 metody push()), která zmenší délku pole o 1 a vrátí hodnotu odebraného prvku. Existuje také metoda posun()(opak unshift()), který odstraní prvek na začátku pole. Na rozdíl od operátoru delete posune metoda shift() všechny prvky dolů na pozici pod jejich aktuálním indexem.

Nakonec existuje víceúčelová metoda spoj (), který umožňuje vkládat, mazat a nahrazovat prvky pole. Změní hodnotu vlastnosti length a podle potřeby posouvá prvky pole na nižší nebo vyšší indexy. Na všechny tyto metody se podíváme o něco později.

Vícerozměrná pole

JavaScript nepodporuje „skutečné“ vícerozměrná pole, ale poskytuje dobrý způsob, jak je simulovat pomocí polí polí. Chcete-li získat přístup k datovému prvku v poli polí, jednoduše použijte 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 k určitému číslu v poli můžete použít výraz matice[x][y]. Níže je uveden 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 Array

Standard ECMAScript 3 definuje Array.prototype jako sadu pohodlných funkcí pro práci s poli, které jsou dostupné jako metody na libovolném poli. 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, spojí je a vrátí výsledný řetězec. Jako volitelný argument můžete metodě 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. Například následující fragment má za následek ř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 v původním poli, tzn. Tato metoda nevytváří nové pole s přeuspořádanými prvky, ale spíše je mění pořadí v již existujícím poli. Například následující úryvek pomocí metod reverse() a join() vede k řetězci "3,2,1":

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

metoda sort().

Metoda Array.sort() třídí prvky ve zdrojovém poli a vrací 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í (to znamená, že 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(funkce(a,b) ( // Číselné pořadí: 4, 33, 222, 1111 návrat a-b; // Vrátí 0 // v závislosti na pořadí řazení a a b)); // Seřadit v opačném směru, 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 concat().

Metoda Array.concat() vytvoří a vrátí nové pole obsahující prvky původního pole, na kterém bylo zavoláno concat(), a hodnoty všech argumentů předávaných 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(); // Návrat arr.concat(,) // Návrat arr.concat(4, ]) // Návrat ]

metoda slice().

Metoda Array.slice() vrací řez nebo podpole zadaného pole. Dva argumenty metody určují 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 je několik příkladů:

Var arr = ; arr.slice(0,3); // Návrat arr.slice(3); // Návrat arr.slice(1,-1); // Návrat arr.slice(-3,-2); // Návrat

metoda splice().

Metoda Array.splice() je obecná metoda, která provádí vkládání nebo mazání prvků 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 se po vložení nebo vymazání vytvořila souvislá sekvence.

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é by měly být odstraněny (vyříznuty) z pole. Pokud je druhý argument vynechán, budou odstraněny všechny prvky pole od zadaného 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 dalších argumentů určujících prvky, které mají být vloženy do pole, počínaje pozicí zadanou v prvním argumentu.

Var arr = ; arr.splice(4); // Return , arr = arr.splice(1,2); // Return , arr = arr.splice(1,1); // Návrat ; arr = arr =; arr.splice(2,0,"a","b"); // Návrat ; arr =

metody push() a pop().

Metody push() a pop() umožňují pracovat s poli, jako by to byly 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 spíše než vytváření jeho upravené kopie.

metody unshift() a shift().

Metody unshift() a shift() se chovají téměř stejně jako push() a pop(), až na to, že vkládají a odebírají prvky na začátek pole, nikoli na konec. Metoda unshift() posune existující prvky na větší indexy, 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 zabraly místo uvolněné na začátku pole.