Javascript - elemente - eliminați un element specific dintr-o matrice js. Javascript - specific - Cum se elimină un element dintr-o matrice după valoare? Js elimină obiectul din matrice



Cum pot elimina un anumit element dintr-o matrice din JavaScript? (douăzeci)

Am o serie de numere întregi și folosesc metoda .push () pentru a adăuga elemente la ea.

Există o modalitate ușoară de a elimina un anumit element dintr-o matrice? Echivalent cu ceva de genul array.remove (int); ,

Trebuie să folosesc baza JavaScript - nici unul nu sunt permise cadre.

ES6 și fără mutație: (oct 2016)

const removeByIndex = (list, index) => [... list.slice (0, index), ... list.slice (index + 1)];

RemoveByIndex (, 1) // =>

Editat în octombrie 2016

  • Faceți-o simplă, intuitivă și explicită (https://en.wikipedia.org/wiki/Occam%27s_razor)
  • Faceți-l neschimbat (matricea originală va rămâne neschimbată)
  • Faceți acest lucru cu funcțiile standard JS dacă browserul dvs. nu le acceptă - folosiți poliampletarea

În acest exemplu de cod, îl folosesc funcție array.filter (...) " pentru a elimina elementele inutile dintr-o matrice, această funcție nu schimbă matricea originală și creează una nouă. Dacă browserul dvs. nu acceptă această caracteristică (de exemplu, IE înainte de versiunea 9 sau Firefox înainte de versiunea 1.5), luați în considerare utilizarea filtru polyfill de la Mozilla .

Eliminarea unui element (codul ECMA-262 Ediția 5, denumit și oldstyle JS)

var valoare = 3 var arr = arr = arr.filter (function (item) (return item! == value)) console.log (arr) // [1, 2, 4, 5]

Ștergeți articolul (cod ES2015)

let value = 3 let arr = arr = arr.filter (item => item! == value) console.log (arr) // [1, 2, 4, 5]

IMPORTANT ES2015 "() => ()" Sintaxa funcției săgeată nu este deloc acceptată în IE, Chrome înainte de versiunea 45, Firefox înainte de versiunea 22, Safari înainte de versiunea 10. Pentru a utiliza sintaxa ES2015 în browsere mai vechi, puteți utiliza BabelJS

Eliminarea mai multor articole (cod ES2016)

Un avantaj suplimentar al acestei metode este că puteți elimina mai multe articole

Let forDeletion = let arr = arr = arr.filter (item =>! ForDeletion.includes (item)) // !!! Citiți mai jos despre array.include (...) asistență !!! console.log (arr) // [1, 4]

IMPORTANT„array.includes (...)” nu este deloc acceptat în IE, Chrome înainte de versiunea 47, Firefox înainte de versiunea 43, Safari înainte de versiunea 9 și Edge înainte de versiunea 14, deci

Eliminarea mai multor elemente (JavaScript experimental avansat ES2018?)

// funcția de export array-lib.js remove (... forDeletion) (returnează acest.filtru (item =>! forDeletion.include (item))) // main.js import (remove) din „./array-lib .js "let arr = // :: This-Binding Syntax Proposal // using" remove "function as" virtual method "// fără a extinde Array.prototype arr = arr :: remove (2, 3, 5) console.log (arr) // [1, 4]

Iată câteva modalități eliminați elementul din matrice folosind javascript .

Toate metodele descrise nu modificați matricea originalăși în schimb creați una nouă.

Dacă cunoașteți indexul elementului

Să presupunem că aveți o matrice și doriți să eliminați elementul din poziția i.

O modalitate este de a folosi slice ():

const items = ["a", "b", "c", "d", "e", "f"] const i = 3 const filteredItems = items.slice (0, i-1) .concat (items. slice (i, items.length)) console.log (filteredItems)

slice () creează o nouă matrice cu indicii pe care îi primește. Pur și simplu creăm o nouă matrice - de la început până la indexul pe care dorim să-l eliminăm și concatenăm o altă matrice din prima poziție după cea pe care am eliminat-o până la sfârșitul matricei.

Dacă cunoașteți sensul

În acest caz, o opțiune bună este să folosiți filter (), care oferă mai multe declarativ o abordare:

const items = ["a", "b", "c", "d", "e", "f"] const valueToRemove = "c" const filteredItems = items.filter (item => item! == valueToRemove) console.log (filteredItems)

Aceasta folosește funcțiile săgeată ES6. Puteți utiliza funcții tradiționale pentru a sprijini browserele mai vechi:

const items = ["a", "b", "c", "d", "e", "f"] const valueToRemove = "c" const filteredItems = items.filter (function (item) (return item! = = valueToRemove)) console.log (filteredItems)

sau puteți utiliza Babel și puteți converti codul ES6 înapoi în ES5 pentru a-l face mai digerabil pentru browserele mai vechi, dar scrieți codul JavaScript modern în codul dvs.

Eliminarea mai multor elemente

Ce se întâmplă dacă doriți să ștergeți multe elemente în loc de un singur element?

Să găsim cea mai simplă soluție.

După index

Puteți pur și simplu să creați o funcție și să eliminați elementele secvențial:

const items = ["a", "b", "c", "d", "e", "f"] const removeItem = (items, i) => items.slice (0, i-1) .concat (items.slice (i, items.length)) let filteredItems = removeItem (items, 3) filteredItems = removeItem (filteredItems, 5) // ["a", "b", "c", "d"] consolă. jurnal (elemente filtrate)

După valoare

Puteți căuta includerea în funcția de apel invers:

const items = ["a", "b", "c", "d", "e", "f"] const valuesToRemove = ["c", "d"] const filteredItems = items.filter (item => ! valuesToRemove.includes (item)) // ["a", "b", "e", "f"] console.log (filteredItems)

Evitați mutarea matricei originale

splice () (nu trebuie confundat cu slice ()) mută matricea originală și trebuie evitat.

Puteți utiliza ES6.

Var array = ["1", "2", "3", "4", "5", "6"] var index = array.filter ((value) => value! = "3");

["1", "2", "4", "5", "6"]

Puteți face acest lucru cu ușurință cu metoda de filtrare:

Funcția remove (arrOriginal, elementToRemove) (returnează arrOriginal.filter (function (el) (return el! == elementToRemove));) console.log (remove (, 1));

Aceasta elimină toate elementele din matrice și este, de asemenea, mai rapidă decât combinația felie și indexOf

Nu ar trebui să mutați niciodată o matrice dintr-o matrice. Deoarece acest lucru este contrar modelului funcțional de programare. Puteți crea o nouă matrice fără a face referință la matricea pe care doriți să o modificați utilizând filtrul metodei es6;

Var myArray =;

Să presupunem că doriți să eliminați 5 dintr-o matrice, pur și simplu o puteți face așa.

MyArray = myArray.filter (valoare => valoare! == 5);

Acest lucru vă va oferi o nouă matrice fără valoarea pe care doriți să o ștergeți. Deci rezultatul va fi

; // 5 a fost eliminat din această matrice

Pentru o înțelegere suplimentară, puteți citi documentația MDN din filtrul Array.filter

Dacă doriți ca noua matrice cu pozițiile eliminate, puteți oricând să eliminați un anumit element și să filtrați matricea. S-ar putea să fie nevoie să extindeți obiectul matrice pentru browserele care nu implementează metoda de filtrare, dar pe termen lung este mai ușor, deoarece tot ce faceți este următorul:

Var my_array =; șterge matricea_ mea; console.log (my_array.filter (function (a) (return typeof a! == "undefined";)));

Ar trebui afișat

Dacă aveți obiecte complexe într-o matrice, puteți folosi filtre? Pentru situațiile în care $ .inArray sau array.splice nu este atât de ușor de utilizat. Mai ales dacă obiectele sunt posibil mici în matrice.

De exemplu, dacă aveți un obiect cu un câmp Id și doriți ca obiectul să fie eliminat din matrice:

This.array = this.array.filter (function (element, i) (return element.id! == idToRemove;));

Găsiți indexul elementului matrice pe care doriți să îl eliminați, apoi eliminați acel index cu splice.

Metoda splice () modifică conținutul unui tablou prin eliminarea elementelor existente și / sau adăugarea de elemente noi.

var array =; console.log (array) var index = array.indexOf (5); if (index> -1) (array.splice (index, 1);) // array = console.log (array);

Al doilea parametru de îmbinare este numărul de elemente de eliminat. Rețineți că splice modifică matricea în loc și returnează o matrice nouă care conține elementele eliminate.

Aveți de la 1 la 9 tablouri și doriți să ștergeți 5 folosind codul de mai jos.

var numberArray =; var newNumberArray = numberArray.filter (m => (returnează m! == 5;)); console.log ("Array nou, 5 eliminat", newNumberArray);

Dacă doriți să utilizați mai multe valori ex: - 1,7,8

var numberArray =; var newNumberArray = numberArray.filter (m => (return (m! == 1) && (m! == 7) && (m! == 8);)); console.log ("nou Array, 5 eliminat", newNumberArray);

Dacă doriți să ștergeți o valoare a matricei din ex matrice: -

var numberArray =; var removebleArray =; var newNumberArray = numberArray.filter (m => (return! removebleArray.include (m);)); console.log ("Array nou, eliminat", newNumberArray);

include un browser acceptat - link

Știu că există deja multe răspunsuri, dar multe dintre ele par să complice problema. Iată un mod simplu, recursiv, de a șterge toate instanțele unei chei - apelează auto până când indexul este găsit. Da, funcționează numai în browserele indexOf, dar este simplu și poate fi completat cu ușurință.

Funcție autonomă

Funcția removeAll (array, key) (var index = array.indexOf (key); if (index === -1) return; array.splice (index, 1); removeAll (array, key);)

Metoda prototipului

Array.prototype.removeAll = function (key) (var index = this.indexOf (key); if (index === -1) return; this.splice (index, 1); this.removeAll (key);)

Array.prototype.removeItem = funcția (a) (pentru (i = 0; i< this.length; i++) { if (this[i] == a) { for (i2 = i; i2 < this.length - 1; i2++) { this = this; } this.length = this.length - 1 return; } } } var recentMovies = ["Iron Man", "Batman", "Superman", "Spiderman"]; recentMovies.removeItem("Superman");



Cum se elimină un element dintr-un tablou după valoare? (douăzeci)

// editat datorită lui MarcoCI pentru sfaturi

incearca asta:

Funcția wantDelete (item, arr) (pentru (var i = 0; i

sper că acest lucru te va ajuta

Există o modalitate de a elimina un element dintr-o matrice JavaScript?

Având în vedere matricea:

Var ary = ["trei", "șapte", "unsprezece"];

Aș dori să fac ceva de genul:

RemoveItem („șapte”, ary);

M-am uitat la splice (), dar asta elimină doar numărul poziției, în timp ce am nevoie de ceva pentru a elimina un element după valoarea sa.

Lăsați commentsWithoutDeletedArray = commentsArray.filter ((comment) =>! (Comment.Id === commentId));

Iată o versiune care utilizează funcția inArray a jQuery:

Var index = $ .inArray (item, array); if (index! = -1) (array.splice (index, 1);)

Puteți realiza acest lucru folosind funcția Lodash _.elimina.

var array = ["trei", "șapte", "unsprezece"]; var evens = _.remove (array, function (e) (return e! == "seven";)); console.log (even);

Const _ = require ("lodash"); _.fără (, 2); // ->

Într-adevăr, nu înțeleg de ce acest lucru nu poate fi rezolvat cu

Arr = arr.filter (valoare => valoare! == "șapte");

Sau poate vrei să folosești vanilie JS

Arr = arr.filter (function (value) (return value! == "seven"));

O altă variantă:

If (! Array.prototype.removeArr) (Array.prototype.removeArr = function (arr) (if (! Array.isArray (arr)) arr =; // să fie drăguți cu oamenii care pun o valoare non-array aici .. asta ar putea fi eu! var that = this; if (arr.length) (var i = 0; while (i -1) (that.splice (i, 1);) else i ++; )) returnează că; )))

Acesta este indexOf () din nou în buclă, dar presupunând că tabloul care trebuie șters este mic în raport cu tabloul care trebuie curățat; fiecare eliminare scurtează bucla while.

Acest lucru vă va permite să faceți următoarele:

Var ary = ["trei", "șapte", "unsprezece"]; var aryWithoutSeven = ary.filter (function (value) (return value! = "seven")); console.log (aryWithoutSeven); // returnează ["trei", "unsprezece"]

Acest lucru a fost remarcat și în acest subiect în altă parte: https: //.com/a/20827100/293492

Nu utilizați opțiunea de ștergere - face o gaură în matrice, deoarece nu reindexează elementele după elementul șters.

> Array.prototype.remove = funcție (v) (... ștergeți acest ...); > var myarray = ["3", "24", "55", "2"]; nedefinit> myarray.remove ("55"); nedefinit> myarray ["3", "24", "2"]

O linie o va face

Var ary = ["trei", "șapte", "unsprezece"]; // Eliminați elementul "șapte" din matricea var filteredAry = ary.filter (funcția (e) (returnează e! == "șapte")) // => ["trei", "unsprezece"] // În ECMA6 (săgeată sintaxa funcției): var filteredAry = ary.filter (e => e! == "șapte")

Aceasta folosește funcția de filtrare în JS. Este acceptat în IE9 și în sus.

filter () apelează o dată funcția de apelare furnizată pentru fiecare element din matrice și creează o matrice nouă din toate valorile pentru care apelarea returnează o valoare care se evaluează la adevărat. callback-ul este apelat numai pentru indicii matricei cărora li s-au atribuit valori; nu este apelat pentru indexuri care au fost abandonate sau cărora nu li s-au atribuit niciodată valori. Elementele de matrice care nu reușesc testul de apel invers sunt omise și nu sunt incluse în noua matrice.

Deci, practic este la fel ca toate celelalte soluții pentru (var key in ary) (...), cu excepția faptului că for in este acceptat ca IE6.

Practic, filtrul este o metodă de comoditate care arată mult mai bine (și este înlănțuit) spre deosebire de for in constructor (AFAIK).

Verifică:

For (var i in array) (if (array [i] == "seven") (array.splice (i, 1); break;))

și în funcție:

Funcția removeItem (array, item) (for (var i in array) (if (array [i] == item) (array.splice (i, 1); break;))) removeItem (array, "șapte");

Eliminarea tuturor elementelor potrivite dintr-o matrice (nu doar primul pare să fie cel mai general răspuns aici):

While ($ .inArray (item, array)> -1) (array.splice ($. InArray (item, array), 1);)

Am folosit jQuery pentru o muncă grea, dar îți vine ideea dacă vrei să mergi într-o limbă maternă.

Trucul este să parcurgi matricea de la început la început, astfel încât să nu încurci indicii atunci când ștergi elemente.

Var deleteMe = function (arr, me) (var i = arr.length; while (i--) if (arr [i] === me) arr.splice (i, 1);) var arr = ["orange "," roșu "," negru "," portocaliu "," alb "," portocaliu "]; deleteMe (arr, "portocaliu");

arr este acum [„roșu”, „negru”, „alb”]

Funcția cleanArrayOfSpecificTerms (array, unwantedTermsArray) ($ .each (unwantedTermsArray, function (index, value)) (var index = array.indexOf (value); if (index> -1) (array.splice (index, 1);)) ); returnează matricea;)

Pentru utilizare, urmați acești pași:

Var notInclude = ["Not", "No", "First", "Last", "Prior", "Next", "dogs", "pisici"]; var splitTerms = ["apel", "jurnal", "câini", "pisici", "subiect", "schimbare", "prețuri"]; cleanArrayOfSpecificTerms (splitTerms, notInclude)

Am încercat să folosesc metoda funcției de la jbaron de mai sus, dar am constatat că trebuia să păstrez matricea originală neschimbată pentru o utilizare ulterioară și să creez o matrice nouă ca aceasta:

Var newArray = referenceArray;

Funcția newArrRemoveItem (matrice, element, newArray) (pentru (var i = 0; i< array.length; i++) { if(array[i]!=item){ newArray.push(array[i]); } } }

Apoi îl folosesc astfel:

Var recipientID = record.get ("VesselID"); var otherVessels = new Array (); newArrRemoveItem (vesselArr, vesselID, otherVessels);

Acum shipArr rămâne intact și, de fiecare dată când execut codul de mai sus, matricea otherVessels include totul, cu excepția ultimului element CAID.

indexOf este o opțiune, dar implementarea sa caută practic întreaga matrice pentru o valoare, astfel încât timpul de rulare crește odată cu dimensiunea matricei. (deci acest lucru este în fiecare browser, cred că am testat doar Firefox).

Nu am IE6 de verificat, dar aș numi un pariu sigur că puteți verifica cel puțin un milion de elemente matrice pe secundă în acest fel pe aproape orice computer client. Dacă [dimensiunea matricei] * [căutări pe secundă] ar putea crește peste un milion, ar trebui să luați în considerare o altă implementare.

Practic, puteți utiliza un obiect pentru a crea un index pentru matricea dvs., de exemplu:

Var index = ("trei": 0, "șapte": 1, "unsprezece": 2);

Orice cadru JavaScript normal va crea un index de căutare pentru astfel de obiecte, astfel încât să puteți traduce rapid o cheie într-o valoare, indiferent de câte proprietăți are obiectul.

Aceasta este doar o metodă de bază, în funcție de nevoile dvs., puteți combina mai multe obiecte și / sau tablouri pentru a face ca aceleași date să poată fi căutate rapid pentru diferite proprietăți. Dacă vă oferiți nevoile dvs. specifice, vă pot sugera o structură de date mai specifică.

// Această funcție permite eliminarea matricei uniforme din matricea var removeFromArr = funcție (arr, elem) (var i, len = arr.length, new_arr =, sort_fn = funcție (a, b) (returnează a - b;); pentru ( 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; }

Exemplu de utilizare

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

Să arr =; console.log (arr); // rezultat let index = arr.indexOf (30); if (index> -1) (arr.splice (index, 1);) console.log (arr); // rezultat

Var index = array.indexOf ("element"); if (index! = - 1) (array.splice (index, 1);)

schimb

Utilizați .shift pentru a elimina primul element al matricei.

De exemplu:

Var array =; array.shift ();

matricea are ca rezultat:

De exemplu:

Var array =; array.pop ();

matricea are ca rezultat:

Ambele metode returnează elementul eliminat;

lipitură

Use.splice () pentru a elimina o serie de elemente dintr-o matrice. .splice () ia doi parametri, un index de pornire și o cardinalitate opțională de eliminat. Dacă al doilea parametru nu este, splice () va elimina toate elementele din indexul de pornire până la sfârșitul matricei.

De exemplu:

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

lasă o matrice care conține:

Returnarea array.splice () este o nouă matrice care conține elementele eliminate. În exemplul de mai sus, randamentul ar fi:

Astfel, omiterea celui de-al doilea parametru împarte în mod eficient matricea în două tablouri cu finalul original până la indexul specificat:

Var array =; array.splice (2);

Părăsește un tablou care conține și se întoarce.

șterge

Utilizați ștergeți pentru a elimina un element dintr-o matrice fără a modifica lungimea matricei:

Var array =; console.log (array.length); // 5 șterge matricea; console.log (matrice); // console.log (array.length); // 5

Array.prototype.length

Atribuirea valorii la lungimea matricei modifică lungimea cu valoarea specificată. Dacă noua valoare este mai mică decât lungimea matricei, elementele vor fi eliminate de la sfârșitul valorii.

Array =; array.length = 2; console.log (matrice); //

Am descris doar o parte din metodele de lucru cu tablouri.

Aici vom vorbi despre adăugarea, eliminarea elementelor matrice. Despre inversarea și sortarea unei matrice, precum și felierea, înlocuirea și combinarea matricelor.

Adăugarea de elemente la o matrice.

Puteți utiliza proprietatea length pentru a adăuga elemente noi la matrice:

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

Acest lucru va funcționa pentru că elementele matrice sunt numerotate de la zero și lungimeîncă una. Lungime mereu echivalent index + 1 deci este foarte ușor să adăugați un element nou la sfârșitul matricei. Ciudat, dar puteți adăuga un element într-o poziție care este mult mai mare decât lungimea matricei în sine:

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

După cum se arată în comentarii, 95 de sloturi goale și un element „Lindsey Buckingham” vor fi adăugate la sfârșitul matricei. După aceea, obținem lungimea 100. O altă modalitate de a adăuga un element nou matricei este utilizarea metodei Apăsaț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”]

Metodă Apăsați () returnează întotdeauna noua lungime a matricei (în cazul nostru 5). Puteți adăuga un articol folosind splice ():

Var myArray = ["ghindă", "fag", "mongongo", "macadamia"]; myArray.splice (2, 0, „caju”); // adaugă „caju” în indexul console.log (myArray); // ["ghindă", "fag", "caju", "mongongo", "macadamia"]

Când al doilea argument este 0, înseamnă că niciun element nu va fi eliminat și, prin urmare, orice argumente ulterioare vor fi adăugate la matrice în poziția specificată în primul argument.

Eliminarea elementelor dintr-o matrice

Eliminarea unui element este puțin mai dificilă decât adăugarea acestuia. Pentru a elimina un element de la capătul unui tablou, se poate utiliza pop ():

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

Metodă pop () elimină întotdeauna ultimul element din matrice și îl returnează.

Puteți utiliza, de asemenea splice () metodă:

Var myArray = ["manioc", "nucșoară", "lupin", "rubarbă"]; myArray.splice (2, 1); // eliminați elementul din indexul 2 console.log (myArray); // ["manioc", "nucșoară", "rubarbă"]

Spre deosebire de metodă splice (), care este folosit pentru a adăuga elemente, aici al doilea argument este 1, care spune că vrem să eliminăm elementul cu indexul 2 (sau al treilea la rând). În acest caz, elementul „lupin” a fost eliminat.

Puteți elimina un element dintr-o matrice folosind operatorul șterge:

Var myArray = ["Byte Bandit", "Eliza", "Jeefo", "Michelangelo"]; console.log (myArray.length); // 4 șterge myArray; // elimina Eliza console.log (myArray.length); // 4 console.log (myArray); // [„Byte Bandit”, nedefinit × 1, „Jeefo”, „Michelangelo”]

Prima notă importantă: șterge () nu modifică lungimea tabloului după eliminarea elementului (chiar dacă a fost ultimul element din tablou). Al doilea: șterge () schimbă valoarea elementului eliminat la nedefinit, deci la inversare myArray = nedefinit.

O modalitate bună de a elimina un element dintr-o matrice este de a utiliza Array.remove a lui John Resig. Mai jos este un exemplu de utilizare preluat de pe pagina sa:

// Array Remove - By John Resig (MIT Licensed) Array.prototype.remove = function (from, to) (var rest = this.slice ((to || from) + 1 || this.length); this.length = din< 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);

S-ar putea să doriți să vă uitați la soluția de Viral Patel, una dintre funcțiile din Underscore.js sau grep () al jQuery.

În plus, în JavaScript există o metodă schimb (), care elimină primul element din matrice și îi returnează valoarea. Să vedem codul:

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”]

Folosind metoda schimb () am eliminat elementul, dar am salvat valoarea acestuia în prima noastră variabilă Item. Lungimea matricei s-a schimbat de la 4 la 3.

Această metodă poate fi utilă împreună cu metoda Apăsați (). Folosindu-le împreună, putem coada eficient elementele dintr-o matrice. Păstrăm lungimea matricei eliminând elementul de la început și adăugând unul nou la sfârșit.

Dimpotrivă, putem folosi metoda unshift () pentru a adăuga un element la începutul matricei:

Var myArray = ["apito", "castanets", "maraca"]; console.log (myArray.length); // 3 myArray.unshift („chime bar”, „tan-tan”); console.log (myArray.length); // 5 console.log (myArray); // ["chime bar", "tan-tan", "apito", "castanets", "maraca"]

Folosind metoda unshift () cu metoda pop (), puteți face coadă înapoi adăugând elemente la început și eliminând de la sfârșitul matricei.

Inversarea și sortarea elementelor matrice.

Pentru a răsturna elementele dintr-o matrice, putem folosi revers ():

Var myArray = ["countdown", "final", "the"]; console.log (myArray); // ["numărătoarea inversă", "final", "the"] myArray = myArray.reverse (); console.log (myArray); // ["numărătoarea finală"]

Sortați elementele matricei în ordine alfabetică eventual folosind metoda fel ():

Var myArray = ["xilofoane", "zebre", "juggernauts", "avocado"]; console.log (myArray); // ["xilofoane", "zebre", "juggernauts", "avocado"] myArray = myArray.sort (); console.log (myArray); // ["avocado", "juggernauts", "xylophones", "zebras"]

Dar asta nu va funcționa cu numerele.

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

Dacă trebuie să sortați numerele, puteți utiliza următorul cod:

Funcție compareNumbers (a, b) (return a - b;) var myArray =; console.log (myArray); // myArray = myArray.sort (compareNumbers); console.log (myArray); //

După cum se arată mai sus, cu o funcție simplă lipită în fel (), matricea care conține numerele va fi sortată corect.

Combinarea matricelor.

Puteți concatena 2 sau mai multe tablouri și puteți obține 1 matrice care conține elementele matricelor concatenate. Pentru aceasta folosim metoda 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”]

Împărțirea unei matrice.

Puteți crea o nouă matrice care conține 1 sau mai multe elemente dintr-o matrice existentă folosind funcția felie ():

Var myArray = ["Vocale", "Bas", "Chitară", "Tobe", "Mere", "Portocale"]; var myNewArray = myArray.slice (4); console.log (myNewArray); // [„Mere”, „Portocale”]

Metodă felie () ia 1 sau 2 argumente. Dacă este trecut 1 argument (index), atunci se creează o nouă matrice din toate elementele celei vechi, începând de la indexul dat. Dacă sunt trecute 2 argumente, atunci se creează o nouă matrice din elementele care încep de la primul argument și până la elementul cu indexul trecut în al doilea parametru, neincluzând ultimul. Pentru a fi mai clar, să vedem codul de mai jos:

Var myArray = ["Vocale", "Bas", "Chitară", "Tobe", "Mere", "Portocale"]; var myNewArray = myArray.slice (0, 4); console.log (myNewArray); // [„Voce”, „Bas”, „Chitară”, „Tobe”]

Înlocuirea elementelor dintr-o matrice.

Folosim splice () pentru a elimina elemente dintr-un tablou, dar putem înlocui și un element dintr-un tablou cu elemente noi:

Var myArray = ["Rivers Cuomo", "Patrick Wilson", "Brian Bell", "Matt Sharp"]; myArray.splice (3, 1, „Scott Shriner”); // înlocuiește 1 element cu index.log console.log (myArray); // ["Rivers Cuomo", "Patrick Wilson", "Brian Bell", "Scott Shriner"]

Metodă splice () returnează întotdeauna o matrice care conține elementele care au fost eliminate. Rândul 2 va returna 1 articol „Brian Bell”.

Concluzie

Aceste articole au descris metode pentru lucrul cu tablouri în JavaScript. Unele elemente suplimentare pot fi vizualizate pe MDN pe care nu le-am inclus în această postare. Funcționează numai în IE9 +, deci s-ar putea să nu fie utile.

Ceva de adăugat? Sau cunoști vreo bibliotecă interesantă care să te ajute să gestionezi matricele? Vă rugăm să comentați!