Meniul
AcasăiOS

Indicii elementelor matrice în javascript încep cu. ▍Puntele tari ale operatorului de expansiune. Conversia unui tablou într-un șir - join

  • Traducere
  • I. Iterarea peste matrice reale
    1. pentruFiecare metodă și metode aferente
    2. pentru buclă
    3. Folosire adecvata pentru...în buclă
    4. for...of loop (utilizarea implicită a iteratorului)
    5. Utilizarea explicită a iteratorului
    1. Folosind metode de iterare peste matrice reale
    2. Convertiți într-o matrice reală
    3. O notă despre obiectele runtime

I. Iterarea peste matrice reale

Pe acest moment Există trei moduri de a repeta elementele unui tablou real:
  1. metoda Array.prototype.forEach ;
  2. clasic pentru buclă
  3. un „corect” construit pentru... în buclă.
În plus, în curând, odată cu apariția noului standard ECMAScript 6 (ES 6), sunt așteptate încă două metode:
  1. for...of loop (utilizarea implicită a iteratorului);
  2. utilizarea explicită a iteratorului.

1. Metoda forEach și metodele conexe

Dacă proiectul dvs. este proiectat să suporte caracteristicile standardului ECMAScript 5 (ES5), puteți utiliza una dintre inovațiile acestuia - metoda forEach.

Exemplu de utilizare:
var a = ["a", "b", "c"]; a.forEach(funcție(intrare) ( console.log(intrare); ));
ÎN caz general utilizarea forEach necesită conectarea bibliotecii de emulare es5-shim pentru browserele care nu acceptă în mod nativ această metodă. Acestea includ IE 8 și mai sus versiuni timpurii, care sunt încă în uz ici și colo.

Avantajul forEach este că nu este nevoie să declarați variabile locale pentru a stoca indexul și valoarea elementului de matrice curent, deoarece acestea sunt transmise automat funcției. sună din nou(callback) ca argumente.

Dacă sunteți îngrijorat de costul posibil al apelării unui apel invers pentru fiecare element, nu vă faceți griji și citiți asta.

ForEach este proiectat să itereze peste toate elementele unei matrice, dar în plus față de acesta, ES5 oferă mai multe metode utile pentru a itera toate sau unele elemente plus efectuarea unor acțiuni asupra acestora:

  • fiecare - returnează adevărat dacă pentru fiecare element al matricei apelul returnează o valoare care poate fi convertită în adevărat .
  • some - returnează adevărat dacă pentru cel puțin un element al matricei, callback returnează o valoare care poate fi convertită în adevărat.
  • filter - creează o nouă matrice care include acele elemente ale matricei originale pentru care callback returnează true .
  • hartă - creează o nouă matrice constând din valorile returnate de apel invers.
  • reduce - reduce o matrice la o singură valoare, aplicând un callback fiecărui element de matrice pe rând, începând cu primul (poate fi util pentru calcularea sumei elementelor matricei și a altor funcții rezumative).
  • reduceRight - funcționează similar cu reduce, dar iterează prin elemente în ordine inversă.

2. Pentru buclă

Bine vechi pentru reguli:

Var a = ["a", "b", "c"]; indicele var; pentru (index = 0; index< a.length; ++index) { console.log(a); }
Dacă lungimea matricei este constantă pe tot parcursul buclei, iar bucla în sine aparține unei secțiuni critice pentru performanță a codului (ceea ce este puțin probabil), atunci puteți utiliza o versiune „mai optimă” a pentru care stochează lungimea matrice:

Var a = ["a", "b", "c"]; var index, len; pentru (index = 0, len = a.lungime; index< len; ++index) { console.log(a); }
În teorie, acest cod ar trebui să ruleze puțin mai repede decât cel anterior.

Dacă ordinea elementelor nu este importantă, atunci puteți merge și mai departe în ceea ce privește optimizarea și puteți scăpa de variabila pentru stocarea lungimii matricei, schimbând ordinea căutării în sens invers:

Var a = ["a", "b", "c"]; indicele var; pentru (index = a.length - 1; index >= 0; --index) ( console.log(a); )
Cu toate acestea, în motoare moderne Jocurile de optimizare JavaScript ca acestea de obicei nu înseamnă nimic.

3. Utilizarea corectă a buclei for...in

Dacă vi se recomandă să utilizați o buclă for...in, amintiți-vă că iterarea peste matrice nu este scopul pentru care este destinată. Contrar unei concepții greșite obișnuite, bucla for...in nu iterează peste indici de matrice, ci mai degrabă prin proprietăți enumerabile ale unui obiect.

Cu toate acestea, în unele cazuri, cum ar fi iterarea pe matrice rare, pentru...in poate fi utilă, atâta timp cât luați măsuri de precauție, așa cum se arată în exemplul de mai jos:

// a - tablou rar var a = ; a = „a”; a = „b”; a = "c"; pentru (cheie var în a) ( dacă (a.hasOwnProperty(cheie) && /^0$|^\d*$/.test(cheie) && cheie<= 4294967294) { console.log(a); } }
În acest exemplu, sunt efectuate două verificări la fiecare iterație a buclei:

  1. că matricea are propria sa proprietate numită cheie (nu este moștenită de la prototipul său).
  2. acea cheie este un șir care conține reprezentarea zecimală a unui număr întreg a cărui valoare este mai mică decât 4294967294 . De unde vine ultimul număr? Din definiția unui index de matrice din ES5, care arată că cel mai mare indice pe care îl poate avea un element dintr-o matrice este: (2^32 - 2) = 4294967294 .
Desigur, astfel de verificări vor lua timp inutil la executarea buclei. Dar în cazul unei matrice rare, această metodă este mai eficientă decât o buclă for, deoarece în acest caz sunt iterate doar acele elemente care sunt definite în mod explicit în matrice. Deci, în exemplul de mai sus, vor fi efectuate doar 3 iterații (pentru indicii 0, 10 și 10000) - față de 10001 în bucla for.

