javascript syntax polia terminály premenné. Polia

Čo je pole

Pole je dátový typ, ktorý ukladá očíslované hodnoty. Každá očíslovaná hodnota sa nazýva prvok poľa a číslo, ku ktorému je prvok priradený, sa nazýva jeho index. Polia JavaScript sú bez typu, čo znamená, že prvok poľa môže byť ľubovoľného typu a rôzne prvky toho istého poľa môžu mať rôzne typy. Polia JavaScriptu sú navyše dynamické, čo znamená, že nemusíte deklarovať pevnú veľkosť a môžete kedykoľvek pridať nové prvky.

Vytvorenie poľa

Pole je možné vytvoriť dvoma spôsobmi, prvým je vytvorenie poľa pomocou literálu poľa – hranatých zátvoriek, vo vnútri ktorých je čiarkami oddelený zoznam prvkov.

var prázdny = ; //prázdne pole var čísla = ; //pole s 5 numerickými prvkami var diff = ; //pole s 3 prvkami rôznych typov

Hodnoty nemusia byť jednoduché (čísla alebo reťazce) - môžu to byť aj akékoľvek iné výrazy, ako napríklad objektové literály, iné polia alebo funkcie.

varnum = 700; var tab = , num + 1];

Druhým spôsobom vytvorenia poľa je zavolanie konštruktora Array(). Existujú tri spôsoby, ako zavolať konštruktor Array().

• Volanie konštruktora bez argumentov:

varb = new Array();

V tomto prípade sa vytvorí prázdne pole ekvivalentné prázdnemu literálu.

• Konštruktor explicitne špecifikuje hodnoty n prvkov poľa:

var b = new Array(1, 3, 5, 8, "string", true);

V tomto prípade dostane konštruktor zoznam argumentov, ktoré sa stanú prvkami nového poľa. Argumenty sa zapisujú do poľa v poradí, v akom sú zadané.

• Pridelenie priestoru pre následné priradenia hodnôt. To sa dosiahne zadaním jedného čísla v zátvorkách pri definovaní poľa:

var b = new Array(5);

Tento spôsob definovania poľa zahŕňa pridelenie určitého počtu prvkov do poľa (každý z nich má hodnotu nedefinované) s možnosťou následného priradenia hodnôt v priebehu skriptu. Tento formulár sa zvyčajne používa na predbežné pridelenie poľa, ak je jeho dĺžka vopred známa.

Čítanie, zapisovanie a pridávanie prvkov poľa

Prvky poľa sú prístupné pomocou . Prvky poľa v JavaScripte sú číslované od nuly. Ak chcete získať požadovaný prvok poľa, musíte zadať jeho číslo v hranatých zátvorkách.

varnumbers = ; document.write(čísla + ", "); //prvý prvok poľa document.write(čísla + ", "); //druhý prvok poľa document.write(čísla + ", "); //tretí prvok poľa document.write(numbers); //štvrtý prvok poľa

Prvky poľa je možné zmeniť:

varnumbers = ; čísla = 10; //zmenil prvý prvok poľa -

Ak chcete pridať nový prvok poľa, stačí priradiť novú hodnotu:

varnumbers = ; čísla = 7; //sa stal

Poznámka: Polia JavaScript môžu uložiť ľubovoľný počet prvkov akéhokoľvek typu.

Dĺžka poľa

Všetky polia, či už vytvorené pomocou konštruktora Array() alebo definované pomocou literálu poľa, majú špeciálnu vlastnosť length, ktorá vracia celkový počet prvkov uložených v poli. Pretože polia môžu mať nedefinované (nedefinované) prvky, presnejšie tvrdenie je, že vlastnosť length je vždy o jednu viac ako najväčší index (číslo) prvku poľa. Vlastnosť dĺžky sa automaticky aktualizuje, aby bola správna, keď sa do poľa pridávajú nové prvky.

Varv = new Array(); // v.length == 0 (nie je definovaný žiadny prvok) v = new Array(1,2,3); // v.dĺžka == 3 (definované prvky 0–2) v = ; // v.length == 2 (prvky 0 a 1 definované) document.write(v.length);

Môžete tiež použiť vlastnosť length na získanie posledného prvku poľa:

Var v = ["JavaScript", "Vlastnosť", "Polia"]; dokument.zapis(v);

Posledný prvok má index o 1 menší ako je dĺžka poľa, pretože počet začína od nuly. Preto, ak nepoznáte presný počet prvkov, ale potrebujete sa odvolať na posledný prvok poľa, použije sa zápis: v.length - 1.

Iterácia cez prvky poľa

Najbežnejším použitím vlastnosti length je iterácia prvkov poľa v slučke:

Tento príklad predpokladá, že prvky poľa sú súvislé a začínajú prvým prvkom (s indexom 0). Ak to tak nie je, pred prístupom ku každému prvku poľa musíte skontrolovať, či je definovaný:

Var ovocie = ["jablko", "banán", "jahoda", "broskyňa"]; for(var i = 0; i

Slučku možno použiť aj na inicializáciu prvkov poľa:

Var bar = new Array(10); for(var i = 0; i

Skráťte a rozbaľte pole

Pri práci s poľami sa vlastnosť length automaticky aktualizuje, takže sa o ňu nemusíme starať ani my sami. Za zmienku však stojí jedna vec – vlastnosť length je dostupná nielen na čítanie, ale aj na písanie. Ak nastavíte vlastnosť length na hodnotu menšiu ako aktuálna, pole sa skráti na novú (danú) dĺžku, všetky prvky, ktoré nespadajú do nového rozsahu indexov, sa zahodia a ich hodnoty sa stratia, dokonca ak dĺžku vrátite neskôr - hodnoty sa neobnovia.

var foo = ; foo.length = 1; //skrátiť na 1 prvok - foo.length = 4; //obnovenie predchádzajúceho počtu prvkov document.write(foo); //neexistuje žiadna predchádzajúca hodnota

Najjednoduchší spôsob, ako vyčistiť pole, by bol: foo.length = 0.

Ak je vlastnosť length väčšia ako jej aktuálna hodnota, na koniec poľa sa pridajú nové nedefinované prvky, čím sa pole zväčší na zadanú veľkosť.

Odstránenie prvkov poľa

Operátor delete zapíše do prvku poľa nedefinovanú hodnotu, zatiaľ čo samotný prvok naďalej existuje. Ak chcete odstrániť prvky, aby sa zvyšné prvky presunuli do uvoľneného priestoru, musíte použiť jednu z preddefinovaných metód poľa. Metóda Array.shift() odstraňuje prvý prvok poľa, pop() - posledný prvok poľa, metóda splice() - jeden alebo rozsah prvkov kdekoľvek v poli. Podrobnosti o používaní týchto metód budú popísané v nasledujúcej kapitole.

Viacrozmerné polia

Pripomeňme, že polia JavaScript môžu obsahovať iné polia ako prvky. Túto funkciu možno použiť na vytváranie viacrozmerných polí. Ak chcete získať prístup k prvkom v poli polí, použite zátvorky dvakrát.

Matica var = [ , , ]; dokument.zapis(matica); //vybratý stredový prvok

Poďme analyzovať, čo je napísané v príklade, matica je pole polí čísel. Akýkoľvek prvok matice[n] je pole čísel. Pre prístup ku konkrétnemu číslu v poli napíšte maticu[n][n], druhé hranaté zátvorky označujú index prvku vnútorného poľa.

//analóg predchádzajúceho záznamu - vytvorenie pomocou konštruktora var table = new Array(3); for(var i = 0; i

Asociatívne polia

Objekty možno použiť ako asociatívne polia. Trochu teórie – asociatívne polia (nazývané aj hašovacie tabuľky) vám umožňujú používať reťazce namiesto indexov. Používanie asociatívnych polí je veľmi podobné používaniu názvu vlastnosti normálneho objektu, ale v tomto prípade vo formáte poľa. Keďže v JavaScripte neexistujú žiadne metódy na prácu s asociatívnymi poliami, používajú sa oveľa menej často ako bežné polia, hoci môžu byť užitočné aj na ukladanie informácií a uľahčenie zapamätania prvkov, ku ktorým je potrebné pristupovať.

Var s_list = new Object(); s_list["fat"] = "Tuk"; s_list["small"] = "Malý"; s_list["meno"] = "Homer"; for (var x v s_liste) //zobrazenie všetkých prvkov document.write(s_list[x] + "
");

V tomto článku sa pozrieme na pole JavaScript a jeho komponenty. JavaScript je ideálne orientovaný a určený na programovanie. V skutočnosti implementuje jazyk ECMAScript (odkaz ECMA-262).

Kde sa používa JavaScript? Používa sa ako vložiteľný jazyk na definovanie programovej cesty k objektu aplikácie. Nachádza sa v prehliadačoch, kde sa používa ako skriptovací jazyk, vďaka ktorému sú webové stránky interaktívne.

Najdôležitejšími architektonickými vlastnosťami tohto produktu sú dynamické a slabé písanie, automatická správa pamäte, dokonalé programovanie a funkcie, ktoré sú prvotriednymi objektmi.

Vo všeobecnosti bol JavaScript ovplyvnený rôznymi dôvodmi, pretože počas vývoja chceli vytvoriť jazyk podobný Jave, ale ľahko ovládateľný pre programátorov. Mimochodom, JavaScript nie je pôvodný pre žiadny podnik alebo organizáciu, čím sa líši od množstva programovacích štýlov používaných webovými vývojármi.

Je potrebné poznamenať, že JavaScript je registrovaná ochranná známka spoločnosti Oracle Corporation.

Čo je pole?

Volá sa pole, ktoré ukladá očíslované hodnoty. Každá takáto hodnota sa nazýva komponent poľa a číslica, ku ktorej je komponent priradený, sa nazýva index. Pole JavaScriptu nie je zadané. To znamená, že časti poľa môžu byť akéhokoľvek typu a rôzne časti patriace do rovnakého poľa majú úplne odlišné typy.

Pole JavaScript je navyše dynamické, čo znamená, že nie je potrebné deklarovať pevnú veľkosť. Koniec koncov, môžete kedykoľvek pridať nové podrobnosti.

Výroba polí

Pomocou JavaScriptu nie je vytvorenie poľa vôbec ťažké. Sú na to dva spôsoby. Prvý zahŕňa vytvorenie poľa pomocou doslovných hranatých zátvoriek, vo vnútri ktorých je zoznam častí oddelených čiarkami.

• var prázdny = ; //prázdne pole;
• var čísla = ; //pole s piatimi digitálnymi komponentmi;
• var diff = ; //pole s tromi prvkami rôznych typov.

Spravidla sa tu nevyžaduje, aby hodnoty boli jednoduché (reťazce a čísla). Môžu to byť aj akékoľvek iné výrazy, ako napríklad predmetové literály, iné funkcie a polia.

Druhý spôsob, ako vytvoriť pole, je zavolať návrhára Array(). Pozvať ho môžete tromi spôsobmi:

• Volanie návrhára bez argumentov: var b - new Array(). To umožňuje vytvorenie prázdneho poľa ekvivalentného prázdnemu literálu .
• Konštruktor explicitne špecifikuje hodnotu n komponentov poľa: var b = new Array(1, 3, 5, 8, "string", true). V tomto prípade sa dizajnérovi zobrazí zoznam argumentov, ktoré sa premenia na komponenty nového poľa. Argumenty sa zapisujú do poľa v mieste, kde sú špecifikované.
• Určenie plochy pre následné priradenie hodnôt. To sa dosiahne špecifikovaním poľa jedného čísla uzavretého v zátvorkách pri identifikácii: var b = new Array(5). Táto metóda detekcie zahŕňa pridelenie požadovaného počtu komponentov do poľa (každá z nich je uvedená ako nedefinovaná) s možnosťou následného priradenia hodnôt v procese prezentácie. Tento formulár sa zvyčajne používa na predbežné pridelenie poľa Javascript, ktorého dĺžka je vopred známa.

Zápis, čítanie a pridávanie detailov poľa

Ku komponentom poľa môžete pristupovať pomocou . Mimochodom, všetky komponenty v JavaScripte, počnúc nulou, sú očíslované. Na získanie požadovaného prvku je jeho číslo uvedené v Spravidla je možné zmeniť podrobnosti. A aby sa JavaScript pridal do poľa, stačí priradiť novú hodnotu.

Je potrebné poznamenať, že polia JavaScript môžu ukladať ľubovoľný počet prvkov akéhokoľvek druhu.

Dĺžka poľa

Takže vieme, že dĺžka poľa je vo všeobecnosti zaujímavým fenoménom. Pozrime sa na to podrobnejšie. Všetky polia, či už skonštruované pomocou návrhára Array() alebo identifikované literálom poľa, majú špecifickú vlastnosť length, ktorá vracia celkový počet prvkov na uloženie. Keďže pole môže obsahovať nedefinované časti (označené ako nedefinované), presnejšie vyjadrenie je: kvalita dĺžky je vždy o jednu viac ako najväčšie číslo (index) komponentu poľa. Kvalita dĺžky sa nastavuje automaticky a zostáva presná, keď sa v poli objavia nové diely.

Môžete použiť vlastnosť length, aby sa zobrazil konečný komponent poľa.

Posledná časť má index o jeden menší ako je veľkosť poľa. Koniec koncov, odpočítavanie vždy začína od nuly. Ach ten JavaScript! Dĺžka poľa závisí od presného počtu prvkov. Preto, ak neviete, koľko by ich malo byť, ale potrebujete odkazovať na konečný prvok poľa, musíte použiť zápis: v.length - 1.

Opakovanie podrobností poľa

Veľmi často sa vlastnosť length používa na iteráciu detailov poľa v slučke:

• var ovocie = ["jahoda", "broskyňa", "jablko", "banán"];
• for(var I = 0; i< fruits.lenght; i++);
• document.write(ovocie[i] + "...").

V tomto príklade sa zdá, že komponenty sú umiestnené súvisle a začínajú v prvej časti, ktorá vlastní index nula. Ak to tak nie je, pred volaním každého prvku poľa musíte skontrolovať, či je definovaný.

Slučka sa niekedy používa aj na inicializáciu komponentov.

Prírastok a skrátenie poľa

Zaujímalo by ma, ako pridať reťazec do poľa pomocou JavaScriptu? V procese práce s poľami sa kvalita dĺžky automaticky zlepšuje, preto sa o to musíme postarať sami. Je potrebné si zapamätať jeden detail – vlastnosť length je nielen čitateľná, ale aj zapisovateľná. Ak je kvalite dĺžky priradená hodnota, ktorej veľkosť je menšia ako aktuálna, pole sa zníži na zadanú hodnotu. Všetky komponenty, ktoré nie sú v novom rozsahu indexov, sa zahodia a ich hodnoty sa stratia, aj keď sa dĺžka neskôr vráti – hodnoty sa neobnovia.

Je celkom jednoduché vyčistiť pole takto: foo.length = 0.

Ak je kvalita dĺžky väčšia ako jej aktuálna hodnota, na konci poľa sa objavia nové nenastavené časti, ktoré ho zväčšia na požadovanú veľkosť.

Odstránenie detailov vzoru

Operátor vymazania nastaví komponent poľa na nedefinovaný, kým naďalej existuje. Ak chcete odstrániť prvok poľa JavaScript, aby sa zvyšné časti presunuli do uvoľneného priestoru, musíte použiť jednu z poskytnutých metód poľa. Metóda Array.shift() eliminuje prvý komponent, pop() posledný komponent a metóda splice() eliminuje jeden alebo celý rad komponentov kdekoľvek v poli.

Polia sú viacrozmerné

Zdá sa, že máme trochu náskok, 2D polia sú to, na čo sa musíme pozrieť ďalej. Pamätáte si, že polia JavaScript môžu obsahovať ďalšie prvky ako komponenty? Táto funkcia sa používa na vytváranie viacrozmerných polí. Ak chcete navštíviť komponenty v rade polí, stačí použiť hranaté zátvorky dvakrát.

Asociatívne polia

Teraz sa pozrime, ako ochranná známka JavaScript používa asociatívne polia. Aby sme to dosiahli, musíme sa pozrieť do teórie: asociatívne polia sa niekedy nazývajú hašovacie tabuľky. Vďaka nim sa namiesto indexov používajú reťazce. Použitie takýchto konštrukcií sa podobá použitiu názvu vlastnosti jednoduchého objektu, ale v tomto prípade pri vykonávaní práce vo formáte poľa. Keďže v JavaScripte neexistujú žiadne spôsoby, ako pracovať s asociatívnymi poliami, používajú sa oveľa menej často ako bežné polia. Je potrebné poznamenať, že stále môžu byť užitočné na ukladanie údajov a uľahčujú zapamätanie podrobností, ku ktorým je potrebné pristupovať.

Výstup poľa

A čo teraz budeme študovať v systéme JavaScript? Zobrazenie poľa v dialógovom okne (na obrazovke monitora), ako aj výstup hodnôt komponentov poľa.

Ak program potrebuje zobraziť hodnoty všetkých komponentov, je vhodné na to použiť príkaz for. Je zaujímavé, že premenná počítadla pravidiel for sa používa ako index komponentu poľa.

čistenie

Ak chcete filtrovať pole JavaScript, musíte nastaviť jeho dĺžku na nulu:

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

• clear: function() (;
• táto dĺžka = 0;
• vrátiť toto;

Pridávanie a odoberanie komponentov

Pokračujeme v ďalšom štúdiu tohto zaujímavého jazyka JavaScript. Prvok poľa je možné odstrániť aj pridať rovnakým spôsobom ako bežné vlastnosti iných objektov. Existujú však určité rozdiely: pridanie číselných vlastností môže zmeniť kvalitu dĺžky, zatiaľ čo úpravou vlastnosti dĺžky môžete číselné vlastnosti odstrániť. Algoritmus na nastavenie kvality polí je v zásade nasledujúci:

• Pri pridávaní neznámej číselnej vlastnosti i, ak je dĺžka rovná alebo menšia ako i, sa dĺžka určí ako i+1.
• Keď sa zmení kvalita dĺžky, vykonajú sa nasledujúce akcie: ak je priradená hodnota menšia ako nula, vyvolá sa chyba RangeError. Odstráňte všetky číselné kvality a indexy, ktoré sú rovnaké alebo väčšie ako nová dĺžka.

Vo všeobecnosti je odstránenie prvku poľa JavaScriptu jednoduché. Koniec koncov, dokonca aj nastavenie dĺžky, musíte z neho odstrániť "extra" komponenty. Preto možnosť vymazať pole. Ak vám z nejakého dôvodu nevyhovovala priradená premenná prázdneho nového poľa, ale je potrebné vynulovať aktuálnu, stačí nastaviť jej kvalitu dĺžky na nulu.

metódy vyraďovania, posunu, pop a push

Hoci sa komponenty poľa upravujú manuálne, mnohí ľudia na to odporúčajú použiť vstavané metódy. Práve táto nuansa zaručuje správnu kvalitu hodnoty dĺžky a absenciu medzier v poli. Mimochodom, správna dĺžka kvality bude zodpovedať počtu komponentov.

Metóda push presunie prechádzajúce časti na koniec poľa. Metóda pop vráti koncový komponent a odstráni ho.

Vo všeobecnosti v Internet Exploreri pred verziou 8 môže funkcia unshift vrátiť hodnotu nedefinovaná, v iných prehliadačoch môže vrátiť novú hodnotu dĺžky. Takže je lepšie nespoliehať sa na hodnotu vrátenú z nestriedanosti.

Pridávanie a odstraňovanie detailov v strede poľa

Ak potrebujete odstrániť pole JavaScript, čo by ste mali urobiť? Je známe, že metóda spájania má podpis Array.prototype.splice.

Odstráni komponenty deleteCount z poľa, počnúc počiatočným indexom. Ak sú odovzdané viac ako dva argumenty, všetky nasledujúce argumenty v poli sa umiestnia na miesto eliminovaných. Ak je začiatok záporný, potom index, od ktorého bude výber pokračovať, sa bude rovnať dĺžke + začiatku. Návrat do poľa pochádza z odstránených prvkov.

V skutočnosti pomocou metódy spájania môžete odstrániť komponenty zo stredu poľa alebo pridať ľubovoľný počet komponentov kdekoľvek v poli.

V najjednoduchšej verzii, ak potrebujete odstrániť komponent s indexom i, musíte požiadať o metódu spojenia z poľa s parametrami i a 1.

V zásade je druhý parameter metódy splice voliteľný, ale správanie funkcie s jedným argumentom je v každom prehliadači iné.

Napríklad vo Firefoxe, v najnovších verziách Opery, v Safari a v Chrome budú všetky podrobnosti odstránené až do konca poľa.

V IE sa žiadna z komponentov nezničí. V prvých variáciách Opery je nemožné predvídať správanie - bude odstránená jedna časť so štartom indexu - 1. Preto musia byť do tejto metódy vždy odovzdané aspoň dva komponenty.

Keys

Samozrejme, pri učení JavaScriptu by sa nemali prehliadať ani asociatívne polia, ako už bolo spomenuté. Ide o abstraktný typ informácie (rozhranie s dátovým úložiskom), ktorý umožňuje ukladať dvojice vo forme „(kľúč, hodnota)“ a podporovať operácie pridávania páru, ako aj mazanie a vyhľadávanie párov pomocou kľúč:

NÁJSŤ (kláves).

INSERT(hodnota, kľúč).

ODSTRÁNIŤ (kláves).

Predpokladá sa, že dva páry s podobnými kľúčmi nemožno uložiť do asociatívneho poľa. V páre k + v v sa nazýva hodnota spojená s kľúčom k. Sémantika a názvy vyššie uvedených operácií v rôznych implementáciách takýchto polí sa môžu líšiť.

Akcia FIND (kľúč) teda vráti hodnotu priradenú k danému kľúču, alebo nejakému špecifickému objektu UNDEF, čo znamená, že k danému kľúču nie je priradená žiadna hodnota. Ďalšie dve akcie nevracajú nič (okrem toho, či bola operácia úspešná alebo nie).

Vo všeobecnosti je z hľadiska rozhrania vhodné považovať asociatívne pole za jednoduché pole, v ktorom môžu byť ako indexy použité nielen celé čísla, ale aj hodnoty iných typov, napríklad reťazce. .

Mimochodom, podpora pre takéto polia je dostupná v mnohých programovacích jazykoch na vysokej úrovni, ako sú PHP, Perl, Ruby, Python, Tcl, JavaScript a ďalšie. Pre jazyky, ktoré nemajú vstavané nástroje na prácu s asociatívnymi poľami, bolo vytvorených veľké množstvo implementácií vo forme knižníc.

Príkladom asociatívneho poľa je telefónny zoznam. V tomto variante je hodnotou komplex „F. I. O. + adresa “ a kľúčom je telefónne číslo. Jedno telefónne číslo má jedného vlastníka, no jedna osoba môže vlastniť viacero čísel.

Asociatívne rozšírenia

Je potrebné poznamenať, že medzi najznámejšie rozšírenia patria nasledujúce akcie:

• KAŽDÝ - "prechádzať" cez všetky uložené páry.
• VYMAZAŤ - odstránenie všetkých záznamov.
• MIN - nájdite pár s najmenšou hodnotou kľúča.
• MAX - nájdite pár s najvyššou hodnotou kľúča.

V posledných dvoch možnostiach je potrebné, aby na klávesoch bola uvedená porovnávacia akcia.

Implementácia asociatívnych polí

Existuje mnoho rôznych implementácií asociatívneho poľa. Najbežnejšia implementácia môže byť založená na jednoduchom poli, ktorého komponentmi sú páry (hodnota, kľúč). Na urýchlenie hľadania si môžete objednať komponenty tohto poľa podľa kľúča a nájsť pomocou. Tým sa však predĺži čas potrebný na pridanie nového páru, pretože budete musieť komponenty poľa „odstrčiť“, aby ste mohli zabaliť nový vstup do prázdnej bunky, ktorá sa objaví.

Najznámejšie implementácie sú založené na rôznych vyhľadávacích stromoch. Napríklad v typickej čítačke C++ STL je mapový kontajner implementovaný na základe čierno-mahagónového stromu. Štýly Ruby, Tcl, Python používajú jeden z typov hašovacích tabuliek. Existujú aj iné implementácie.

Vo všeobecnosti má každá implementácia svoje výhody a nevýhody. Je dôležité, aby sa všetky tri akcie vykonali v priemere aj v najhoršom odtieni za obdobie O(log n), kde n je aktuálny počet uložených párov. V prípade zhodných vyhľadávacích stromov (vrátane čierno-červených stromov) je táto podmienka splnená.

Je známe, že pri implementáciách založených na hashovacích tabuľkách je priemerný čas definovaný ako O(1), čo je lepšie ako pri akciách založených na vyhľadávacích stromoch. To samozrejme nezaručuje vysokú rýchlosť vykonávania jednotlivých operácií: čas vykonania INSERT je v najhoršom prípade označený ako O(n). Proces INSERT trvá dlho, keď faktor plnenia dosiahne svoj najvyšší bod a je potrebné rekonštruovať index hašovacej tabuľky.

Mimochodom, tieto hash zoznamy sú zlé, pretože na ich základe nie je možné vykonávať rýchle dodatočné akcie MAX, MIN a algoritmus na obídenie všetkých uložených párov v zostupnom alebo vzostupnom poradí kľúčov.

Polia môžu byť manipulované pomocou rôznych metód poskytovaných konštruktorom Array.

metódy pop/push a shift/unshift

Zvážte metódy pop() a push(). Tieto metódy umožňujú, aby sa s poliami zaobchádzalo ako so zásobníkmi. Zásobník je dátová štruktúra, v ktorej je prístup k prvkom organizovaný podľa princípu LIFO (anglicky last in - first out, "last in - first out"). Princíp stohu možno prirovnať k stohu tanierov: ak chcete vziať druhý zhora, musíte odstrániť horný. Ako to funguje je znázornené na obrázku:

Vráťme sa teda k metódam push() a pop(). Metóda push() pridá jeden alebo viacero nových prvkov na koniec poľa a vráti jeho novú dĺžku. Metóda pop() odstráni posledný prvok poľa, skráti dĺžku poľa a vráti hodnotu, ktorú odstránil. Všimnite si, že obe tieto metódy upravujú pole na mieste, namiesto vytvárania jeho modifikovanej kópie.

var foo = ; // foo: foo.push(1,2); // foo: Vráti 2 foo.pop(); // foo: Vráti 2 foo.push(3); // foo: Vráti 2 foo.pop(); // foo: Vráti 3 foo.push(); // foo: ] Vráti 2 foo.pop() // foo: Vráti foo.pop(); // foo: Vráti 1 var ovocie = ["hrušky", "banány", "jablká"]; var vybral = ovocie.pop(); document.write("Vytrhol si mi " + vybral); Skúste »

Metódy shift() a unshift() sa správajú podobne ako pop() a push(), až na to, že vkladajú a odstraňujú prvky na začiatok poľa. Metóda unshift() posúva existujúce prvky smerom k vyšším indexom, aby sa vytvoril priestor pre nové prvky, pridáva jeden alebo viac prvkov na začiatok poľa a vracia novú dĺžku poľa. Metóda shift() odstráni prvý prvok poľa a vráti jeho hodnotu, pričom posunie všetky nasledujúce prvky tak, aby zaplnili voľné miesto na začiatku poľa.

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

spájacia metóda

Metóda Array.join() sa používa na spojenie prvkov poľa do jedného reťazca. Metóde môžete odovzdať voliteľný argument reťazca, ktorý sa použije na oddelenie prvkov v reťazci. Ak nie je zadaný oddeľovač, pri volaní metódy bude predvoleným znakom oddeľovača čiarka.

Var a = ["Vietor","Dážď","Oheň"]; var myVar1 = a.join(); //"Vietor,dážď,oheň" var myVar2 = a.join(", "); //"Vietor, dážď, oheň" var myVar3 = a.join(" + "); //"Vietor + dážď + oheň" document.write(myVar1 + "
" + myVar2 + "
" + myVar3); Skúste »

Metóda Array.join() je inverzná metóda k metóde String.split(), ktorá vytvára pole rozdelením reťazca na časti.

reverzná metóda

Metóda Array.reverse() obráti poradie prvkov v poli a vráti pole s preusporiadanými prvkami. Táto metóda nevytvára nové pole s preusporiadanými prvkami, ale mení ich poradie v už existujúcom poli.

Var myArr = ["jeden", "dva", "tri"]; document.write(myArr.reverse()); Skúste »

konkátová metóda

Metóda Array.concat() vytvorí a vráti nové pole obsahujúce prvky pôvodného poľa, na ktorom bola zavolaná metóda concat(), postupne doplnené hodnotami všetkých argumentov odovzdaných metóde concat(). Ak je niektorý z týchto argumentov sám o sebe pole, pridajú sa všetky jeho prvky. Názvy polí sa používajú ako argumenty a sú špecifikované v poradí, v akom majú byť ich prvky zreťazené.

Var a = ; a.concat(4, 5) //Vráti a.concat(); //rovnako - vráti a.concat(,) //Vráti

spôsob triedenia

Metóda Array.sort() triedi prvky poľa na mieste a vracia zoradené pole. Ak sa metóda sort() zavolá bez argumentu, zoradí prvky poľa abecedne (dočasne ich prevedie na reťazce na účely porovnania). Ako argument môže metóda sort() použiť porovnávaciu funkciu, ktorá určuje poradie triedenia prvkov.

Var a = ["Kiwi", "Pomaranče", "Hrušky"]; a.sort(); vars = a.join(", "); //Pomaranče, hrušky, kivi document.write(s); //príklad s číslami var myArr = ; myArr.sort(); document.write(myArr); //1,10,2 Vyskúšať »

Pravdepodobne ste čakali, že pri triedení čísel uvidíte trochu iný výsledok. K tomuto triedeniu dochádza, pretože metóda sort() triedi prvky tak, že ich konvertuje na reťazce. Preto je poradie, ktoré dostanú, reťazec – napokon „10“

Ak chcete triediť v inom ako abecednom poradí, môžete metóde sort() odovzdať funkciu porovnávania ako argument. Treba však poznamenať, že porovnávaciu funkciu si budeme musieť napísať sami. Táto funkcia musí mať dva parametre, pretože určuje, ktorý z jej dvoch argumentov sa má objaviť ako prvý v zoradenom zozname. Na uľahčenie pochopenia a napísania takejto funkcie existuje niekoľko pravidiel, podľa ktorých bude poradie prvkov určené:

• Ak musí byť prvý argument pred druhým, porovnávacia funkcia vráti záporné číslo (ak a
• Ak prvý argument musí nasledovať za druhým, potom porovnávacia funkcia vráti kladné číslo (ak a > b)
• Ak sú dve hodnoty ekvivalentné (t. j. ich poradie nie je dôležité), porovnávacia funkcia vráti 0 (ak a == b)

Na porovnanie funkcia používa prvky poľa ako svoje argumenty:

Funkcia foo(a,b) ( //definuje testovaciu funkciu, ak (a b) vráti 1; vráti 0; //ak a == b ) var a = ; a.sort(foo); //ako argument sa odovzdá iba názov funkcie document.write(a.join(", ")); //skratka rovnaká var a = ; a.sort(funkcia(a,b) ( //použitie anonymnej funkcie vráti a - b; //funkcia vráti 0 )); dokument.zapis(a); //1,2,5,10 Vyskúšať »

Prvý záznam v príklade je napísaný týmto spôsobom, aby bolo ľahšie pochopiť, ako to funguje. Všimnite si, aké pohodlné je použiť anonymnú funkciu v druhom úryvku. Volá sa len raz, takže nie je potrebné ho pomenovať.

Poznámka: Ak sú v poli nedefinované prvky, presunú sa na koniec poľa.

plátková metóda

Metóda Array.slice() sa používa na kopírovanie špecifikovaného rezu z poľa a vracia nové pole obsahujúce skopírované prvky. Pôvodné pole sa nemení.

Syntax metódy:

názov_poľa.slice(začiatok, koniec);

Názov poľa by mal byť nahradený názvom poľa, z ktorého chcete extrahovať špecifickú množinu prvkov pre nové pole. Metóda má dva argumenty, ktoré definujú začiatok a koniec vrátenej sekcie poľa. Metóda skopíruje časť poľa začínajúcu od začiatku do konca, bez konca. Ak je zadaný iba jeden argument, vrátené pole bude obsahovať všetky prvky od zadanej pozície po koniec poľa. Môžete použiť záporné indexy - počítajú sa od konca poľa.

Var arr = ; arr slice(0,3); //Vráti arr.slice(3); //Vráti arr.slice(1,-1); //Vráti arr.slice(-3,-2); //Vrátenie

spájacia metóda

Metóda Array.splice() je všeobecná metóda na prácu s poľami. Upravuje pole na mieste namiesto toho, aby vrátilo nové upravené pole, ako to robia metódy slice() a concat(). Metóda splice môže odstrániť prvky z poľa, vložiť nové prvky, nahradiť prvky - jeden po druhom a súčasne. Vráti pole pozostávajúce z odstránených prvkov, ak nebol odstránený žiadny z prvkov, vráti prázdne pole.

Syntax metódy:

názov_poľa.splice(index , počet, prvok1, ..., prvokN);

Prvý argument určuje index v poli, od ktorého sa má začať vkladať alebo odstraňovať prvky. Druhý argument určuje počet prvkov, ktoré sa majú z poľa odstrániť, počnúc indexom uvedeným v prvom argumente, ak je druhý argument 0, neodstránia sa žiadne prvky. Ak je druhý argument vynechaný, všetky prvky poľa sa odstránia zo zadaného indexu až do konca poľa. Pri použití záporného čísla pozície sa prvky budú počítať od konca poľa.

Var ovocie = ["pomaranče", "jablká", "hrušky", "hrozno"]; var delete = fruits.splice(2,2); //vráti ["hrušky", "hrozno"] document.write(deleted); var arr = ; arr.splice(4); // Vráti ; pole sa zmenilo na: arr.splice(1,2); // Vráti ; pole sa zmenilo na: arr.splice(1,1); // Vráti ; pole sa zmenilo na: Skúste »

Prvé dva argumenty metódy splice() špecifikujú prvky poľa, ktoré sa majú odstrániť. Po týchto dvoch argumentoch môže nasledovať ľubovoľný počet ďalších argumentov špecifikujúcich prvky, ktoré sa majú vložiť do poľa, počnúc od pozície danej prvým argumentom.

Var ovocie = ["pomaranče", "jablká"]; ovocie.splice(2,0, "vodove melóny"); //vráti document.write(ovocie); //stal sa ["pomaranče", "jablká", "vodové melóny"] var arr = ; arr.splice(2,0,"a","b"); // Vráti ; stalo sa arr.splice(2,2,); //Vráti ["a","b"]; stal sa ,3,4,5] Skúste »

Stojí za zmienku, že na rozdiel od concat() metóda splice() nerozdeľuje polia odovzdané ako argumenty na samostatné prvky. To znamená, že ak sa pole odovzdá metóde na vloženie, vloží pole samotné, nie prvky tohto poľa.

metóda toString

Metóda toString() konvertuje prvky poľa na reťazec pomocou čiarky ako oddeľovacieho znaku.

Var arr = ["Mlieko","Chlieb","Sušienky"]; var jedlo = arr.toString(); dokument.písať(jedlo); //Milk,Bread,Cookie Try »

Všimnite si, že metóda vracia rovnaký reťazec ako metóda join(), keď je volaná bez argumentov.

indexOf a lastIndexOf

Metóda indexOf vracia index prvku, ktorého hodnota sa rovná hodnote odovzdanej metóde ako argument.

Syntax metód indexOf() a lastIndexOf():

názov_poľa.indexOf(prvok_hľadania, index) názov_poľa.lastIndexOf(prvok_hľadania, index)

Prvý argument metódy udáva hodnotu prvku, ktorého index sa má nájsť, druhý argument (voliteľný) udáva index, od ktorého sa začne vyhľadávanie. Ak existuje viacero rovnakých výskytov, vyberie sa najmenší (prvý) index. Ak sa nenájde prvok s požadovanou hodnotou, metóda vráti -1. Vo vnútri metódy sa na vyhľadávanie používa striktné porovnávanie (===).

Var a = ; a.indexOf(3); //vráti 2 a.indexOf(3,4); //vráti 6 a.indexOf(35); //vráti -1: žiadny prvok s touto hodnotou a.indexOf(2); // jeden

Metóda lastIndexOf() tiež vráti index prvku, ktorého hodnota sa rovná hodnote odovzdanej metóde ako argument. Jediný rozdiel je v tom, že metóda lastIndexOf() vyberá najvyšší (posledný) index.

Var a = ; a.lastIndexOf(3); //vráti 7 a.lastIndexOf(35); //vracia -1: žiadny prvok s touto hodnotou a.lastIndexOf(2); // 6

Metódy iterátora

Metódy opísané nižšie sú iterátory. Všetky moderné prehliadače na prácu s poľami majú metódy, ktoré sú navrhnuté tak, aby iterovali prvky a vykonávali na nich rôzne akcie. Sú to metódy forEach(), map(), filter(), every(), some, reduction() a reductionRight().

Iterujú prvky poľa od 0 do dĺžky - 1 a ak prvok existuje, odovzdajú ho funkcii obsluhy spätného volania.

pre každý

Syntax metódy:

názov_poľa.forEach(spätné volanie, thisArg)

Prvým argumentom je funkcia spätného volania, ktorú zavolá metóda forEach() pre každý prvok poľa. Implementáciu funkcie volaného handlera si musíte napísať sami. Volaná funkcia musí mať tri parametre: prvý parameter berie ako argument - hodnotu prvku poľa, druhý - index prvku a tretí - samotné pole. Ak však chcete použiť iba hodnoty prvkov poľa, môžete napísať funkciu iba s jedným parametrom. Druhý argument - thisArg (voliteľné) bude odovzdaný ako hodnota this.

Var arr = ; funkcia foo(hodnota) ( ​​var suma = hodnota * toto; return document.write(sum + "
"); ) arr.forEach(foo, 5); //druhý argument bude odovzdaný ako hodnota tohto //príkladu s tromi parametrami var a = ; a.forEach(function(el, idx, a) ( dokument. write( "a["+idx+"] = "+el+" v ["+a+"]
"); )); Skúste »

filter

Syntax metódy:

názov_poľa.filter(spätné volanie, tentoObjekt)

Metóda filter() vytvorí a vráti nové pole, ktoré bude obsahovať iba tie prvky poľa, pre ktoré funkcia spätného volania vráti hodnotu true.

Function isBig(prvok, index, pole) ( //vracia čísla, ktoré sú väčšie alebo rovné 10, vrátia (prvok >= 10); //ak je hodnota prvku väčšia alebo rovná 10, výraz vráti hodnotu true ) var filter = .filter(isBig) ; //filtrované

mapa

Metóda map() vytvorí a vráti nové pole, ktoré bude pozostávať z výsledkov volania funkcie callback(item, idx, ar) pre každý prvok poľa.

Var a = ; var b = a.map(funkcia(položka, idx, arr) ( vrátenie položky * položka; )); // b =

každý a niektorí

Metóda every() vráti hodnotu true, ak pre všetky prvky poľa zadaná funkcia použitá na ich kontrolu vráti hodnotu true.

Metóda some() vráti hodnotu true, ak počas testu v zadanej funkcii jeden alebo viacero prvkov vráti hodnotu true.

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

znížiť a znížiťSprávne

Syntax metódy:

názov_poľa.reduce(spätné volanie, počiatočná hodnota) názov_poľa.reduceRight(spätné volanie, počiatočná hodnota)

Metóda reduction() aplikuje zadanú funkciu (spätné volanie) na dve hodnoty v poli naraz, pričom prechádza cez prvky zľava doprava, pričom zachováva medzivýsledok.

Argumenty funkcie spätného volania: (previousValue, currentItem, index, pole)

• previousValue – návratový výsledok funkcie spätného volania (známy ako medzivýsledok)
• currentItem - aktuálny prvok poľa (prvky sú zoradené postupne zľava doprava)
• index - index aktuálneho prvku
• pole – pole, ktoré sa má spracovať

initialValue (inicializujúca hodnota) - objekt použitý ako prvý argument prvého volania funkcie spätného volania. Jednoducho povedané, hodnota previousValue pri prvom volaní sa rovná initialValue. Ak neexistuje žiadna počiatočná hodnota, potom sa rovná prvému prvku poľa a iterácia začína od druhého:

Var a = ; function foo(prevNum,curNum) ( sum = prevNum + curNum; alert(sum); return sum; ) var vysledok = a.reduce(foo, 0); dokument.zapis(vysledok); Skúste »

Pozrime sa, ako tento príklad funguje. Prvé argumenty funkcie foo sú:

• prevNum = 0 (keďže initialValue je 0)
• curNum = 1 (aktuálny prvok je 1. prvok poľa)

1 sa pripočíta k číslu 0. Tento výsledok (súčet: 1) bude odovzdaný ako prevNum pri ďalšom spustení funkcie. A tak ďalej, kým sa nedosiahne posledný prvok. Vrátený výsledok je súčet z posledného behu, ktorý je 15 (1+2+3+4+5).

Metóda reductionRight funguje podobne ako metóda zmenšenia, ale iteruje pole sprava doľava:

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

V JavaScripte, ako aj v iných programovacích jazykoch, sa na prácu s poľami používajú rôzne metódy.

Metódy uľahčujú vytváranie logiky a jej implementáciu do skriptu.

Nižšie sú uvedené základné metódy pre prácu s poliami v JS.

TLAČIŤ

Metóda push() pridáva hodnotu na koniec poľa.

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

pop

Metóda pop() odstráni posledný prvok z poľa alebo vráti jeho hodnotu.

Nech arr = ; arr.pop(); log konzoly (arr); // →

Pomocou schopnosti získať hodnotu posledného prvku poľa ako príklad môžeme získať formát obrázka:

Nech img = "https://example.com/img/meno.png"; nech format = img.split(".").pop(); konzolový protokol (formát); // → png console.log(img.split(".")); // → ["https://example", "com/img/name", "png"]

nevyraďovať

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

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

posun

Metóda shift() odstráni prvý prvok z poľa.

Nech arr = ; arr.shift(); log konzoly (arr); // → ;

Musíte pochopiť, že pri použití metód shift a unshift každý prvok poľa mení svoj index. To môže spomaliť vykonávanie programu, ak je pole veľké.

rozdeliť

Metóda split() sa používa na transformáciu reťazca na pole. Split rozdelí reťazec (reťazec) podľa zadaného parametra.

Nech str = "Anya, Máša, Saša, Dáša"; // toto je reťazec nech arr = str.split(", "); log konzoly (arr); // → ["Anya", "Masha", "Sasha", "Dasha"] je pole

pripojiť sa

Metóda join() kombinuje prvky poľa do reťazca pomocou oddeľovača špecifikovaného v parametri.

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

plátok

Metóda slice() vytvorí nové pole, do ktorého skopíruje prvky zo zdroja, počnúc od prvku s indexom prvého parametra odovzdaného metóde až po prvok s indexom druhého parametra.

Napríklad: slice(3, 7) vráti prvky s indexmi 3, 4, 5, 6. Prvok s indexom 7 nebude zahrnutý do poľa.

Ak sa do slice() odovzdá parameter so zápornou hodnotou, vráti nové pole s počtom prvkov zadaným v parametri, ale už prevzatých z konca pôvodného poľa.

Metóda slice nemení pôvodné pole.

Tu je niekoľko príkladov toho, ako metóda slice() funguje:

Nech arr = ["A", "B", "C", "D", "E", "F", "G"]; // Vráti pole obsahujúce prvky s indexmi od 2 do 5 console.log(arr.slice(2, 5)); // → ["C", "D", "E"] // Vráti nové pole obsahujúce prvky s indexmi od 3 do arr.length console.log(arr.slice(3)); // → ["D", "E", "F", "G"] // Vráti kópiu pôvodného poľa console.log(arr.slice()); // → ["A", "B", "C", "D", "E", "F", "G"] // Vráti nové pole pozostávajúce z posledných troch prvkov pôvodného console.log (priem. rez (-3)); // → ["E", "F", "G"]

spájať

Metóda splice() upravuje obsah poľa odstránením existujúcich prvkov a/alebo pridaním nových.

Syntax:

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

Možnosti:

• začať- Index, pri ktorom sa má začať upravovať pole. Ak je väčšia ako dĺžka poľa, skutočný index bude nastavený na dĺžku poľa. Ak je záporné, určuje index prvku od konca.
• deleteCount- Celé číslo označujúce počet starých prvkov, ktoré sa majú z poľa odstrániť. Ak je deleteCount 0, neodstránia sa žiadne prvky. V tomto prípade musíte zadať aspoň jeden nový prvok. Ak je deleteCount väčší ako počet prvkov, ktoré zostali v poli, počnúc začiatkom indexu, potom budú odstránené všetky prvky až do konca poľa.
• položkaN- Voliteľné parametre. Prvky, ktoré sa majú pridať do poľa. Ak nešpecifikujete žiadny prvok, splice() jednoducho odstráni prvky z poľa.

Návratová hodnota

Popis

Ak sa počet prvkov špecifikovaných na vloženie líši od počtu prvkov, ktoré sa majú odstrániť, pole po volaní zmení dĺžku.

Nech arr = [Barca, Šachtar, Manchester United, Miláno, Real Madrid, Ajax, Juventus]; nech nax = arr.splice(2, 3); arr.splice(2, 3); log konzoly (nax); // → ["Man Utd", "Milan", "Real"] console.log(arr); // → ["Bary", "Šachtar"] arr.splice(1, 0, "Zenith", "CSKA", "Spartak"); log konzoly (arr); // → [Barca, Zenit, CSKA, Spartak, Šachtar]

obrátene

Metóda reverse() obráti poradie prvkov poľa. V dôsledku toho sa prvý prvok poľa stane posledným a posledný prvok prvým.

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

mapa

Metóda map() prechádza prvkami poľa, vykonáva s nimi zadané akcie a vracia kópiu poľa so zmenenými prvkami.

V nižšie uvedenom príklade pridajte pre každý prvok poľa hodnotu indexu tohto prvku (7 + 0, 2 + 1, 15 + 2, 4 + 3, 31 + 4):

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

alebo vynásobte každú hodnotu poľa, napríklad 12

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

filter

Metóda filter() sa používa na filtrovanie polí. Iteruje cez pole a vracia iba tie prvky, ktoré vyhovujú danej podmienke.

Napríklad filtrujeme hodnoty poľa z čísel, pričom ponecháme iba tie, ktoré sú väčšie ako 21

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

Upozorňujeme, že 21 nebolo zahrnuté vo výsledku poľa, pretože podmienkou bolo vrátiť niečo, čo je väčšie ako 21. Aby bolo 21 zahrnuté do poľa, potom je podmienka nastavená ako väčšia alebo rovná: prvok >= 21

znížiť

Metóda reduction() postupne prechádza prvkami poľa, pričom akumuluje medzivýsledok podľa akcie funkcie špecifikovanej v podmienke. V konečnom dôsledku vráti iba jednu hodnotu.

Táto metóda sa často používa na nájdenie súčtu všetkých čísel v poli. Príklad:

Nech arr = ; nech summa = arr.reduce((acc, element) => acc + element); konzolový denník (summa); // → 370

triediť

Metóda sort() sa používa na triedenie prvkov poľa podľa daných parametrov.

Príklad - vezmite pole čísel a zoraďte ich vo vzostupnom poradí:

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

zahŕňa

Metóda include() určuje, či pole obsahuje konkrétny prvok, pričom v závislosti od toho vracia hodnotu true alebo false.

Príklad použitia include() .

Tu je logické vyjadrenie:

Nech zviera = "pes"; if (zviera == "mačka" || zviera == "pes" || zviera == "lev" || zviera == "kôň") ( // ........ )

pomocou metódy include to môžete napísať takto:

Nech zviera = "pes"; const animals = ["mačka", "pes", "lev", "kôň"]; if (zvieratá.zahŕňa(zviera)) ( // ........... )

V tejto lekcii sa zoznámime s poľami, naučíme sa ich vytvárať, vykonávať operácie s ich prvkami a tiež zvážime hlavné metódy a vlastnosti dostupné pri práci s nimi.

Koncept poľa

Pole je usporiadaná kolekcia údajov, ktorá má názov a je inštanciou objektu Array. Pozostáva z prvkov, ku ktorým sa pristupuje podľa ich sériového čísla (indexu). Číslovanie prvkov v poli nezačína od 1, ale od 0.

Nasledujúci obrázok zobrazuje číselné pole so 7 prvkami. Prvky tohto poľa obsahujú nasledujúce údaje: 1. prvok (index 0) - číslo 123, 2. prvok (1. index) - číslo 214, 3. prvok (2. index) - číslo 315 atď.

//prvok, ktorému zobrazíme pole

Vytvorenie (deklarovanie) poľa

Vytvorenie poľa v JavaScripte sa vykonáva pomocou operátora new a funkcie konštruktora poľa. V zátvorkách funkcie konštruktora poľa môžete zadať jednu z nasledujúcich hodnôt:

• číslo. V tomto prípade táto funkcia vytvorí pole pozostávajúce zo zadaného počtu prvkov. Všetky tieto prvky budú mať nedefinované hodnoty.
• Viaceré hodnoty oddelené čiarkami. V tomto prípade funkcia konštruktora Array vytvorí pole zo zadaného počtu prvkov a priradí im príslušné hodnoty.
• nič. V tomto prípade táto funkcia vytvorí prázdne pole.

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

Práca s prvkami poľa

Aby ste mohli odkazovať na konkrétny prvok poľa, musíte zadať názov tohto poľa a jeho index v hranatých zátvorkách. Táto operácia sa tiež nazýva operácia indexovania.

Napríklad vytvorte prázdne pole a pridajte doň 4 textové prvky:

//vytvor prázdne pole smartphoneColors var smartphoneColors = new Array(); //nastaví prvok poľa 1 (index 0) na "Black" smartphoneColors = "Black"; //nastaví prvok poľa 2 (index 1) na "White" smartphoneColors = "White"; //nastaví prvok poľa 3 (index 2) na "Grey" smartphoneColors = "Grey"; //nastaví prvok poľa 4 (index 3) na "Blue" smartphoneColors = "Blue";

Napríklad zobrazme hodnoty 2 a 4 prvku poľa smartphoneColors v konzole prehliadača (F12):

Console.log("2 element = " + farby smartfónu); console.log("Prvok 4 = " + farby smartfónu);

Dĺžka poľa (počet prvkov v poli)

Počet prvkov v poli je určený pomocou vlastnosti length.

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

Ako získať prvý prvok poľa

Hodnota prvého prvku poľa sa získa zadaním čísla 0 v hranatých zátvorkách tohto poľa:

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

Ako získať posledný prvok poľa

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

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

Iterácia cez pole

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

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

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

Aký je účel operátora vymazania

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

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

Metódy objektov poľa

Objekt Array obsahuje nasledujúce metódy na prácu s prvkami poľa: pop() , push() , shift() , unshift() , slice() , splice() , join() , split() , reverse() , sort () .

Odstránenie posledného prvku poľa - pop

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

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

Pridanie prvku na koniec poľa - push

Metóda push slúži na pridanie prvku na koniec poľa. Hodnota tohto prvku je špecifikovaná ako parameter tejto metódy. Výsledkom je, že metóda push vracia počet prvkov v poli, pričom berie do úvahy pridaný.

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

Odstránenie prvého prvku poľa - shift

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

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

Pridanie prvku na začiatok poľa - unshift

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

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

Kopírovanie prvkov poľa - rez

Metóda slice je navrhnutá tak, aby kopírovala zadané prvky poľa. Táto metóda nemení pôvodné pole, ale ako výsledok vráti nové pole pozostávajúce zo skopírovaných prvkov.

Metóda rezu má 2 parametre:

• 1 parameter (povinný) - používa sa na určenie indexu prvku, od ktorého sa má začať kopírovať prvky;
• 2. parameter (voliteľný) – slúži na určenie indexu prvku, do ktorého chcete kopírovať. Ak nie je zadaný, prvky sa skopírujú na koniec zadaného poľa.

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

Pridávanie a (alebo) odoberanie prvkov - spoj

Metóda spájania je určená na pridávanie a (alebo) odstraňovanie prvkov poľa.

1. Metóda spájania umožňuje vystrihnúť niektoré jej prvky z poľa, t.j. budú odstránené z poľa:

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

2. Metóda spájania vám tiež umožňuje pridávať (ak je parameter 2 0) prvky do poľa alebo súčasne pridávať a odstraňovať (ak je parameter 2 väčší ako 0) prvky poľa.

Táto metóda má 3 parametre:

• 1 parameter (povinný) - slúži na určenie indexu prvku, z ktorého začíname rezať prvky;
• 2. parameter (povinný) - používa sa na určenie počtu prvkov, ktoré sa majú vyrezať;
• 3 a následné parametre (voliteľné) - sú určené na pridávanie prvkov do poľa.

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

Previesť pole na reťazec - spojiť

Metóda join slúži na konverziu poľa na reťazec. Táto metóda má parameter, ktorý sa používa ako spojovací reťazec medzi prvkami poľa pri ich konverzii na reťazec. Ak ako parameter nie je zadané nič, na spojenie prvkov poľa sa použije čiarka ("").

Var namePlanets = new Array("Venuša","Merkúr","Zem","Mars"); var strPlanets = namePlanets.join(); console.log("String: " + strPlanets); var strPlanets2 = namePlanets.join(" "); console.log("String: " + strPlanets2);

Previesť reťazec na pole - rozdeliť

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

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

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

Opačná metóda slúži na zmenu poradia prvkov poľa v opačnom poradí.

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

Triedenie prvkov poľa - triedenie

Metóda triedenia slúži na triedenie prvkov poľa. Štandardne táto metóda triedi pole ako reťazce.

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