odstrániť konkrétny prvok poľa js (20)

Existuje spôsob, ako odstrániť položku z Pole JavaScript?

Vzhľadom na pole:

Var ary = ["tri", "sedem", "jedenásť"];

Chcel by som urobiť niečo ako:

RemoveItem („sedem“, ary);

Pozrel som sa na splice (), ale to len odstráni číslo pozície, zatiaľ čo niečo potrebujem na odstránenie prvku podľa jeho hodnoty.

// upravené vďaka MarcoCI za radu

skúste to:

Funkcia wantDelete (položka, arr) (pre (var i = 0; i

dúfam, že vám to pomôže

Nechaj commentsWithoutDeletedArray = commentsArray.filter ((komentár) =>! (Comment.Id === commentId));

Tu je verzia, ktorá používa funkciu jQuery inArray:

Var index = $ .inArray (položka, pole); if (index! = -1) (array.splice (index, 1);)

Môžete to dosiahnuť pomocou funkcie Lodash _.odstrániť.

var pole = ["tri", "sedem", "jedenásť"]; var evens = _.remove (pole, funkcia (e) (návrat e! == "sedem";)); console.log (dokonca);

Const _ = require ("lodash"); _.bez (, 2); // ->

Skutočne nerozumiem, prečo sa to nedá vyriešiť

Arr = arr.filter (hodnota => hodnota! == "sedem");

Alebo možno budete chcieť použiť vanilla JS

Arr = arr.filter (funkcia (hodnota) (návratová hodnota! == "sedem"));

Ďalší variant:

If (! Array.prototype.removeArr) (Array.prototype.removeArr = function (arr) (if (! Array.isArray (arr)) arr =; // Buďme milí k ľuďom, ktorí uvádzajú hodnotu bez poľa tu .. to by som mohol byť ja! var to = toto; ak (dĺžka dĺžky) (var i = 0; zatiaľ čo (i -1) (to.splice (i, 1);) inak i ++; )) vrátiť to; )))

Toto je opäť indexOf () vo vnútri slučky, ale za predpokladu, že pole, ktoré sa má odstrániť, je relatívne k poľu, ktoré sa má vyčistiť; každé odstránenie skracuje cyklus while.

To vám umožní vykonávať nasledujúce činnosti:

Var ary = ["tri", "sedem", "jedenásť"]; var aryWithoutSeven = ary.filter (funkcia (hodnota) (návratová hodnota! = "sedem")); console.log (aryWithoutSeven); // vráti ["tri", "jedenásť"]

Toto bolo tiež zaznamenané v tomto vlákne niekde inde: https: //.com/a/20827100/293492

Nepoužívajte možnosť odstránenia - urobí to dieru v poli, pretože nedeindexuje prvky po odstránenom prvku.

> Array.prototype.remove = funkcia (v) (... vymazať toto ...); > var myarray = ["3", "24", "55", "2"]; nedefinované> myarray.remove ("55"); nedefinované> myarray ["3", "24", "2"]

Jedna vložka to zvládne

Var ary = ["tri", "sedem", "jedenásť"]; // Odstráňte položku „sedem“ z poľa var filterAry = ary.filter (funkcia (e) (návrat e! == „sedem“)) // => [„tri“, „jedenásť“] // V ECMA6 (šípka syntax funkcie): var filterAry = ary.filter (e => e! == "sedem")

Toto používa funkciu filtra v JS. Je podporovaný v IE9 a novších verziách.

filter () volá poskytnutú funkciu spätného volania raz pre každý prvok v poli a vytvorí nové pole zo všetkých hodnôt, pre ktoré spätné volanie vráti hodnotu, ktorá je vyhodnotená ako true. spätné volanie sa volá iba pre indexy polí, ktorým boli priradené hodnoty; nevolá sa pre indexy, ktoré boli zrušené alebo ktorým neboli nikdy priradené hodnoty. Prvky poľa, ktoré neprešli testom spätného volania, sa jednoducho preskočia a nezahrnú do nového poľa.

Je teda v zásade rovnaký ako všetky ostatné riešenia (var key v ary) (...), ibaže in je podporovaný ako IE6.

V zásade je filter pohodlnou metódou, ktorá vyzerá oveľa lepšie (a je reťazená), na rozdiel od príkazu for in constructor (AFAIK).

Skontroluj to:

Pre (var i v poli) (ak (pole [i] == "sedem") (pole.splice (i, 1); zlom;))

a vo funkcii:

Funkcia removeItem (pole, položka) (pre (var i v poli) (if (pole [i] == položka) (pole.splice (i, 1); zlom;))) removeItem (pole, "sedem");

Odstránenie všetkých zhodných prvkov z poľa (nielen prvý sa zdá byť najobecnejšou odpoveďou tu):

Kým ($ .inArray (položka, pole)> -1) (pole.splice ($. InArray (položka, pole), 1);)

Použil som jQuery na tvrdú prácu, ale dostanete predstavu, ak chcete ísť do rodného jazyka.

Ide o to, previesť sa poľom od začiatku do začiatku, aby ste pri odstraňovaní prvkov nepoškodili indexy.

Var deleteMe = function (arr, me) (var i = arr.length; while (i--) if (arr [i] === me) arr.splice (i, 1);) var arr = ["orange "," červená "," čierna "," oranžová "," biela "," oranžová "]; deleteMe (arr, "oranžová");

arr je teraz ["červená", "čierna", "biela"]

Funkcia cleanArrayOfSpecificTerms (pole, nežiaduceTermsArray) ($ .each (nežiaduceTermsArray, funkcia (index, hodnota) (var index = pole.indexOf (hodnota); if (index> -1) (pole.splice (index, 1);)) ); vrátiť pole;)

Ak chcete použiť, postupujte nasledovne:

Var notInclude = ["Not", "No", "First", "Last", "Prior", "Next", "dogs", "cats"]; var splitTerms = ["hovor", "denník", "psy", "mačky", "téma", "zmena", "cena"]; cleanArrayOfSpecificTerms (splitTerms, notInclude)

Skúsil som použiť funkčnú metódu z vyššie uvedeného jbaron, ale zistil som, že pôvodné pole musím zachovať nezmenené pre neskoršie použitie a vytvoriť nové pole takto:

Var newArray = referenceArray;

Funkcia newArrRemoveItem (pole, položka, newArray) (pre (var i = 0; i< array.length; i++) { if(array[i]!=item){ newArray.push(array[i]); } } }

Potom to použijem takto:

Var shipID = record.get ("VesselID"); var otherVessels = new Array (); newArrRemoveItem (shipArr, shipID, otherVessels);

Teraz shipArr zostáva nedotknutý a vždy, keď spustím vyššie uvedený kód, pole otherVessels obsahuje všetko okrem posledného prvku CAID.

indexOf je možnosť, ale jeho implementácia v zásade hľadá hodnotu v celom poli, takže runtime rastie s veľkosťou poľa. (tak je to v každom prehliadači, myslím, že som testoval iba Firefox).

Nemám IE6 na kontrolu, ale nazval by som to stávkou na istotu, že týmto spôsobom môžete skontrolovať najmenej milión prvkov poľa za sekundu na takmer akomkoľvek klientskom počítači. Ak [veľkosť poľa] * [vyhľadávania za sekundu] môže narásť nad milión, mali by ste zvážiť inú implementáciu.

V zásade môžete použiť objekt na vytvorenie indexu pre svoje pole, napríklad:

Var index = ("tri": 0, "sedem": 1, "jedenásť": 2);

Akýkoľvek normálny rámec JavaScript vytvorí pre tieto objekty index vyhľadávania, aby ste mohli rýchlo preložiť kľúč k hodnote bez ohľadu na to, koľko vlastností daný objekt má.

Toto je len základná metóda, v závislosti od vašich potrieb môžete skombinovať viacero objektov a / alebo polí, aby ste v rovnakých dátach mohli rýchlo vyhľadávať rôzne vlastnosti. Ak uvediete svoje konkrétne potreby, môžem navrhnúť konkrétnejšiu štruktúru údajov.

// Táto funkcia umožňuje odstrániť párne pole z poľa var removeFromArr = funkcia (arr, elem) (var i, len = arr.length, new_arr =, sort_fn = function (a, b) (return a - b;); for ( i = 0; i< len; i += 1) { if (typeof elem === "object" && typeof arr[i] === "object") { if (arr[i].toString() === elem.toString()) { continue; } else { if (arr[i].sort(sort_fn).toString() === elem.sort(sort_fn).toString()) { continue; } } } if (arr[i] !== elem) { new_arr.push(arr[i]); } } return new_arr; }

Príklad použitia

Var arr =, "abc", 1, "1", 1]; removeFromArr (arr, 1); // ["2" ,, "abc", "1"] var arr = [, 2, "a" ,,]; removeFromArr (arr,); //]

Nechajte arr =; console.log (arr); // vysledok nech index = arr.indexOf (30); if (index> -1) (arr.splice (index, 1);) console.log (arr); // vysledok

Var index = pole.indexOf ("položka"); if (index! = - 1) (array.splice (index, 1);)

smena

Na odstránenie prvého prvku poľa použite .shift.

Napríklad:

Var pole =; array.shift ();

výsledky poľa v:

Napríklad:

Var pole =; array.pop ();

výsledky poľa v:

Oba spôsoby vrátia odstránenú položku;

spoj

Použite.splice () na odstránenie série prvkov z poľa. Na odstránenie .splice () sú potrebné dva parametre, počiatočný index a voliteľná mohutnosť. Ak druhý parameter nie je, splice () odstráni všetky prvky z počiatočného indexu na konci poľa.

Napríklad:

Var pole =; pole.splice (1, 2);

zanecháva pole obsahujúce:

Návrat poľa.splice () je nové pole obsahujúce odstránené prvky. Vo vyššie uvedenom príklade bude návratnosť:

Vynechanie druhého parametra teda efektívne rozdelí pole na dve polia, pričom pôvodné končí až do zadaného indexu:

Var pole =; pole.splice (2);

Zanechá pole obsahujúce a vráti sa.

vymazať

Na odstránenie prvku z poľa bez zmeny dĺžky poľa použite kláves Delete:

Var pole =; console.log (array.length); // 5 vymazať pole; console.log (pole); // console.log (array.length); // 5

Pole.prototyp.dĺžka

Priradením hodnoty k dĺžke poľa sa dĺžka zmení o zadanú hodnotu. Ak je nová hodnota menšia ako dĺžka poľa, prvky budú z konca hodnoty odstránené.

Pole =; array.length = 2; console.log (pole); //

V. Javascript odstráni prvok poľa môžete použiť niekoľko spôsobov. Patria sem metódy pop a shift. Metóda pop odstráni prvý prvok z daného poľa. Metóda shift odstráni posledný prvok z daného poľa.

Dĺžku poľa môžete nastaviť na 0, ak chcete z daného poľa odstrániť všetky prvky. Ale čo, potrebujete odstrániť konkrétny prvok?

Napríklad:

Array_name.splice (index);

Array_name.delete

Je možné použiť metódu spájania. Vráti nové pole odstránených prvkov. A pôvodné pole obsahuje zostávajúce prvky.

V nižšie uvedenej ukážke sa dozviete, ako používať metódu spájania JavaScript a ďalšie spôsoby odstraňovania konkrétnych prvkov.

Ukážka odstránenia konkrétneho prvku pomocou metódy spojenia

Toto demo vytvára množstvo čísel. Na začiatku sa do poľa pridá päť prvkov. Metóda spojenia sa potom použije na odstránenie tretej položky. Podobne v JavaScripte môžete odstrániť prvý prvok poľa.

Prvky numerického poľa sa zobrazujú pred a po použití Metóda JavaScript spojte nasledovne:

JavaScript kód s metódou spájania:

Všimli ste si, že na odstránenie prvku poľa som použil dva parametre pre JavaScript. Prvá označuje index prvku, ktorý sa má odstrániť. Druhým je, koľko prvkov odstrániť po zadanom kľúči.

Nasledujúce demo ukazuje prípad, keď používame druhý parameter.

Čo keď druhý parameter nie je uvedený v metóde spájania JavaScript?

Použitie rovnakého kódu, ale bez druhého parametra v metóde spájania:

Arr_Numbers.splice (2);

Kód a výsledok:

Pozrite si online ukážku a kód

Ako vidíte, aj tu boli odstránené všetky položky pred uvedeným indexovým číslom. Metóda spájania navyše vráti pole odstránených položiek.

JavaScript kód:

Použitie funkcie odstrániť na odstránenie prvku poľa

Na vymazanie prvku v poli v JavaScripte môžete použiť aj funkciu vymazania. Šetrí však prázdne miesto a ak toto pole po použití funkcie vrátite, odstránený prvok sa zobrazí ako nedefinovaný.

Pozrime sa na demo verziu, ktorá používa funkciu odstránenia:

Pozrite si online ukážku a kód

JavaScript kód:

Môžete vidieť, že pre tretí prvok sa zobrazí nedefinovaný po jeho odstránení pomocou funkcie vymazania.

JavaScript vymazať operátora odstráni vlastnosť z objektu; ak nie sú k dispozícii žiadne ďalšie referencie na ten istý majetok, nakoniec sa automaticky uvoľní.

Zdroj pre tento interaktívny príklad je uložený v úložisku GitHub. Ak by ste chceli prispieť k projektu interaktívnych príkladov, naklonujte https://github.com/mdn/interactive-examples a pošlite nám žiadosť o stiahnutie.

Syntax

vymazať výraz

Akákoľvek premenná definovaná pomocou var je označená ako nekonfigurovateľná. V nasledujúcom príklade je plat nekonfigurovateľný a nemožno ho vymazať. V nie striktnom režime sa operáciou odstránenia vráti hodnota false.

Funkcia Zamestnanec () (vymazať plat; var plat;) Zamestnanec ();

Pozrime sa, ako sa ten istý kód správa v striktnom režime. Namiesto vrátenia hodnoty false vyvolá príkaz SyntaxError.

„používať prísne“; funkcia Employee () (vymazať plat; // SyntaxError var plat;) // Podobne akýkoľvek priamy prístup k funkcii // s odstránením zvýši funkciu SyntaxError DemoFunction () (// nejaký kód) delete DemoFunction; // Chyba syntaxe

Príklady

// Vytvorí vlastnosť adminName v globálnom rozsahu. adminName = "xyz"; // Vytvorí vlastnosť empCount v globálnom rozsahu. // Pretože používame var, je toto označené ako nekonfigurovateľné. To isté platí pre let a const. var empCount = 43; EmployeeDetails = (meno: "xyz", vek: 5, označenie: "Vývojár"); // adminName je vlastnosť globálneho rozsahu. // Dá sa odstrániť, pretože je vytvorený bez var, // a je teda konfigurovateľný. odstrániť adminName; // vracia true // Naopak, empCount nie je možné konfigurovať //, pretože bol použitý var. vymazať empCount; // vráti false // delete je možné použiť na odstránenie vlastností z objektov. odstrániť EmployeeDetails.name; // vráti true // Aj keď vlastnosť neexistuje, vráti príkaz „true“. odstrániť EmployeeDetails.salary; // vráti true // delete nemá vplyv na vstavané statické vlastnosti. odstrániť Math.PI; // vráti false // EmployeeDetails je vlastnosťou globálneho rozsahu. // Pretože bol definovaný bez "var", je označený ako konfigurovateľný. odstrániť EmployeeDetails; // vráti true funkciu f () (var z = 44; // zmazanie neovplyvní názvy miestnych premenných delete z; // vráti false)

odstrániť a reťazec prototypu

V nasledujúcom príklade odstránime vlastnú vlastnosť objektu, kým je v prototypovom reťazci k dispozícii vlastnosť s rovnakým názvom:

Funkcia Foo () (this.bar = 10;) Foo.prototype.bar = 42; var foo = nové Foo (); // foo.bar je spojený s // vlastnou vlastnosťou. console.log (foo.bar); // 10 // Vymažte vlastnú vlastnosť v rámci // foo objektu. odstrániť foo.bar; // vráti true // foo.bar je v reťazci // prototyp stále k dispozícii. console.log (foo.bar); // 42 // Odstráňte vlastnosť na prototype. odstrániť Foo.prototype.bar; // vráti true // Vlastnosť "bar" už nemožno // zdediť od Foo, pretože bola // odstránená. console.log (foo.bar); // nedefinované

Odstránenie prvkov poľa

Keď odstránite prvok poľa, dĺžka poľa nebude ovplyvnená. To platí, aj keď vymažete posledný prvok poľa.

Keď operátor odstránenia odstráni prvok poľa, tento prvok už v poli nie je. V nasledujúcom príklade sú stromy odstránené odstránením.

Var stromy = ["sekvoja", "zátoka", "céder", "dub", "javor"]; odstrániť stromy; if (3 na stromoch) (// toto sa nevykoná)

Ak chcete, aby prvok poľa existoval, ale mal nedefinovanú hodnotu, použite namiesto operátora vymazania nedefinovanú hodnotu. V nasledujúcom príklade je stromom priradená nedefinovaná hodnota, ale prvok poľa stále existuje:

Var stromy = ["sekvoja", "zátoka", "céder", "dub", "javor"]; stromy = nedefinované; if (3 na stromoch) (// toto sa vykoná)

Ak namiesto toho chcete odstrániť prvok poľa zmenou obsahu poľa, použite metódu spojenia. V nasledujúcom príklade sú stromy z poľa úplne odstránené pomocou spojenia:

Var stromy = ["sekvoja", "zátoka", "céder", "dub", "javor"]; stromy.splice (3,1); console.log (stromy); // ["sekvoja", "zátoka", "céder", "javor"]

technické údaje

Špecifikácia	Postavenie	Komentovať
Najnovší návrh ECMAScript (ECMA-262)	Návrh
ECMAScript 2015 (6. vydanie, ECMA-262) Definícia „Operátora odstránenia“ v tejto špecifikácii.	Štandardné
ECMAScript 5.1 (ECMA-262) Definícia „Operátora odstránenia“ v tejto špecifikácii.	Štandardné
1. vydanie ECMAScript (ECMA-262) Definícia „Operátora odstránenia“ v tejto špecifikácii.	Štandardné	Počiatočná definícia. Implementované v JavaScripte 1.2.

Kompatibilita s prehliadačom

Tabuľka kompatibility na tejto stránke je generovaná zo štruktúrovaných údajov. Ak by ste chceli prispieť k údajom, navštívte stránku https://github.com/mdn/browser-compat-data a pošlite nám žiadosť o stiahnutie.

Aktualizujte údaje o kompatibilite na GitHub

	Pracovná plocha						Mobilné						Server
	Chrome	Hrana	Firefox	internet Explorer	Opera	Safari	Webview v systéme Android	Chrome pre Android	Firefox pre Android	Opera pre Android	Safari v systéme iOS	Internet Samsung	Node.js
vymazať	Plná podpora prehliadača Chrome 1	Úplná podpora Edge 12	Plná podpora Firefoxu 1	IE Plná podpora 4	Opera Plná podpora Áno	Safari Plná podpora Áno	WebView Android Plná podpora 1	Chrome Android Plná podpora 18	Firefox Android Plná podpora 4	Opera Android Plná podpora Áno	Safari iOS Plná podpora Áno	Samsung Internet Android Plná podpora 1.0	nodejs Plná podpora Áno

Legenda

Plná podpora Plná podpora

Poznámky medzi prehliadačmi

Hoci ECMAScript robí poradie iterácií objektov závislými na implementácii, môže sa zdať, že všetky hlavné prehliadače podporujú poradie iterácií na základe najskôr pridanej vlastnosti (aspoň pre vlastnosti, ktoré nie sú na prototype). V prípade programu Internet Explorer však pri použití vlastnosti delete vo vlastníctve dôjde k mätúcemu správaniu, ktoré bráni iným prehliadačom používať jednoduché objekty ako literály objektov ako usporiadané asociatívne polia. V Prieskumníkovi, zatiaľ čo vlastnosť hodnotu je skutočne nastavený na nedefinovaný, ak neskôr niekto pridá vlastnosť s rovnakým názvom, bude nehnuteľnosť iterovaná vo svojom starý pozícia - nie na konci sekvencie iterácií, ako by sa dalo očakávať po vymazaní vlastnosti a následnom pridaní späť.

Opísal som iba časť metód pre prácu s poľami.

Tu budeme hovoriť o pridávaní a odstraňovaní prvkov poľa. O invertovaní a triedení poľa, ako aj o krájaní, výmene a kombinovaní polí.

Pridávanie prvkov do poľa.

Vlastnosť length môžete použiť na pridanie nových prvkov do poľa:

Var myArray = [„Apple“, „Microsoft“, „Google“, „Facebook“]; myArray = "Yahoo!"; console.log (myArray); // [„Apple“, „Microsoft“, „Google“, „Facebook“, „Yahoo!“ “]

Bude to fungovať, pretože prvky poľa sú očíslované od nuly a dĺžka ešte jeden. Dĺžka vždy ekvivalentné index + 1 preto je veľmi jednoduché pridať nový prvok na koniec poľa. Zvláštne, ale prvok môžete pridať na pozíciu, ktorá je oveľa väčšia ako dĺžka samotného poľa:

Var myArray = ["Jimi Hendrix", "Eric Clapton", "Jimmy Page", "Keith Richards"]; myArray = "Lindsey Buckingham"; console.log (myArray); // ["Jimi Hendrix", "Eric Clapton", "Jimmy Page", "Keith Richards", nedefinované × 95, "Lindsey Buckingham"] console.log (myArray.length); // 100

Ako je uvedené v komentároch, na koniec poľa bude pridaných 95 prázdnych slotov a prvok „Lindsey Buckingham“. Potom získame dĺžku 100. Ďalším spôsobom, ako pridať nový prvok do poľa, je použiť metódu tlačiť ():

Var myArray = ["Paul McCartney", "John Lennon", "George Harrison"]; myArray.push („Ringo Starr“, „George Martin“); console.log (myArray); // [„Paul McCartney“, „John Lennon“, „George Harrison“, „Ringo Starr“, „George Martin“]

Metóda tlačiť () vždy vráti novú dĺžku poľa (v našom prípade 5). Položku môžete pridať pomocou spoj ():

Var myArray = ["žaluď", "buk", "mongongo", "macadamia"]; myArray.splice (2, 0, "kešu"); // prida "cashew" do indexu 2 console.log (myArray); // ["žaluď", "buk", "kešu", "mongongo", "macadamia"]

Keď je druhý argument 0, znamená to, že žiadny prvok nebude odstránený, a preto budú všetky nasledujúce argumenty pridané do poľa na mieste určenom v prvom argumente.

Odstraňovanie prvkov z poľa

Odstránenie prvku je o niečo ťažšie ako jeho pridanie. Na odstránenie prvku z konca poľa je možné použiť pop ():

Var myArray = ["7-up", "Sprite", "Ginger Ale", "Lemonade"]; myArray.pop (); console.log (myArray); // ["7-up", "Sprite", "Ginger Ale"]

Metóda pop () vždy odstráni posledný prvok v poli a vráti ho.

Môžete tiež použiť spojka () metóda:

Var myArray = ["kasava", "muškátový oriešok", "vlčí bôb", "rebarbora"]; myArray.splice (2, 1); // odstránenie prvku na indexe 2 console.log (myArray); // ["maniok", "muškátový oriešok", "rebarbora"]

Na rozdiel od metódy spojka (), ktorý slúži na pridávanie prvkov, tu je druhý argument 1, ktorý hovorí, že chceme odstrániť prvok s indexom 2 (alebo 3. v poradí). V tomto prípade bol prvok "vlčí bôb" odstránený.

Prvok poľa môžete odstrániť pomocou operátora vymazať:

Var myArray = ["Byte Bandit", "Eliza", "Jeefo", "Michelangelo"]; console.log (myArray.length); // 4 vymazať myArray; // odstránenie Eliza console.log (myArray.length); // 4 console.log (myArray); // ["Byte Bandit", nedefinované × 1, "Jeefo", "Michelangelo"]

Prvá dôležitá poznámka: vymazať () nemení dĺžku poľa po odstránení prvku (aj keď to bol posledný prvok v poli). Za druhé: vymazať () zmení hodnotu odstráneného prvku na nedefinovanú, takže pri cúvaní myArray = nedefinované.

Dobrý spôsob, ako odstrániť prvok z poľa, je použiť pole Johna Resiga Array.remove. Nasleduje príklad použitia prevzatý z jeho stránky:

// Odstránenie poľa - John Resig (licencovaný MIT) Array.prototype.remove = funkcia (od, do) (var rest = this.slice ((do || od) + 1 || this.length); this.length = od< 0 ? this.length + from: from; return this.push.apply(this, rest); }; // Удаление 2 элемента из массива array.remove(1); // Удаление 2-ого элемента с конца массива array.remove(-2); // Удаление второго и третьего элемента array.remove(1,2); // Удаление последнего и предпоследнего элемента array.remove(-2,-1);

Môžete sa pozrieť na riešenie od Viral Patel, jednej z funkcií v programe Underscore.js alebo grep () jQuery.

Navyše v JavaScript existuje metóda smena (), ktorý odstráni prvý prvok v poli a vráti jeho hodnotu. Pozrime sa na kód:

Var myArray = ["Matt Kramer", "Jason Bieler", "Tom Defile", "Phil Varone"]; console.log (myArray.length); // 4 var firstItem = myArray.shift (); console.log (firstItem); // Matt Kramer console.log (myArray.length); // 3 console.log (myArray); // ["Jason Bieler", "Tom Defile", "Phil Varone"]

Použitie metódy smena () položku sme odstránili, ale uložili sme jej hodnotu do našej premennej firstItem. Dĺžka poľa sa zmenila zo 4 na 3.

Táto metóda môže byť užitočná v spojení s touto metódou tlačiť (). Ich spoločným použitím môžeme efektívne zaradiť prvky do radu. Dĺžku poľa zachováme tak, že odstránime prvok zo začiatku a na koniec pridáme nový.

Metódu naopak môžeme použiť zrušiť posun () pridať prvok na začiatok poľa:

Var myArray = ["apito", "kastanety", "maraca"]; console.log (myArray.length); // 3 myArray.unshift ("zvonkohra", "tan-tan"); console.log (myArray.length); // 5 console.log (myArray); // ["zvonkohra", "tan-tan", "apito", "kastanety", "maraca"]

Použitie metódy zrušiť posun () s metódou pop (), môžete zaradiť do frontu dozadu pridaním prvkov na začiatok a odstránením z konca poľa.

Zvrat a triedenie prvkov poľa.

Na prevrátenie prvkov v poli môžeme použiť obrátiť ():

Var myArray = ["odpočítavanie", "konečné", "" "; console.log (myArray); // ["countdown", "final", "the"] myArray = myArray.reverse (); console.log (myArray); // ["posledné odpočítavanie"]

Pomocou metódy je možné triediť prvky poľa podľa abecedy triediť ():

Var myArray = ["xylofóny", "zebry", "juggernauts", "avokádo"]; console.log (myArray); // ["xylofóny", "zebry", "juggernauts", "avokádo"] myArray = myArray.sort (); console.log (myArray); // ["avokádo", "juggernauts", "xylofóny", "zebry"]

Ale s číslami to nepôjde.

Var myArray =; console.log (myArray); // myArray = myArray.sort (); console.log (myArray); //

Ak potrebujete zoradiť čísla, môžete použiť nasledujúci kód:

Porovnanie funkciíČísla (a, b) (návrat a - b;) var myArray =; console.log (myArray); // myArray = myArray.sort (compareNumbers); console.log (myArray); //

Ako je uvedené vyššie, s vloženou jednoduchou funkciou triediť (), pole obsahujúce čísla bude zoradené správne.

Kombinácia polí.

Môžete zreťaziť 2 alebo viac polí a získať 1 pole, ktoré obsahuje prvky zreťazených polí. Na tento účel používame metódu concat ():

Var myArray = ["Jay Ferguson", "Andrew Scott"]; var myArray2 = ["Chris Murphy", "Patrick Pentland"]; var myNewArray = myArray.concat (myArray2); console.log (myNewArray); // ["Jay Ferguson", "Andrew Scott", "Chris Murphy", "Patrick Pentland"]

Var myArray = ["Jay Ferguson", "Andrew Scott"]; var myNewArray = myArray.concat ("Chris Murphy", "Patrick Pentland"); console.log (myNewArray); // ["Jay Ferguson", "Andrew Scott", "Chris Murphy", "Patrick Pentland"]

Rozdelenie poľa.

Pomocou funkcie môžete vytvoriť nové pole obsahujúce 1 alebo viac prvkov z existujúceho poľa plátok ():

Var myArray = [„spev“, „basa“, „gitara“, „bicie“, „jablká“, „pomaranče“]; var myNewArray = myArray.slice (4); console.log (myNewArray); // ["Jablká", "Pomaranče"]

Metóda plátok () trvá 1 alebo 2 argumenty. Ak prejde 1 argument (index), vytvorí sa nové pole zo všetkých prvkov starého, začínajúc od daného indexu. Ak sú odovzdané 2 argumenty, vytvorí sa nové pole od prvkov začínajúcich od prvého argumentu až po prvok v indexe odovzdaný v druhom parametri, pričom nezahŕňa posledný. Aby to bolo jasnejšie, pozrime sa na kód nižšie:

Var myArray = [„spev“, „basa“, „gitara“, „bicie“, „jablká“, „pomaranče“]; var myNewArray = myArray.slice (0, 4); console.log (myNewArray); // [„spev“, „basa“, „gitara“, „bicie“]

Výmena prvkov v poli.

Používame spojka () na odstránenie prvkov z poľa, ale prvok v poli môžeme tiež nahradiť novými prvkami:

Var myArray = ["Rivers Cuomo", "Patrick Wilson", "Brian Bell", "Matt Sharp"]; myArray.splice (3, 1, „Scott Shriner“); // nahradenie 1 prvku indexom 3 console.log (myArray); // [„Rivers Cuomo“, „Patrick Wilson“, „Brian Bell“, „Scott Shriner“]

Metóda spojka () vždy vráti pole obsahujúce prvky, ktoré boli odstránené. Riadok 2 vráti 1 položku „Brian Bell“.

Záver

Tieto články popísali metódy práce s poľami v JavaScripte. Na MDN je možné zobraziť niektoré ďalšie prvky, ktoré som do tohto príspevku nezahrnul. Fungujú iba v IE9 +, takže nemusia byť užitočné.

Niečo dodať? Alebo poznáte nejakú zaujímavú knižnicu, ktorá vám pomôže so správou polí? Prosím komentuj!