Pentru a nu scrie un cod de verificare atât de greoi de fiecare dată când trebuie să iterați printr-o matrice, îl puteți scrie ca o funcție separată:

Funcția arrayHasOwnIndex(matrice, cheie) ( returnează matrice.hasOwnProperty(cheie) && /^0$|^\d*$/.test(cheie) && cheie<= 4294967294; }
Apoi corpul buclei din exemplu va fi redus semnificativ:

Pentru (tastați a) ( dacă (arrayHasOwnIndex(a, cheie)) ( console.log(a); ) )
Codul de verificare discutat mai sus este universal, potrivit pentru toate cazurile. Dar, în schimb, puteți utiliza o versiune mai scurtă, deși formal nu este complet corectă, dar totuși potrivită pentru majoritatea cazurilor:

Pentru (tastați a) ( dacă (a.hasOwnProperty(cheie) && String(parseInt(key, 10)) === cheie) ( console.log(a); ) )

4. For...of loop (utilizarea implicită a iteratorului)

ES6, încă în stare de schiță, ar trebui să introducă iteratori în JavaScript.

Iterator este un protocol implementat de un obiect care definește o modalitate standard de a obține o secvență de valori (finită sau infinită).
Un iterator este un obiect care definește o metodă next() - o funcție fără argument care returnează un obiect cu două proprietăți:

  1. done (boolean) - adevărat dacă iteratorul a ajuns la sfârșitul secvenței iterabile. În caz contrar, valoarea este falsă.
  2. valoare - definește valoarea returnată de iterator. Poate fi nedefinit (lipsește) dacă proprietatea realizată este adevărată.
Multe obiecte încorporate, incl. tablourile reale au iteratoare în mod implicit. Cea mai simplă modalitate de a folosi un iterator pe tablouri reale este să folosiți noul for...of construct.

Exemplu de utilizare pentru...de:

Varval; var a = ["a", "b", "c"]; pentru (val of a) ( console.log(val); )
În exemplul de mai sus, bucla for...of apelează implicit iteratorul obiectului Array pentru a obține fiecare valoare a matricei.

5. Utilizarea explicită a iteratorului

Iteratorii pot fi, de asemenea, folosiți în mod explicit, totuși, în acest caz, codul devine mult mai complicat în comparație cu bucla for...of. Arata cam asa:

Var a = ["a", "b", "c"]; var it = a.entries(); intrare var; în timp ce (!(entry = it.next()). done) ( console.log(entry.value); )
În acest exemplu, metoda Array.prototype.entries returnează un iterator care este utilizat pentru a afișa valorile matricei. La fiecare iterație, entry.value conține o matrice de forma [cheie, valoare] .

II. Iterarea peste obiecte asemănătoare matricei

Pe lângă matricele reale, în JavaScript există și obiecte asemănătoare matricei . Ceea ce au în comun cu tablourile reale este că au o proprietate de lungime și proprietăți numite ca numere corespunzătoare elementelor matricei. Exemplele includ DOM-ul colecției NodeList și pseudo-matricea de argumente, disponibile în orice funcție/metodă.

1. Folosirea metodelor de iterare peste matrice reale

Cel puțin, cele mai multe, dacă nu toate, metodele de iterare peste matrice reale pot fi folosite pentru a repeta peste obiecte asemănătoare matricei.

Construcțiile for și for...in pot fi aplicate obiectelor asemănătoare matrice exact în același mod în care sunt aplicate matricelor reale.

Metodele ForEach și alte Array.prototype se aplică și obiectelor asemănătoare matricei. Pentru a face acest lucru, trebuie să utilizați Function.call sau Function.apply .

De exemplu, dacă doriți să aplicați forEach la proprietatea childNodes a unui obiect Node, ați proceda astfel:

Array.prototype.forEach.call(node.childNodes, function(child) ( // face ceva cu obiectul copil));
Pentru a face acest truc mai ușor de reutilizat, puteți declara o referință la metoda Array.prototype.forEach într-o variabilă separată și o puteți utiliza ca scurtătură:

// (Presupunând că tot codul de mai jos este în același domeniu) var forEach = Array.prototype.forEach; // ... forEach.call(node.childNodes, function(child) ( // face ceva cu obiectul copil));
Dacă un obiect asemănător matricei are un iterator, acesta poate fi utilizat în mod explicit sau implicit pentru a itera asupra obiectului în același mod ca și pentru matricele reale.

2. Convertiți într-o matrice reală

Există, de asemenea, o altă modalitate, foarte simplă, de a repeta peste un obiect asemănător matricei: convertiți-l într-o matrice reală și utilizați oricare dintre metodele discutate mai sus pentru a repeta peste matrice reale. Pentru conversie, puteți utiliza metoda generică Array.prototype.slice, care poate fi aplicată oricărui obiect asemănător matricei. Acest lucru se face foarte simplu, așa cum se arată în exemplul de mai jos:

Var trueArray = Array.prototype.slice.call(arrayLikeObject, 0);
De exemplu, dacă doriți să convertiți o colecție NodeList într-o matrice reală, veți avea nevoie de cod de genul acesta:

Var divs = Array.prototype.slice.call(document.querySelectorAll("div"), 0);
Actualizați: După cum s-a menționat în comentarii

În acest articol ne vom uita la o matrice JavaScript și componentele sale. JavaScript este proiectat ideal pentru programare. De fapt, implementează limbajul ECMAScript (standard ECMA-262).

Unde este folosit JavaScript? Este folosit ca limbaj încorporat pentru a defini calea unui program către un subiect de aplicație. Poate fi găsit în browsere unde este folosit ca limbaj de scripting care face paginile web interactive.

Cele mai importante caracteristici arhitecturale ale acestui produs sunt tastarea dinamică și slabă, gestionarea automată a memoriei, programarea perfectă și funcțiile obiectelor de primă clasă.

În general, JavaScript a fost influențat de diverse motive, deoarece în timpul dezvoltării s-au dorit să creeze un limbaj similar cu Java, dar ușor de folosit de programatori. Apropo, limbajul JavaScript nu este deținut de nicio companie sau organizație, ceea ce îl face diferit de o serie de stiluri de programare utilizate de dezvoltatorii web.

Trebuie remarcat faptul că JavaScript este o marcă înregistrată a Oracle Corporation.

Ce este o matrice?

Un tablou este unul care stochează valori numerotate. Fiecare astfel de valoare este numită componentă de matrice, iar cifra căreia este asociată componenta se numește index. Matricea JavaScript este netipificată. Aceasta înseamnă că părțile unei matrice pot fi de orice tip, iar părțile diferite aparținând aceleiași matrice au tipuri complet diferite.

În plus, matricea JavaScript este dinamică, ceea ce înseamnă că nu este nevoie să declarați o dimensiune fixă. La urma urmei, puteți adăuga oricând detalii noi.

Producția de matrice

Folosind JavaScript, crearea unei matrice nu este deloc dificilă. Există două metode pentru aceasta. Primul implică crearea unei matrice folosind un literal - paranteze pătrate, în interiorul căreia se află o listă de părți, separate prin virgule.

  • var gol = ; //matrice goală;
  • var numere = ; //matrice cu cinci componente digitale;
  • var diff = ; //matrice cu trei elemente de tipuri diferite.

De obicei, valorile de aici nu trebuie să fie simple (șiruri și numere). Poate fi, de asemenea, orice alte expresii, de exemplu, literale subiect, alte funcții și matrice.

A doua modalitate de a crea o matrice este apelarea designerului Array(). Îl poți invita în trei moduri:

  • Apelarea designerului fără argumente: var b - new Array(). Aceasta prevede crearea unui tablou gol, echivalent cu un literal gol.
  • Constructorul specifică în mod explicit valoarea celor n componente ale matricei: var b = new Array (1, 3, 5, 8, „șir”, adevărat). În acest caz, designerului i se prezintă o listă de argumente care sunt transformate în componente ale unei noi matrice. Argumentele sunt scrise în matrice în locația în care sunt specificate.
  • Definirea zonei pentru atribuirea ulterioară a valorilor. Aceasta se face prin specificarea, la identificarea unui tablou, a unui singur număr cuprins între paranteze: var b = new Array(5). Această metodă de identificare presupune alocarea numărului necesar de componente matricei (fiecare dintre acestea fiind listată ca nedefinită) cu posibilitatea de a atribui ulterior valori în timpul procesului de prezentare. Acest formular este de obicei folosit pentru a pre-aloca o matrice Javascript a cărei lungime este cunoscută dinainte.

Scrierea, citirea și adăugarea detaliilor matricei

Puteți accesa componentele unei matrice folosind operatorul. Apropo, toate componentele din JavaScript, începând de la zero, sunt numerotate. Pentru a obține elementul necesar, numărul acestuia este indicat în De regulă, detaliile pot fi modificate. Și pentru a adăuga JavaScript la matrice, trebuie doar să atribuiți o nouă valoare.

Trebuie remarcat faptul că matricele JavaScript pot stoca orice număr de elemente de orice fel.

Lungimea matricei

Deci, știm că lungimea unui tablou este în general un fenomen interesant. Să aruncăm o privire mai atentă. Toate tablourile, indiferent dacă sunt construite folosind designerul Array() sau dezvăluite printr-un literal de matrice, au o proprietate de lungime specifică care indică numărul total de elemente stocate. Deoarece o matrice poate conține părți nedefinite (notate cu nedefinit), o expresie mai precisă este: calitatea lungimii este întotdeauna cu unul mai mare decât cel mai mare număr (indice) al componentei matricei. Calitatea lungimii este ajustată automat, rămânând precisă atunci când apar piese noi în matrice.

Pentru a face să apară componenta finală a matricei, puteți utiliza proprietatea length.

Ultima parte are un index cu un mai mic decât dimensiunea matricei. La urma urmei, numărătoarea inversă începe întotdeauna de la zero. Oh, acest JavaScript! Lungimea matricei depinde de numărul exact de elemente. Deci, dacă nu știți câte ar trebui să fie, dar trebuie să accesați elementul final al matricei, trebuie să utilizați notația: v.length - 1.

Iterarea asupra detaliilor matricei

Foarte des, proprietatea lungimii este folosită pentru a itera detaliile unui tablou într-o buclă:

  • fructe var = [„căpșuni”, „piersici”, „măr”, „banane”];
  • pentru(var I = 0; i< fruits.lenght; i++);
  • document.write(fructe[i] + "...").

În acest exemplu, componentele par a fi plasate continuu și încep cu prima parte deținând un indice de zero. Dacă nu este cazul, înainte de a apela fiecare element al matricei, trebuie să verificați dacă este definit.

O buclă este de asemenea folosită uneori pentru a inițializa componente.

Creșteți și trunchiați o matrice

Mă întreb cum să adaug un șir la o matrice folosind JavaScript? Pe măsură ce lucrăm cu matrice, lungimea calității se îmbunătățește automat, motiv pentru care trebuie să avem grijă de asta. Este necesar să ne amintim un detaliu - proprietatea lungimii nu este doar lizibilă, ci și scrisă. Dacă calității lungimii i se atribuie o valoare mai mică ca dimensiune decât cea actuală, atunci matricea este redusă la dimensiunea specificată. Orice componente care nu se află în noul interval de index sunt aruncate și valorile lor sunt pierdute, chiar dacă lungimea este returnată ulterior - valorile nu sunt restaurate.

Este foarte ușor să ștergeți matricea astfel: foo.length = 0.

Dacă calitatea lungimii este mai mare decât valoarea sa actuală, noi părți neidentificate vor apărea la sfârșitul matricei, ceea ce o va crește la dimensiunea dorită.

Îndepărtarea pieselor de model

Operatorul de ștergere specifică o valoare nedefinită într-o componentă a matricei, dar aceasta continuă să existe. Dacă trebuie să eliminați un element dintr-o matrice JavaScript, astfel încât părțile rămase să fie mutate în spațiul liber, trebuie să utilizați una dintre metodele de matrice furnizate. Array.shift() elimină prima componentă, pop() elimină componenta finală, iar splice() elimină una sau o serie de componente oriunde în matrice.

Matrice multidimensionale

Se pare că ne-am dat seama puțin, tablourile bidimensionale sunt ceea ce trebuie să luăm în considerare în continuare. Vă amintiți că matricele JavaScript pot conține și alte elemente ca componente? Această caracteristică este utilizată pentru a produce matrice multidimensionale. Pentru a vizita componente dintr-o serie de matrice, pur și simplu utilizați paranteze pătrate de două ori.

Matrice asociative

Acum haideți să explorăm modul în care marca comercială JavaScript folosește matricele asociative. Pentru a face acest lucru, trebuie să ne uităm la teorie: tablourile asociative sunt uneori numite tabele hash. Datorită lor, șirurile sunt folosite în loc de indecși. Utilizarea unor astfel de construcții amintește de utilizarea numelui proprietății unui obiect simplu, dar în această versiune atunci când se efectuează lucrări într-un format de matrice. Deoarece JavaScript nu are modalități de a opera cu tablouri asociative, acestea sunt folosite mult mai puțin frecvent decât cele obișnuite. Trebuie remarcat faptul că acestea pot fi în continuare utile pentru stocarea datelor și ușurează reținerea detaliilor care trebuie accesate.

Ieșire matrice

Ce vom învăța acum despre JavaScript? Afișarea matricei într-o casetă de dialog (pe ecranul monitorului), precum și afișarea valorilor componentelor matricei.

Dacă trebuie să afișați valorile tuturor componentelor dintr-un program, atunci este convenabil să utilizați instrucțiunea for. În mod interesant, variabila pentru contor reguli este folosită ca index al unei componente de matrice.

Curatenie

Pentru a filtra o matrice JavaScript, trebuie să-i resetați lungimea la zero:

  • var myArray = ;
  • myArray.length = 0.
  • clear: function() (;
  • aceasta.lungime = 0;
  • returnează asta;

Adăugarea și îndepărtarea componentelor

Ei bine, să continuăm să studiem acest limbaj JavaScript interesant. Un element de matrice poate fi șters sau adăugat în același mod ca proprietățile obișnuite ale altor obiecte. Dar există unele diferențe: adăugarea de proprietăți numerice poate schimba calitatea lungimii, iar modificarea proprietății lungime poate elimina calitățile numerice. În principiu, algoritmul pentru setarea calităților pentru matrice este următorul:

  • Când se adaugă o proprietate digitală necunoscută i, dacă lungimea este egală sau mai mică decât i, lungimea este definită a fi i+1.
  • Când calitatea lungimii se modifică, se efectuează următoarele acțiuni: dacă valoarea atribuită este mai mică decât zero, atunci este aruncată o RangeError. Toate calitățile numerice și indicii care sunt egali cu noua lungime și care sunt mai mari sunt eliminați.

În general, ștergerea unui element dintr-o matrice JavaScript nu este dificilă. La urma urmei, chiar și atunci când setați lungimea, trebuie să eliminați componentele „extra” din ea. Acest lucru duce la opțiunea de ștergere a matricei. Dacă variabila atribuită unei matrice noi goale nu este potrivită dintr-un motiv oarecare și este necesară resetarea celei curente, este suficient să atribuiți valoarea zero calității lungimii sale.

metodele unshift, shift, pop și push

Deși componentele matricei sunt modificate manual, mulți oameni recomandă utilizarea metodelor încorporate pentru aceasta. Această nuanță este cea care garantează valoarea corectă a calității lungimii și absența golurilor în matrice. Apropo, calitatea corectă a lungimii va corespunde numărului de componente.

Metoda push mută părțile trecute la sfârșitul matricei. Metoda pop redă componenta finală și o elimină.

În general, în Internet Explorer mai tânără decât versiunea a opta, unshift poate returna nedefinit în alte browsere, o nouă valoare de lungime; Prin urmare, este mai bine să nu vă bazați pe valoarea returnată de la unshift.

Adăugarea și eliminarea pieselor în mijlocul unui tablou

Dacă trebuie să șterg o matrice JavaScript, ce ar trebui să fac? Metoda splice este cunoscută ca având semnătura Array.prototype.splice.

Îndepărtează componentele deleteCount din matrice, începând cu indicatorul de pornire. Dacă sunt transmise mai mult de două argumente, atunci toate argumentele ulterioare din matrice sunt plasate în locul celor eliminate. Dacă startul este negativ, atunci indicele de la care se va relua retragerea va fi egal cu lungimea + start. Matricea este returnată din elementele eliminate.

De fapt, folosind metoda splice, puteți elimina componente din mijlocul matricei sau puteți adăuga orice număr de componente oriunde în matrice.

În cea mai simplă versiune, dacă trebuie să eliminați o componentă cu index i, trebuie să solicitați metoda de îmbinare din matricea cu parametrii i și 1.

În principiu, al doilea parametru al metodei splice este opțional, dar comportamentul unei funcții cu un argument este diferit în fiecare browser.

De exemplu, în Firefox, în cele mai recente variante ale Opera, în Safari și în Chrome, toate detaliile până la sfârșitul matricei vor fi eliminate.

Nicio componentă nu va fi eliminată în IE. În primele variații ale Opera, este imposibil să preziceți comportamentul - o parte cu începutul indexului - 1 va fi eliminată. Prin urmare, trebuie să treceți întotdeauna cel puțin două componente acestei metode.

Chei

Desigur, atunci când învățați JavaScript, ar trebui să aveți în vedere și matricele asociative, așa cum am menționat mai devreme. Acesta este un tip abstract de informații (o interfață pentru o stocare de date), care vă permite să salvați perechi de forma „(cheie, valoare)” și să sprijine operațiunile de adăugare a unei perechi, precum și ștergerea și căutarea unei perechi prin cheie:

GĂSIȚI (cheie).

INSERT (valoare, cheie).

ELIMĂ (cheie).

Se presupune că două perechi cu chei similare nu pot fi stocate într-o matrice asociativă. Într-o pereche k + v, v se numește valoarea asociată cu cheia k. Semantica și numele operațiilor de mai sus pot fi diferite în diferite implementări ale unor astfel de matrice.

Astfel, acțiunea FIND (cheie) returnează valoarea asociată cu cheia dată sau un anumit obiect UNDEF care indică faptul că nu există nicio valoare asociată cu cheia dată. Celelalte două acțiuni nu returnează nimic (cu excepția faptului că operația a avut succes).

În general, din punctul de vedere al interfeței, este convenabil să se considere o matrice asociativă ca o matrice simplă în care nu numai numere întregi, ci și valori de alte tipuri - de exemplu, șiruri - pot fi folosite ca indici.

Apropo, suportul pentru astfel de matrice este disponibil în multe limbaje de programare de nivel înalt, cum ar fi PHP, Perl, Ruby, Python, Tcl, JavaScript și altele. Pentru limbile care nu au instrumente încorporate pentru lucrul cu tablouri asociative, a fost creat un număr colosal de implementări sub formă de biblioteci.

Un exemplu de matrice asociativă este un director telefonic. În această versiune, semnificația este complexul „F. I. O. + adresa”, iar cheia este numărul de telefon. Un număr de telefon are un singur proprietar, dar o persoană poate deține mai multe numere.

Extensii asociative

Trebuie remarcat faptul că cele mai cunoscute extensii includ următoarele:

  • FIECARE - „treceți prin” toate perechile salvate.
  • CLEAR - eliminați toate înregistrările.
  • MIN - găsiți perechea cu cea mai mică valoare a cheii.
  • MAX - găsiți perechea cu cea mai mare valoare a cheii.

Ultimele două opțiuni necesită ca acțiunea de comparare să fie indicată pe taste.

Implementări de tablouri asociative

Există multe implementări diferite ale unui tablou asociativ. Cea mai comună implementare s-ar putea baza pe o matrice simplă ale cărei componente sunt perechi (valoare, cheie). Pentru a accelera operațiunile de căutare, puteți ordona componentele unui anumit tablou după cheie și puteți efectua căutarea folosind Dar acest lucru va crește perioada de timp necesară pentru a adăuga o nouă pereche, deoarece va fi necesar să „depărtați” componentele din matricea pentru a împacheta o înregistrare nouă în celula goală care apare.

Cele mai cunoscute implementări sunt cele bazate pe diferiți arbori de căutare. De exemplu, într-un cititor C++ STL tipic, containerul hărții este implementat pe baza unui arbore de mahon negru. Stilurile Ruby, Tcl, Python folosesc un tip de tabel hash. Există și alte implementări.

În general, fiecare implementare are propriile sale dezavantaje și avantaje. Este important ca toate cele trei acțiuni să fie efectuate atât în ​​medie, cât și în cea mai proastă nuanță pe perioada O(log n), unde n este numărul curent de perechi salvate. Pentru arborii de căutare potriviți (inclusiv arborii negru-roșu), această condiție este îndeplinită.

Se știe că implementările bazate pe tabelul hash au un timp mediu de O(1), care este mai bun decât implementările bazate pe arborele de căutare. Desigur, acest lucru nu garantează execuția de mare viteză a operațiunilor individuale: timpul de INSERT în cel mai rău caz este notat cu O(n). Procesul INSERT rulează o perioadă lungă de timp când factorul de umplere atinge punctul cel mai înalt și indexul tabelului hash trebuie reconstruit.

Apropo, aceste liste hash sunt proaste, deoarece pe baza lor este imposibil să se efectueze acțiuni suplimentare rapide MAX, MIN și un algoritm pentru parcurgerea tuturor perechilor salvate în ordinea descrescătoare sau crescătoare a tastelor.

Matrice

Matrice este o colecție ordonată de valori. Valorile dintr-o matrice se numesc elemente, iar fiecare element este caracterizat de o poziție numerică în matrice, numită index. Matricele în JavaScript sunt netipizate: elementele unei matrice pot fi de orice tip, iar elementele diferite ale aceleiași matrice pot avea tipuri diferite. Elementele de matrice pot fi chiar obiecte sau alte matrice, permițându-vă să creați structuri de date complexe, cum ar fi matrice de obiecte și matrice de matrice.

Indicii de matrice JavaScript încep de la zero și folosesc numere întregi de 32 de biți - primul element al matricei are indicele 0. Matricele JavaScript sunt dinamice: pot crește și micșora dimensiunea după cum este necesar; nu este nevoie să declarați dimensiuni fixe ale matricei atunci când le creați sau să realocați memorie atunci când dimensiunile lor se schimbă.

Matricele în JavaScript sunt o formă specializată de obiecte, iar indicii de matrice înseamnă puțin mai mult decât nume de proprietăți, care întâmplător sunt numere întregi.

Crearea de tablouri

Cel mai simplu mod de a crea o matrice este de a folosi un literal, care este o listă simplă de elemente de matrice, separate prin virgulă, înconjurate de paranteze drepte. Valorile dintr-un literal de matrice nu trebuie să fie constante - pot fi orice expresii, inclusiv literale obiect:

Var gol = ; // Matrice goală var numere = ; // Matrice cu cinci elemente numerice var misc = [ 1.1, true, "a", ]; // 3 elemente de diferite tipuri + virgulă finală var bază = 1024; var table = ; // Matrice cu variabile var arrObj = [, ]; // 2 tablouri în interior care conțin obiecte

Sintaxa literală a matricei vă permite să inserați o virgulă finală opțională, de ex. literalul [,] se potrivește cu o matrice cu două elemente, nu trei.

O altă modalitate de a crea o matrice este apelarea constructorului matrice(). Puteți apela constructorul în trei moduri diferite:

    Apelați constructorul fără argumente:

    Var arr = nou Array();

    În acest caz, va fi creată o matrice goală, echivalentă cu literalul.

    Apelați constructorul cu un singur argument numeric care specifică lungimea matricei:

    Var arr = nou Array(10);

    În acest caz, va fi creată o matrice goală de lungimea specificată. Această formă de apelare a constructorului Array() poate fi folosită pentru a pre-aloca memorie pentru o matrice dacă numărul elementelor sale este cunoscut dinainte. Rețineți că aceasta nu stochează nicio valoare în matrice.

    Specificați în mod explicit valorile primelor două sau mai multe elemente ale matricei sau ale unui element nenumeric în apelul constructorului:

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

    În acest caz, argumentele către constructor devin valorile elementelor noii matrice. Utilizarea literalelor matrice este aproape întotdeauna mai ușoară decât utilizarea constructorului Array().

Citirea și scrierea elementelor de matrice

Elementele matricei sunt accesate cu ajutorul operatorului. În stânga parantezelor trebuie să existe o referință de matrice. În paranteze trebuie să existe o expresie arbitrară care returnează o valoare întreagă nenegativă. Această sintaxă este utilă atât pentru citirea, cât și pentru scrierea valorii unui element de matrice. Prin urmare, toate următoarele instrucțiuni JavaScript sunt valide:

// Creați o matrice cu un element var arr = ["world"]; // Citiți elementul 0 var value = arr; // Scrieți valoarea elementului 1 arr = 3,14; // Scrieți valoarea elementului 2 i = 2; arr[i] = 3; // Scrieți valoarea elementului 3 arr = "bună ziua"; // Citiți elementele 0 și 2, scrieți valoarea în elementul 3 arr] = arr;

Permiteți-mi să vă reamintesc că tablourile sunt un tip specializat de obiect. Parantezele pătrate folosite pentru a accesa elementele matricei acționează exact la fel ca parantezele pătrate folosite pentru a accesa proprietățile obiectului. Interpretul JavaScript convertește indecșii numerici din paranteze în șiruri de caractere — indexul 1 devine șirul „1” — și apoi folosește șirurile ca nume de proprietate.

Nu este nimic special în conversia indicilor numerici în șiruri de caractere: puteți face același lucru cu obiectele obișnuite:

Var obj = (); // Creați un obiect simplu obj = "unul"; // Indexați-l cu numere întregi

Lucrul cu matrice este că atunci când utilizați nume de proprietate care sunt numere întregi nenegative, matricele determină automat valoarea proprietății lungime. De exemplu, mai sus am creat o matrice arr cu un singur element. Apoi a atribuit valori elementelor sale la indecșii 1, 2 și 3. Ca urmare a acestor operațiuni, valoarea proprietății lungime a tabloului s-a schimbat la 4.

Ar trebui să distingeți clar indecșii dintr-o matrice de numele proprietăților obiectului. Toți indicii sunt nume de proprietăți, dar numai proprietățile cu nume reprezentate prin numere întregi sunt indici. Toate tablourile sunt obiecte și le puteți adăuga proprietăți cu orice nume. Cu toate acestea, dacă atingeți proprietăți care sunt indici de matrice, matricele răspund prin actualizarea valorii proprietății lungime după cum este necesar.

Vă rugăm să rețineți că numerele negative și non-întregi pot fi folosite ca indici de matrice. În acest caz, numerele sunt convertite în șiruri de caractere, care sunt folosite ca nume de proprietăți.

Adăugarea și eliminarea elementelor de matrice

Am văzut deja că cel mai simplu mod de a adăuga elemente într-o matrice este de a atribui valori noilor indici. De asemenea, puteți utiliza metoda pentru a adăuga unul sau mai multe elemente la sfârșitul matricei. Apăsaţi():

Var arr = ; // Creați o matrice goală arr.push("zero"); // Adăugați o valoare la final arr.push("one",2); // Adăugați încă două valori

De asemenea, puteți adăuga un element la sfârșitul matricei prin atribuirea unei valori elementului arr. Pentru a insera un element la începutul unui tablou, puteți folosi metoda unshift(), care mută elementele existente în matrice în poziții cu indici mai mari.

Puteți șterge elemente de matrice folosind operatorul de ștergere, la fel ca proprietățile obișnuite ale obiectului:

Var arr = ; șterge arr; 2 în arr; // fals, indexul 2 din matrice nu este definit arr.length; // 3: operatorul de ștergere nu modifică proprietatea de lungime a matricei

Eliminarea unui element este similară (dar ușor diferită) cu alocarea valorii nedefinite acelui element. Rețineți că aplicarea operatorului de ștergere la un element de matrice nu modifică valoarea proprietății lungime și nici nu deplasează în jos elementele cu indici mai mari pentru a umple golul lăsat prin ștergerea elementului.

De asemenea, este posibil să eliminați elemente la sfârșitul unui tablou prin simpla atribuire a unei noi valori proprietății lungime. Array-urile au o metodă pop()(opusul metodei push()), care reduce lungimea matricei cu 1 și returnează valoarea elementului eliminat. Există și o metodă schimb()(opusul lui unshift()), care elimină elementul de la începutul matricei. Spre deosebire de operatorul de ștergere, metoda shift() mută toate elementele în jos într-o poziție sub indexul lor curent.

În cele din urmă, există o metodă multifuncțională lipitură(), care vă permite să inserați, să ștergeți și să înlocuiți elemente de matrice. Schimbă valoarea proprietății lungime și mută elementele matricei la indecși mai mici sau mai mari, după cum este necesar. Ne vom uita la toate aceste metode puțin mai târziu.

Matrice multidimensionale

JavaScript nu acceptă matrice multidimensionale „adevărate”, dar oferă o modalitate bună de a le simula folosind matrice de matrice. Pentru a accesa un element de date dintr-o matrice de matrice, pur și simplu utilizați operatorul de două ori.

De exemplu, să presupunem că matricea variabilă este o matrice de matrice de numere. Fiecare element al matricei[x] este o matrice de numere. Pentru a accesa un anumit număr dintr-o matrice, puteți utiliza expresia matrice [x][y]. Mai jos este un exemplu specific în care o matrice bidimensională este folosită ca tabelă de înmulțire:

// Creați o matrice multidimensională var table = new Array(10); // Există 10 rânduri în tabel pentru (var i = 0; i

Metode ale clasei Array

Standardul ECMAScript 3 definește Array.prototype ca un set de funcții convenabile pentru lucrul cu matrice, care sunt disponibile ca metode pe orice matrice. Aceste metode vor fi prezentate în următoarele subsecțiuni.

metoda join().

Metoda Array.join() convertește toate elementele matricei în șiruri de caractere, le unește și returnează șirul rezultat. Ca argument opțional, puteți trece un șir metodei care va fi folosită pentru a separa elementele din șirul rezultat. Dacă nu este specificat un șir delimitator, se folosește o virgulă. De exemplu, următorul fragment are ca rezultat șirul „1,2,3”:

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

metoda reverse().

Metoda Array.reverse() inversează ordinea elementelor dintr-o matrice și returnează o matrice reordonată. Permutarea se realizează direct în matricea originală, adică. Această metodă nu creează o nouă matrice cu elementele reordonate, ci mai degrabă le reordonează într-o matrice deja existentă. De exemplu, următorul fragment, folosind metodele reverse() și join(), are ca rezultat șirul „3,2,1”:

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

metoda sort().

Metoda Array.sort() sortează elementele din tabloul sursă și returnează tabloul sortat. Dacă metoda sort() este apelată fără argumente, sortarea se face în ordine alfabetică (elementele sunt convertite temporar în șiruri de caractere pentru comparare dacă este necesar). Elementele nedefinite sunt mutate la sfârșitul matricei.

Pentru a sorta în altă ordine decât alfabetică, puteți trece o funcție de comparație ca argument la metoda sort(). Această funcție stabilește care dintre cele două argumente ale sale ar trebui să apară primul în lista sortată. Dacă primul argument trebuie să vină înaintea celui de-al doilea, funcția de comparare trebuie să returneze un număr negativ. Dacă primul argument îl urmează pe al doilea într-o matrice sortată, atunci funcția trebuie să returneze un număr mai mare decât zero. Și dacă două valori sunt echivalente (adică ordinea lor nu contează), funcția de comparație ar trebui să returneze 0:

Var arr = ; arr.sort(); // Ordine alfabetică: 1111, 222, 33, 4 arr.sort(function(a,b) ( // Ordine numerică: 4, 33, 222, 1111 returnează a-b; // Returnează 0 // în funcție de ordinea de sortare a și b)); // Sortează în sens invers, de la cel mai mare la cel mai mic arr.sort(function(a,b) (return b-a));

Observați cât de convenabil este să utilizați o funcție fără nume în acest fragment. Funcția de comparare este folosită doar aici, deci nu este nevoie să-i dai un nume.

metoda concat().

Metoda Array.concat() creează și returnează o nouă matrice care conține elementele matricei originale pe care a fost apelat concat() și valorile oricăror argumente transmise la concat(). Dacă oricare dintre aceste argumente este el însuși o matrice, elementele sale sunt adăugate la tabloul returnat. Trebuie remarcat, totuși, că nu există o transformare recursivă a unei matrice de matrice într-o matrice unidimensională. Metoda concat() nu modifică tabloul original. Mai jos sunt câteva exemple:

Var arr = ; arr.concat(4, 5); // Returnează arr.concat(); // Întoarce arr.concat(,) // Întoarce arr.concat(4, ]) // Întoarce ]

metoda slice().

Metoda Array.slice() returnează o porțiune, sau un subbary, din tabloul specificat. Cele două argumente ale metodei specifică începutul și sfârșitul fragmentului returnat. Matricea returnată conține elementul al cărui număr este specificat în primul argument, plus toate elementele ulterioare, până la (dar fără a include) elementul al cărui număr este specificat în al doilea argument.

Dacă este dat un singur argument, tabloul returnat conține toate elementele de la poziția de început până la sfârșitul matricei. Dacă oricare dintre argumente este negativ, acesta determină numărul elementului relativ la sfârșitul matricei. Deci, argumentul -1 corespunde ultimului element al tabloului, iar argumentul -3 corespunde celui de-al treilea element al tabloului de la sfârșit. Aici sunt cateva exemple:

Var arr = ; arr.slice(0,3); // Returnează arr.slice(3); // Returnează arr.slice(1,-1); // Returnează arr.slice(-3,-2); // Întoarcere

metoda splice().

Metoda Array.splice() este o metodă generică care realizează inserarea sau ștergerea elementelor matricei. Spre deosebire de metodele slice() și concat(), metoda splice() modifică tabloul original pe care a fost apelată. Rețineți că metodele splice() și slice() au nume foarte asemănătoare, dar efectuează operații complet diferite.

Metoda splice() poate elimina elemente dintr-o matrice, poate introduce elemente noi sau poate face ambele în același timp. Elementele matricei sunt deplasate după cum este necesar pentru a crea o secvență continuă după inserare sau ștergere.

Primul argument al metodei splice() specifică poziția din matrice din care se va efectua inserarea și/sau ștergerea. Al doilea argument specifică numărul de elemente care ar trebui eliminate (tăiate) din matrice. Dacă al doilea argument este omis, toate elementele matricei de la specificat până la sfârșitul matricei sunt eliminate. Metoda splice() returnează o matrice a elementelor eliminate sau (dacă niciun element nu a fost eliminat) o matrice goală.

Primele două argumente ale metodei splice() specifică elementele matricei care trebuie eliminate. Aceste argumente pot fi urmate de orice număr de argumente suplimentare care specifică elementele care trebuie inserate în matrice, începând cu poziția specificată în primul argument.

Var arr = ; arr.splice(4); // Return , arr = arr.splice(1,2); // Return , arr = arr.splice(1,1); // Întoarcere ; arr = arr = ; arr.splice(2,0,"a","b"); // Întoarcere ; arr =

metodele push() și pop().

Metodele push() și pop() vă permit să lucrați cu matrice ca și cum ar fi stive. Metoda push() adaugă unul sau mai multe elemente noi la sfârșitul matricei și returnează noua lungime. Metoda pop() efectuează operația inversă - elimină ultimul element al matricei, reduce lungimea matricei și returnează valoarea pe care a eliminat-o. Rețineți că ambele metode modifică matricea originală, mai degrabă decât să creeze o copie modificată a acesteia.

metodele unshift() și shift().

Metodele unshift() și shift() se comportă aproape la fel ca push() și pop(), cu excepția faptului că inserează și elimină elemente la începutul matricei, mai degrabă decât la sfârșit. Metoda unshift() mută elementele existente la indici mai mari pentru a elibera spațiu, adaugă elementul sau elementele la începutul matricei și returnează noua lungime a matricei. Metoda shift() elimină și returnează primul element al matricei, deplasând toate elementele ulterioare cu o poziție în jos pentru a ocupa spațiul liber la începutul matricei.

Am descris doar câteva dintre metodele de lucru cu matrice.

Aici vom vorbi despre adăugarea și eliminarea elementelor de matrice. Despre răsturnarea și sortarea unei matrice, precum și despre tăierea, înlocuirea și combinarea matricelor.

Adăugarea de elemente la o matrice.

Puteți folosi 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 matricei sunt numerotate începând de la zero și lungimeîncă una. Lungimeîntotdeauna echivalent indice + 1, deci este foarte ușor să adăugați un nou element la sfârșitul matricei. În mod ciudat, 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, aceasta va adăuga 95 de sloturi goale și elementul „Lindsey Buckingham” la sfârșitul matricei. După aceasta vom obține o lungime de 100. O altă modalitate de a adăuga un nou element la matrice este să folosiți metoda 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 element folosind lipitură():

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

Când al doilea argument este 0, înseamnă că niciun element nu va fi eliminat și, prin urmare, orice argument ulterioar va fi adăugat la matrice la 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 sfârșitul unui tablou, puteți 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ă.

De asemenea, puteți utiliza lipitură() metodă:

Var myArray = ["cassava", "nucsoara", "lupin", "rhubarb"]; myArray.splice(2, 1); // elimina elementul cu index 2 console.log(myArray); // ["manioc", "nucșoară", "rubarbă"]

Spre deosebire de metoda lipitură(), care este folosit pentru a adăuga elemente, aici al doilea argument este 1, care spune că vrem să eliminăm elementul cu indicele 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; // șterge Eliza console.log(myArray.length); // 4 console.log(myArray); // ["Byte Bandit", nedefinit × 1, "Jeefo", "Michelangelo"]

Prima notă importantă: șterge() nu modifică lungimea matricei după eliminarea unui element (chiar dacă a fost ultimul element din matrice). Al doilea: șterge() modifică valoarea elementului de eliminat în nedefinit, deci la accesare myArray = nedefinit.

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

// Array Remove - De John Resig (Licențiat MIT) 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);

Poate doriți să vă uitați la soluția lui Viral Patel, una dintre funcțiile din Underscore.js sau grep() de la jQuery.

În plus, în JavaScript exista o metoda schimb(), care elimină primul element din tablou și returnează valoarea acestuia. Să ne uităm la cod:

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 i-am stocat valoarea în variabila noastră firstItem. Lungimea matricei s-a schimbat de la 4 la 3.

Această metodă poate fi utilă împreună cu metoda Apăsaţi(). Folosind-le împreună, putem pune în coadă eficient elementele într-o matrice. Menținem lungimea matricei eliminând un element 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 crea cozi în sens invers adăugând elemente la început și eliminând de la sfârșitul matricei.

Inversarea și sortarea elementelor matricei.

Pentru a inversa elementele dintr-o matrice putem folosi verso():

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

Este posibil să sortați elementele matricei în ordine alfabetică folosind metoda fel():

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

Dar asta nu va funcționa cu numere.

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

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

Funcția 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ă introdusă în fel(), o matrice care contine numere va fi sortata corect.

Combinarea matricelor.

Putem combina 2 sau mai multe matrice și obținem 1 matrice care conține elementele matricelor unite. 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"]

Diviziune matrice.

Putem crea o matrice nouă care să conțină 1 sau mai multe elemente dintr-o matrice existentă folosind funcția felie():

Var myArray = ["Voce", "Bas", "Chitara", "Tobe", "Mere", "Portocale"]; var myNewArray = myArray.slice(4); console.log(myNewArray); // ["Mere", "Portocale"]

Metodă felie() ia 1 sau 2 argumente. Dacă se trece 1 argument (index), atunci se creează o nouă matrice din toate elementele celui vechi, pornind de la acest index. Dacă se trec 2 argumente, atunci se creează o nouă matrice din elementele începând de la primul argument și până la elementul cu indexul trecut în al doilea parametru, fără a include ultimul. Pentru a fi mai clar, să ne uităm la codul de mai jos:

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

Înlocuirea elementelor dintr-o matrice.

Folosim lipitură() pentru a elimina elemente dintr-o matrice, dar putem înlocui și un element din matrice cu elemente noi:

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

Metodă lipitură() returnează întotdeauna o matrice care conține elementele care au fost eliminate. Linia 2 va returna 1 element „Brian Bell”.

Concluzie

Aceste articole descriu metode de lucru cu matrice în JavaScript. Există câteva elemente suplimentare pe care le puteți vedea pe MDN pe care nu le-am inclus în această postare. Ele funcționează doar în IE9+, așa că s-ar putea să nu fie utile.

Ceva de adăugat? Sau cunoașteți vreo bibliotecă interesantă care vă va ajuta să gestionați matricele? Vă rugăm să comentați!