Invia esempi di JavaScript. Array in JavaScript. Metodi della classe Array

È possibile lavorare con gli array attraverso vari metodi forniti dal costruttore Array.

Metodi pop/push e shift/unshift

Diamo un'occhiata ai metodi pop() e push(). Questi metodi ti consentono di lavorare con gli array come se fossero stack. Uno stack è una struttura dati in cui l'accesso agli elementi è organizzato secondo il principio LIFO (inglese: last in - first out, “last in - first out”). Il principio di funzionamento della pila può essere paragonato a una pila di piatti: per prendere il secondo dall'alto è necessario rimuovere quello superiore. Il funzionamento è mostrato in figura:

E quindi torniamo a considerare i metodi push() e pop(). Il metodo push() aggiunge uno o più nuovi elementi alla fine dell'array e ne restituisce la nuova lunghezza. Metodo pop(): rimuove l'ultimo elemento dell'array, riduce la lunghezza dell'array e restituisce il valore rimosso. Vale la pena notare che entrambi questi metodi modificano l'array sul posto, anziché crearne una copia modificata.

Var foo = ; // foo: foo.push(1,2); // foo: restituisce 2 foo.pop(); // foo: restituisce 2 foo.push(3); // foo: restituisce 2 foo.pop(); // foo: restituisce 3 foo.push(); // foo: ] Restituisce 2 foo.pop() // foo: Restituisce foo.pop(); // foo: Restituisce 1 var frutti = ["pere", "banane", "mele"]; var scelto = frutti.pop(); document.write("Hai scelto il mio " + scelto);

Tentativo " I metodi shift() e unshift() si comportano in modo molto simile a pop() e push(), tranne per il fatto che inseriscono e rimuovono elementi all'inizio dell'array. Il metodo unshift() cambia elementi esistenti di lato indici di grandi dimensioni

per fare spazio a nuovi elementi, aggiunge uno o più elementi all'inizio dell'array e restituisce la nuova lunghezza dell'array. Il metodo shift() rimuove il primo elemento di un array e ne restituisce il valore, spostando tutti gli elementi successivi in ​​modo da occupare lo spazio libero all'inizio dell'array.

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

Il metodo Array.join() viene utilizzato per unire gli elementi di un array in un'unica stringa. Al metodo può essere passato un argomento stringa opzionale, che verrà utilizzato per separare gli elementi nella stringa. Se il delimitatore non è specificato, il carattere delimitatore predefinito quando si chiama il metodo sarà una virgola.

Var a = ["Vento","Pioggia","Fuoco"]; var miaVar1 = a.join(); //"Vento,Pioggia,Fuoco" var myVar2 = a.join(", "); //"Vento, Pioggia, Fuoco" var myVar3 = a.join(" + "); //"Vento + Pioggia + Fuoco" document.write(myVar1 + "
" + miaVar2 + "
" + miaVar3); Prova "

Il metodo Array.join() è l'inverso del metodo String.split(), che crea un array suddividendo una stringa in frammenti.

metodo inverso

Il metodo Array.reverse() inverte l'ordine degli elementi in un array e restituisce un array con gli elementi riorganizzati. Questo metodo non crea un nuovo array con elementi riordinati, ma piuttosto li riordina in un array esistente.

Var mioArr = ["uno", "due", "tre"]; document.write(myArr.reverse());

Tentativo "

metodo concat

Il metodo Array.concat() crea e restituisce un nuovo array contenente gli elementi dell'array originale su cui è stato chiamato concat(), incrementato sequenzialmente con i valori di tutti gli argomenti passati a concat(). Se uno qualsiasi di questi argomenti è esso stesso un array, verranno aggiunti tutti i suoi elementi. I nomi degli array vengono utilizzati come argomenti e sono specificati nell'ordine in cui devono essere combinati i loro elementi.

Vara = ; a.concat(4, 5) //Restituisce a.concat(); //stessa cosa - restituisce a.concat(,) //Restituisce

metodo di ordinamento

Il metodo Array.sort() ordina gli elementi dell'array sul posto e restituisce l'array ordinato. Se il metodo sort() viene chiamato senza argomento, ordina gli elementi dell'array in ordine alfabetico (convertendoli temporaneamente in stringhe per eseguire il confronto). Il metodo sort() può accettare come argomento una funzione di confronto, che determina l'ordinamento degli elementi.

Var a = ["Kiwi", "Arance", "Pere"]; a.sort(); var s = a.join(", "); //Arance, pere, kiwi document.write(s); //esempio con numeri var myArr = ; mioArr.sort(); document.write(mioArr); //1,10,2 Prova »

Per ordinare in un ordine diverso da quello alfabetico, puoi passare una funzione di confronto come argomento al metodo sort(). Tuttavia, va tenuto presente che dovrai scrivere tu stesso la funzione di confronto. Questa funzione deve avere due parametri perché imposta quale dei suoi due argomenti deve apparire per primo nell'elenco ordinato. Per facilitare la comprensione e la scrittura di tale funzione, esistono diverse regole in base alle quali verrà determinato l'ordine degli elementi:

• Se il primo argomento deve precedere il secondo, la funzione di confronto restituisce numero negativo(se a
• Se il primo argomento deve seguire il secondo, allora la funzione di confronto restituisce un numero positivo (se a > b)
• Se due valori sono equivalenti (cioè il loro ordine non è importante), la funzione di confronto restituisce 0 (se a == b)

Per confronto, la funzione utilizza gli elementi dell'array come argomenti:

Function foo(a,b) ( //definisce la funzione di controllo if (a b) return 1; return 0; //if a == b ) var a = ; a.sort(foo); //solo il nome della funzione viene passato come argomento document.write(a.join(", ")); //scrivi la stessa cosa più brevemente var a = ; a.sort(function(a,b) ( //usa la funzione anonima return a - b; //la funzione restituisce il valore 0 )); documento.write(a); //1,2,5,10 Prova »

La prima voce nell'esempio è scritta in questo modo per facilitare la comprensione del funzionamento. Nota quanto sia conveniente utilizzare una funzione anonima nel secondo frammento. Viene chiamato una sola volta, quindi non è necessario dargli un nome.

Nota: se nell'array sono presenti elementi non definiti, questi vengono spostati alla fine dell'array.

metodo delle fette

Il metodo Array.slice() viene utilizzato per copiare una sezione specificata da un array e restituisce un nuovo array contenente gli elementi copiati. L'array originale non cambia.

Sintassi del metodo:

ArrayName.slice(inizio, fine);

Array_name deve essere sostituito con il nome dell'array da cui si desidera estrarre un insieme specifico di elementi per il nuovo array. Il metodo accetta due argomenti che specificano l'inizio e la fine dell'array restituito. Il metodo copia una sezione dell'array, dall'inizio alla fine, esclusa la fine. Se viene fornito un solo argomento, l'array restituito conterrà tutti gli elementi dalla posizione specificata fino alla fine dell'array. Puoi usare indici negativi: vengono contati dalla fine dell'array.

Var arr = ; arr.fetta(0,3); //Restituisce arr.slice(3); //Restituisce arr.slice(1,-1); //Restituisce arr.slice(-3,-2); //Restituisce

metodo di giunzione

Il metodo Array.splice() lo è metodo universale per lavorare con gli array. Modifica l'array sul posto anziché restituire un nuovo array modificato come fanno i metodi slice() e concat(). Il metodo di giunzione può rimuovere elementi da un array, inserire nuovi elementi, sostituire elementi, uno alla volta e simultaneamente. Restituisce un array costituito dagli elementi rimossi, se nessun elemento è stato rimosso restituirà un array vuoto.

Sintassi del metodo:

Array_name.splice(indice, quantità, elem1, ..., elemN);

Il primo argomento specifica l'indice nell'array da cui iniziare a inserire o rimuovere elementi. Il secondo argomento specifica il numero di elementi che devono essere rimossi dall'array a partire dall'indice specificato nel primo argomento. Se il secondo argomento è 0, nessun elemento verrà rimosso; Se il secondo argomento viene omesso, tutti gli elementi dell'array dall'indice specificato fino alla fine dell'array verranno rimossi. Quando si utilizza un numero di posizione negativo, gli elementi verranno contati dalla fine dell'array.

Frutti Var = ["arance", "mele", "pere", "uva"]; var cancellato = frutti.splice(2,2); //restituisce ["pere", "uva"] document.write(eliminato); var arr = ; arr.splice(4); //Restituisce; l'array è diventato: arr.splice(1,2); //Restituisce; l'array è diventato: arr.splice(1,1); //Restituisce; l'array è diventato: Prova »

I primi due argomenti del metodo splice() specificano gli elementi dell'array da rimuovere. Questi due argomenti possono essere seguiti da un numero qualsiasi di argomenti aggiuntivi che specificano gli elementi da inserire nell'array, a partire dalla posizione specificata dal primo argomento.

Frutti Var = ["arance", "mele"]; frutta.splice(2,0, "cocomeri"); //restituisce document.write(frutti); //divenne ["arance", "mele", "angurie"] var arr = ; arr.splice(2,0,"a","b"); //Restituisce; è diventato arr.splice(2,2,); //Restituisce ["a","b"]; è diventato ,3,4,5] Prova »

Vale la pena notare che, a differenza di concat(), il metodo splice() non si divide in singoli elementi array passati come argomenti. Cioè, se al metodo viene passato un array da inserire, inserisce l'array stesso e non gli elementi di quell'array.

metodo toString

Il metodo toString() converte gli elementi di un array in una stringa utilizzando una virgola come carattere delimitatore.

Var arr = ["Latte","Pane","Biscotti"]; var cibo = arr.toString(); document.write(cibo); //Latte,Pane,Biscotti Prova »

Si noti che il metodo restituisce la stessa stringa di join() quando viene chiamato senza argomenti.

indiceOf e ultimoIndiceOf

Il metodo indexOf restituisce l'indice di un elemento il cui valore è uguale al valore passato come argomento al metodo.

Sintassi dei metodi indexOf() e lastIndexOf():

nome_array.indexOf(elemento_ricerca, indice) nome_array.lastIndexOf(elemento_ricerca, indice)

Il primo argomento del metodo specifica il valore dell'elemento di cui si vuole trovare l'indice, il secondo argomento (facoltativo) specifica l'indice da cui inizierà la ricerca. Se sono presenti più occorrenze identiche, viene selezionato l'indice più piccolo (il primo). Se non viene trovato un elemento con il valore desiderato, il metodo restituirà -1. All'interno del metodo, per la ricerca viene utilizzato il confronto rigoroso (===).

Vara = ; a.indiceDi(3); //restituisce 2 a.indexOf(3,4); //restituisce 6 a.indexOf(35); //return -1: non esiste alcun elemento con questo valore a.indexOf(2); // 1

Il metodo lastIndexOf() restituisce anche l'indice dell'elemento, il cui valore è uguale al valore passato al metodo come argomento. L'unica differenza è che il metodo lastIndexOf() seleziona l'indice più grande (ultimo).

Vara = ; a.lastIndexOf(3); //restituisce 7 a.lastIndexOf(35); //return -1: non esiste alcun elemento con questo valore a.lastIndexOf(2); // 6

Metodi iteratori

I metodi descritti di seguito sono iteratori. Tutti i browser moderni dispongono di metodi per lavorare con gli array progettati per scorrere gli elementi ed eseguire varie azioni su di essi. Questi metodi sono forEach(), map(), filter(), Every(), some, reduce() e reduceRight().

Iterano sugli elementi dell'array a partire da 0 fino a length - 1 e, se l'elemento esiste, lo passano alla funzione del gestore di callback.

perEach

Sintassi del metodo:

ArrayName.forEach(callback, thisArg)

Il primo argomento specifica la funzione di callback che il metodo forEach() chiamerà per ciascun elemento dell'array. È necessario scrivere personalmente l'implementazione della funzione del gestore chiamata. La funzione chiamata deve avere tre parametri: il primo parametro prende come argomento il valore dell'elemento dell'array, il secondo l'indice dell'elemento e il terzo l'array stesso. Tuttavia, se devi utilizzare solo i valori degli elementi dell'array, puoi scrivere una funzione con un solo parametro. Il secondo argomento - thisArg (facoltativo) verrà passato come valore di this.

Var arr = ; funzione foo(valore) ( var somma = valore * questo; return document.write(somma + "
"); ) arr.forEach(foo, 5); //il secondo argomento verrà passato come valore di questo //esempio con tre parametri var a = ; a.forEach(function(el, idx, a) ( document .write( "a["+idx+"] = "+el+" in ["+a+"]
"); )); Tentativo "

filtro

Sintassi del metodo:

Nome_array.filter(callback, thisObject)

Il metodo filter() crea e restituisce un nuovo array che conterrà solo quegli elementi dell'array per i quali la funzione di callback restituisce true.

Funzione èGrande(elemento, indice, array) ( //restituisce numeri maggiori o uguali a 10 return (elemento >= 10); //se il valore dell'elemento è maggiore o uguale a 10, l'espressione restituirà true ) var filtered = .filter(isBig) ; //filtrato

mappa

Il metodo map() crea e restituisce un nuovo array, che consisterà nei risultati della chiamata alla funzione callback(item, idx, ar) per ciascun elemento dell'array.

Vara = ; var b = a.map(function(item, idx, arr) ( return item * item; )); // b =

tutti e alcuni

Il metodo any() restituisce true se, per tutti gli elementi dell'array, la funzione specificata utilizzata per verificarli restituisce true.

Il metodo some() restituisce true se uno o più elementi nella funzione specificata restituiscono true durante il test.

Vara = ; a.every(function(x) ( return x 10; )) //true: un numero > 10

ridurre e ridurreDestra

Sintassi del metodo:

nome_array.reduce(callback, valoreiniziale) nome_array.reduceRight(callback, valoreiniziale)

Si applica il metodo reduce() funzione specificata(callback) in relazione a due valori nell'array contemporaneamente, ripetendo gli elementi da sinistra a destra, mantenendo un risultato intermedio.

Argomenti della funzione di callback: (previousValue, currentItem, indice, array)

• previousValue - il risultato restituito della funzione di callback (noto anche come risultato intermedio)
• currentItem - elemento corrente dell'array (gli elementi sono ordinati da sinistra a destra)
• indice - indice dell'elemento corrente
• array - array elaborato

valoreiniziale è l'oggetto utilizzato come primo argomento della prima chiamata alla funzione di callback. In poche parole, il valore di previousValue quando viene chiamato per la prima volta è uguale a previousValue. Se non esiste il valore iniziale, allora è uguale al primo elemento dell'array e la ricerca inizia dal secondo:

Vara = ; function foo(Numprec,Numcur) ( sum = Numprec + Numcur; alert(sum); return sum; ) var result = a.reduce(foo, 0); document.write(risultato);

Tentativo "

• Diamo un'occhiata a come funziona questo esempio. I primi argomenti della funzione foo sono:
• prevNum = 0 (poiché il valore iniziale è 0)

1 viene aggiunto al numero 0. Questo risultato (somma: 1) verrà passato come prevNum alla successiva esecuzione della funzione. E così via fino ad arrivare all'ultimo elemento. Il risultato restituito è l'importo da ultimo lancio, saranno 15 (1+2+3+4+5).

Il metodo reduceRight funziona in modo simile al metodo reduce, ma attraversa l'array da destra a sinistra:

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

In JavaScript. Qui continueremo la nostra conoscenza con gli Array. Parliamo della proprietà length: come scoprirlo: quanti elementi contiene l'Array?

Impariamo come aggiungere elementi all'inizio e alla fine dell'array: questi sono rispettivamente i metodi unshift e push.

Ed anche utilizzando i metodi shift e pop possiamo rimuovere elementi dall'inizio e dalla fine dell'Array!

Essenzialmente un Array è un oggetto costituito da un certo numero di elementi diversi.

La proprietà length permette di conoscere il numero di elementi nell'Array.

Ad esempio, prendiamo l'array di sette giorni della settimana, a noi familiare dall'argomento precedente.

var giorni = ["Lun." , "Mar.";

Scopriamo e visualizziamo il numero di elementi dell'array. Per fare ciò è necessario, come vedi nell'esempio seguente, creare una variabile il cui valore sarà l'array che ci interessa, per il quale, a sua volta, viene specificata la proprietà length.

array.length - questo codice ci fornisce il numero di elementi dell'array (Dove vettore - Nome dell'array) .

var giorni = ["Lun." , "Martedì.", "Mer.", "Giov.", "Ven.", "Sab.", "Dom."] ;

conteggio var = giorni.lunghezza;

document.write(conteggio);

Pertanto, nella variabile count abbiamo inserito un numero pari al numero di elementi dell'Array.

Ecco come funziona la proprietà length.

Metodo Push: aggiunge un elemento alla fine dell'array.

Per iniziare a lavorare con i metodi per aggiungere elementi, è necessario creare una sorta di Array.

Di seguito ho creato un array "Amici" - friends .

, "Vyacheslav", "Alexey"] ;

Ora dobbiamo aggiungere un elemento, cioè un altro Nome, alla fine dell'Array.

Esiste un metodo push per questo: aggiunge un elemento alla fine dell'array. Sembra questo:

, "Vyacheslav", "Alexey"];

amici.push("Giacobbe"); /*Aggiunge un elemento alla fine dell'Array*/

document.write(+amici.lunghezza);

documento.write("

" + friends); /*Visualizza l'intero array*/

documento.write("

" + friends); /*Emette in output l'ultimo quinto elemento dell'array*/

Nastya, Grigory, Vyacheslav, Alexey, Yakov

Yakov

Per testare il funzionamento del metodo push nell'esempio sopra, abbiamo visualizzato il numero di elementi dell'array di amici utilizzando la proprietà length: ce n'erano 5. Quindi abbiamo generato l'intero array di amici, così come l'ultimo elemento di Vettore .

Ora puoi vedere tu stesso che l'elemento è stato aggiunto alla fine dell'Array!

metodo unshift: aggiunge un elemento all'inizio dell'array.

Anche qui faremo riferimento agli amici Array.

var amici = ["Nastya", "Gregory", "Vyacheslav", "Alexey"] ;

Ora dobbiamo aggiungere un elemento all'inizio dell'Array. Esiste un metodo chiamato unshift per questo.

var amici = ["Nastya", "Grigory", "Vyacheslav", "Alexey"];

amici.unshift("Boris"); /*Aggiunge un elemento all'inizio dell'Array*/

document .write ("Il numero di elementi nell'array è " + friends .length );

documento.write("

" + friends); /*Visualizza l'intero array*/

documento.write("

" + friends); /*Emette in output il primo elemento dell'array*/

Il numero di elementi nell'Array è 5

Boris, Nastya, Grigory, Vyacheslav, Alexey

Boris

Per testare il funzionamento del metodo unshift, mostriamo in output il numero di elementi dell'array di amici utilizzando la proprietà length, quindi mostriamo l'intero array di amici, nonché il primo elemento dell'array (ricordiamo che la numerazione degli elementi dell'Array parte da 0) .

Ora, come puoi vedere, l'elemento è stato aggiunto all'inizio dell'Array!

metodo pop: rimuove l'ultimo elemento dall'array.

E ancora una volta stiamo lavorando con l'array "Amici".

var amici = ["Nastya", "Gregory", "Vyacheslav", "Alexey"] ;

Utilizzando il metodo pop rimuoviamo l'ultimo elemento dall'Array:

var amici = ["Nastya", "Grigory", "Vyacheslav", "Alexey"];

amici.pop(); /*Rimuove l'ultimo elemento dall'Array*/

document .write ("Il numero di elementi nell'array è " + friends .length );

documento.write("

" + friends); /*Visualizza l'intero array*/

documento.write("

" + friends); /*Emette in output l'ultimo elemento dell'array. Per fare ciò, prendi numero totale elementi dell'Array - friends.length e, poiché la numerazione nell'array parte da zero, sottraiamo 1 da questo numero */

Nastya, Grigory, Vyacheslav

Vyacheslav

Per rendere più chiaro il metodo pop, abbiamo nuovamente visualizzato il numero di elementi dell'Array utilizzando la proprietà length, quindi visualizzato l'intero array degli amici, senza rimuovere l'ultimo elemento.

E veniva visualizzato anche l'ultimo elemento dell'Array appena ottenuto . Per emettere l'ultimo elemento, utilizzando la proprietà length, abbiamo preso il numero totale di elementi rimanenti nell'Array (3) e abbiamo sottratto 1 da esso. Pertanto, abbiamo emesso l'ultimo elemento dell'array, il numero 2. Ma questo è il terzo elemento, poiché la numerazione nell'Array inizia da 0!!!

Il metodo shift rimuove il primo elemento dall'Array.

Davanti a noi, come prima, c'è l'array "Amici".

var amici = ["Nastya", "Gregory", "Vyacheslav", "Alexey"] ;

Utilizzando il metodo shift rimuoviamo il primo elemento dall'Array:

var amici = ["Nastya", "Grigory", "Vyacheslav", "Alexey"];

amici.shift(); /*Rimuove il primo elemento dall'Array*/

document .write ("Il numero di elementi nell'array è " + friends .length );

documento.write("

" + friends); /*Visualizza l'intero array*/

documento.write("

" + friends); /*Emette in output il primo elemento dell'array.*/

Il numero di elementi nell'Array è 3

Grigory, Vyacheslav, Alexey

Gregorio

E infine, per testare il funzionamento del metodo shift, produciamo il numero di elementi dell'array appena risultante utilizzando la proprietà length, quindi produciamo l'intero array di amici, senza rimuovere il primo elemento.

E ha anche visualizzato il primo elemento di Array . La numerazione nell'array inizia da 0!!!

Permettimi di ricordare a te e a me stesso un punto interessante di questo articolo!

Per trovare il numero/indice dell'ultimo elemento dell'Array è necessario tra i suoi elementi (cioè da) Sottrai uno!!!

Abbiamo già lavorato con questo nel punto dell'argomento.

Una buona opzione Un'illustrazione di questo punto sarà una continuazione dell'esempio dal punto dell'argomento in cui abbiamo esaminato l'array dei sette giorni della settimana.

var giorni = ["Lun." , "Martedì.", "Mer.", "Giov.", "Ven.", "Sab.", "Dom."] ;

conteggio var = giorni.lunghezza; /*Crea una variabile count nella quale inseriamo il numero di elementi dell'Array days*/

document .write ("Il numero di elementi nell'array dei giorni è " + count );

documento.write("

Il numero dell'ultimo elemento dell'array dei giorni è il numero " + (count - 1 ) );

Il numero di elementi nell'array dei giorni è 7

Il numero dell'ultimo elemento dell'Array è il numero 6

Quindi, con questo esempio, abbiamo notato ancora una volta il fatto che la numerazione nell'Array inizia da 0. E, come puoi vedere da questo esempio, il numero del settimo elemento dell'array è il numero 6.

Alla fine di questo argomento faremo anche i nostri compiti. Ancora una volta, prova a risolverlo da solo.

I compiti sulla rimozione da... e sull'aggiunta di elementi a un array in Javascript hanno il seguente contenuto:

1. Crea una serie di frutti: arancia, banana, pera.
2. Visualizza quanti al momento hai una vasta gamma di frutti.
3. Utilizzando i metodi appresi nella lezione precedente, aggiungi due frutti alla fine della serie: una mela e un ananas, e all'inizio della serie: un pompelmo.
4. Visualizza sullo schermo quanti frutti hai attualmente nell'assortimento.
5. Utilizzando le tecniche apprese nella lezione precedente, rimuovi l'ultimo e il primo elemento dall'array.
6. Visualizza sullo schermo quanti frutti hai attualmente nell'assortimento.

var frutto = ["Arancia","Banana","Pera"];
documento .write (frutta + "

" )
document .write("Attualmente nel mio carrello " + frutta.lunghezza + " frutta" + "

frutta .push("Mela", "Ananas"); // Aggiunge elementi alla FINE dell'array
fruit.unshift("Pompelmo"); // Aggiunge elementi all'INIZIO dell'array
documento .write (frutta + "

" )
document .write("Attualmente nel mio carrello " + frutta.lunghezza + " frutta" + "

frutta.pop(); // Rimuove l'ULTIMO elemento dall'Array
frutta.shift(); // Rimuove il PRIMO elemento dall'Array
documento .write (frutta + "

" )
document .write("Attualmente nel mio carrello " + frutta.lunghezza + "frutta" );

Arancia, Banana, Pera

Attualmente nel mio carrello sono presenti 3 frutti

Pompelmo, Arancia, Banana, Pera, Mela, Ananas

Attualmente nel mio carrello sono presenti 6 frutti

Arancia, Banana, Pera, Mela

Al momento nel mio carrello ci sono 4 frutti

Il metodo push() aggiunge uno o più elementi alla fine dell'array e restituisce la nuova lunghezza dell'array.

Sintassi arr .push(elemento1 [, ...[, elementoN ]]) parametri elemento N Elementi da aggiungere alla fine dell'array. Valore restituito var verdure = ["pastinaca", "patata"]; var moreVegs = ["sedano", "barbabietola rossa"]; // Unisci il secondo array nel primo // Equivalente a verdure.push("sedano", "barbabietola"); Array.prototype.push.apply(verdure, moreVegs); console.log(verdure); // ["pastinaca", "patata", "sedano", "barbabietola"] Utilizzo di un oggetto come array

Come accennato in precedenza, il push è intenzionalmente generico e possiamo usarlo a nostro vantaggio. Array.prototype.push può funzionare perfettamente con un oggetto, come mostra questo esempio. Tieni presente che non stiamo creando un array per contenere una raccolta di oggetti. Invece, memorizziamo la raccolta sull'oggetto stesso e usiamo call Array.prototype.push per ingannare il metodo facendogli credere che abbiamo a che fare con un array, e funziona semplicemente, grazie al fatto che JavaScript ci consente di impostare il contesto di esecuzione , comunque ci fa piacere.

Var obj = ( length: 0, addElem: funzione addElem(elem) ( // obj.length viene incrementato automaticamente // ogni volta che viene aggiunto un elemento. .push.call(this, elem); ) ); // Aggiungiamo alcuni oggetti vuoti solo per illustrare obj.addElem(); obj.addElem());

Si noti che sebbene obj non sia un array, il metodo push incrementa con successo il valore della lunghezza di obj come se avessimo a che fare con un array reale.

CaratteristicheCompatibilità con il browser Funzionalità Visualizzazione Web Android Chrome per dispositivi mobili Android Edge Firefox per sistema operativo Android Sistema Android Negozio online Samsung Safari per iOS

Array

Un array è una raccolta ordinata di valori. I valori in un array sono chiamati elementi, e ogni elemento è caratterizzato da una posizione numerica nell'array, chiamata indice. Gli array in JavaScript non sono tipizzati: gli elementi di un array possono essere di qualsiasi tipo e diversi elementi dello stesso array possono avere tipi diversi. Gli elementi dell'array possono anche essere oggetti o altri array, consentendo di creare strutture di dati complesse come array di oggetti e array di array.

Gli indici degli array JavaScript iniziano da zero e utilizzano numeri interi a 32 bit: il primo elemento dell'array ha indice 0. Gli array JavaScript sono dinamici: possono aumentare e diminuire le dimensioni secondo necessità; non è necessario dichiarare dimensioni fisse degli array durante la loro creazione o riallocare la memoria quando le loro dimensioni cambiano.

Gli array in JavaScript sono una forma specializzata di oggetti e gli indici di array significano poco più che semplici nomi di proprietà, che guarda caso sono numeri interi.

Creazione di array

Il modo più semplice per creare un array è utilizzare un valore letterale, ovvero un semplice elenco di elementi dell'array separati da virgole e racchiusi tra parentesi quadre. I valori in un valore letterale di array non devono essere costanti: possono essere qualsiasi espressione, compresi i valori letterali oggetto:

Var vuoto = ; // Array vuoto var numeri = ; // Array con cinque elementi numerici var misc = [ 1.1, true, "a", ]; // 3 elementi diversi tipi+ virgola finale var base = 1024; tabella var = ; // Array con variabili var arrObj = [, ]; // 2 array all'interno contenenti oggetti

La sintassi letterale dell'array consente di inserire una virgola finale opzionale, ad es. il letterale [,] corrisponde a un array con due elementi, non tre.

Un altro modo per creare un array è chiamare il costruttore Array(). Puoi chiamare il costruttore in tre modi diversi:

Chiama il costruttore senza argomenti:

Var arr = nuovo Array();

In questo caso verrà creato un array vuoto, equivalente al letterale.

Chiama il costruttore con un singolo argomento numerico specificando la lunghezza dell'array:

Var arr = nuovo Array(10);

In questo caso, verrà creato un array vuoto della lunghezza specificata. Questa forma di chiamata al costruttore Array() può essere utilizzata per preallocare memoria per un array se il numero dei suoi elementi è noto in anticipo. Tieni presente che questo non memorizza alcun valore nell'array.

Specificare esplicitamente i valori dei primi due o più elementi dell'array o di un elemento non numerico nella chiamata del costruttore:

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

In questo caso gli argomenti del costruttore diventano i valori degli elementi del nuovo array. Usare valori letterali di array è quasi sempre più semplice che usare il costruttore Array().

Lettura e scrittura di elementi di array

È possibile accedere agli elementi dell'array utilizzando l'operatore. A sinistra delle parentesi deve esserci un riferimento all'array. All'interno delle parentesi deve esserci un'espressione arbitraria che restituisce un valore intero non negativo. Questa sintassi è utile sia per leggere che per scrivere il valore di un elemento dell'array. Pertanto, tutte le seguenti istruzioni JavaScript sono valide:

// Crea un array con un elemento var arr = ["world"]; // Leggi l'elemento 0 var value = arr; // Scrive il valore nell'elemento 1 arr = 3.14; // Scrive il valore nell'elemento 2 i = 2; arr[i] = 3; // Scrive il valore nell'elemento 3 arr = "ciao"; // Leggi gli elementi 0 e 2, scrivi il valore nell'elemento 3 arr] = arr;

Lascia che ti ricordi che gli array sono un tipo di oggetto specializzato. Le parentesi quadre, utilizzate per accedere agli elementi dell'array, funzionano esattamente come parentesi quadre, utilizzato per accedere alle proprietà dell'oggetto. L'interprete JavaScript converte gli indici numerici tra parentesi in stringhe (l'indice 1 diventa la stringa "1") e quindi utilizza le stringhe come nomi di proprietà.

Non c'è niente di speciale nel convertire indici numerici in stringhe: puoi fare lo stesso con oggetti normali:

Var oggetto = (); // Crea un oggetto semplice obj = "uno"; // Indicizzalo con numeri interi

Il problema degli array è che quando si utilizzano nomi di proprietà che sono numeri interi non negativi, gli array determinano automaticamente il valore della proprietà length. Ad esempio, sopra abbiamo creato un array arr con un singolo elemento. Ha quindi assegnato valori ai suoi elementi negli indici 1, 2 e 3. Come risultato di queste operazioni, il valore della proprietà length dell'array è cambiato in 4.

È necessario distinguere chiaramente gli indici in un array dai nomi delle proprietà dell'oggetto. Tutti gli indici sono nomi di proprietà, ma solo le proprietà con nomi rappresentati da numeri interi sono indici. Tutti gli array sono oggetti e puoi aggiungere loro proprietà con qualsiasi nome. Tuttavia, se si toccano proprietà che sono indici di array, gli array rispondono aggiornando il valore della proprietà length secondo necessità.

Tieni presente che i numeri negativi e non interi possono essere utilizzati come indici di array. In questo caso, i numeri vengono convertiti in stringhe, che vengono utilizzate come nomi di proprietà.

Aggiunta e rimozione di elementi dell'array

Abbiamo già visto che il modo più semplice per aggiungere elementi a un array è assegnare valori a nuovi indici. Puoi anche utilizzare il metodo push() per aggiungere uno o più elementi alla fine di un array:

Var arr = ; // Crea un array vuoto arr.push("zero"); // Aggiunge un valore alla fine arr.push("one",2); // Aggiungi altri due valori

Puoi anche aggiungere un elemento alla fine dell'array assegnando un valore all'elemento arr. Il metodo unshift() può essere utilizzato per inserire un elemento all'inizio di un array, spostando gli elementi esistenti nell'array in posizioni di indice più alte.

Puoi eliminare gli elementi dell'array utilizzando l'operatore delete, proprio come le normali proprietà degli oggetti:

Var arr = ; cancella arr; 2 arr; // false, l'indice 2 nell'array non è definito arr.length; // 3: l'operatore delete non modifica la proprietà length dell'array

Rimuovere un elemento è simile (ma leggermente diverso) all'assegnazione del valore indefinito a quell'elemento. Tieni presente che l'applicazione dell'operatore delete a un elemento dell'array non modifica il valore della proprietà length né sposta verso il basso gli elementi con indici più alti per riempire il vuoto lasciato dall'eliminazione dell'elemento.

È anche possibile rimuovere elementi alla fine di un array semplicemente assegnando un nuovo valore alla proprietà length. Gli array hanno un metodo pop() (l'opposto di push()), che riduce la lunghezza dell'array di 1 e restituisce il valore dell'elemento rimosso. Esiste anche un metodo shift() (l'opposto di unshift()), che rimuove l'elemento all'inizio dell'array. A differenza dell'operatore delete, il metodo shift() sposta tutti gli elementi in una posizione inferiore al loro indice corrente.

Infine, esiste un metodo multiuso splice() che consente di inserire, rimuovere e sostituire elementi di array. Modifica il valore della proprietà length e sposta gli elementi dell'array su indici inferiori o superiori secondo necessità. Vedremo tutti questi metodi un po 'più tardi.

Array multidimensionali

JavaScript non supporta "reale" array multidimensionali, ma ti consente di simularli bene utilizzando array di array. Per accedere a un elemento dati in un array di array, è sufficiente utilizzare l'operatore due volte.

Ad esempio, supponiamo che la matrice variabile sia una matrice di matrici di numeri. Ogni elemento di matrice[x] è un array di numeri. Per accedere a un numero specifico in un array, è possibile utilizzare l'espressione matrice[x][y]. Di seguito è riportato esempio concreto, Dove matrice bidimensionale usato come tabella di moltiplicazione:

// Crea un array multidimensionale var table = new Array(10); // Ci sono 10 righe nella tabella for(var i = 0; i

Metodi della classe Array

Lo standard ECMAScript 3 definisce Array.prototype come un insieme di funzioni utili per lavorare con gli array, disponibili come metodi su qualsiasi array. Questi metodi verranno presentati nelle sottosezioni seguenti.

metodo join()

Il metodo Array.join() converte tutti gli elementi dell'array in stringhe, li unisce e restituisce la stringa risultante. Come argomento facoltativo, puoi passare una stringa al metodo che verrà utilizzato per separare gli elementi nella stringa del risultato. Se non viene specificata una stringa delimitatrice, viene utilizzata una virgola. Ad esempio, il seguente frammento restituisce la stringa "1,2,3":

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

metodo inverso()

Il metodo Array.reverse() inverte l'ordine degli elementi in un array e restituisce un array riordinato. La permutazione viene eseguita direttamente nell'array originale, ovvero Questo metodo non crea un nuovo array con gli elementi riordinati, ma piuttosto li riordina in un array già esistente. Ad esempio, il seguente frammento, utilizzando i metodi reverse() e join(), restituisce la stringa "3,2,1":

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

metodo sort()

Il metodo Array.sort() ordina gli elementi nell'array di origine e restituisce l'array ordinato. Se il metodo sort() viene chiamato senza argomenti, l'ordinamento viene eseguito in ordine alfabetico (gli elementi vengono temporaneamente convertiti in stringhe per il confronto, se necessario). Gli elementi non definiti vengono spostati alla fine dell'array.

Per ordinare in un ordine diverso da quello alfabetico, puoi passare una funzione di confronto come argomento al metodo sort(). Questa funzione imposta quale dei suoi due argomenti dovrebbe essere il primo nell'elenco ordinato. Se il primo argomento deve precedere il secondo, la funzione di confronto deve restituire un numero negativo. Se il primo argomento deve seguire il secondo in un array ordinato, la funzione deve restituire un numero maggiore di zero. E se due valori sono equivalenti (cioè il loro ordine non ha importanza), la funzione di confronto dovrebbe restituire 0:

Var arr = ; arr.sort(); // Ordine alfabetico: 1111, 222, 33, 4 arr.sort(function(a,b) ( // Ordine numerico: 4, 33, 222, 1111 return a-b; // Restituisce 0 // a seconda dell'ordinamento a eb)); // Ordina nella direzione opposta, dal più grande al più piccolo arr.sort(function(a,b) (return b-a));

Nota quanto è conveniente utilizzare una funzione senza nome in questo snippet. La funzione di confronto viene utilizzata solo qui, quindi non è necessario darle un nome.

metodo concat()

Il metodo Array.concat() crea e restituisce un nuovo array contenente gli elementi dell'array originale su cui è stato chiamato concat() e i valori di eventuali argomenti passati a concat(). Se uno qualsiasi di questi argomenti è esso stesso un array, i suoi elementi vengono aggiunti all'array restituito. Va notato, tuttavia, che non esiste alcuna trasformazione ricorsiva di un array di array in un array unidimensionale. Il metodo concat() non modifica l'array originale. Di seguito sono riportati alcuni esempi:

Var arr = ; arr.concat(4, 5); // Restituisce arr.concat(); // Restituisce arr.concat(,) // Restituisce arr.concat(4, ]) // Restituisce ]

metodo slice()

Il metodo Array.slice() restituisce una sezione, o sottoarray, dell'array specificato. I due argomenti del metodo specificano l'inizio e la fine del frammento restituito. L'array restituito contiene l'elemento il cui numero è specificato nel primo argomento, più tutti gli elementi successivi, fino (escluso) all'elemento il cui numero è specificato nel secondo argomento.

Se viene fornito un solo argomento, l'array restituito contiene tutti gli elementi dalla posizione iniziale alla fine dell'array. Se uno qualsiasi degli argomenti è negativo, determina il numero dell'elemento relativo alla fine dell'array. Quindi, l'argomento -1 corrisponde all'ultimo elemento dell'array e l'argomento -3 corrisponde al terzo elemento dell'array dalla fine. Ecco alcuni esempi:

Var arr = ; arr.fetta(0,3); // Restituisce arr.slice(3); // Restituisce arr.slice(1,-1); // Restituisce arr.slice(-3,-2); // Ritorno

metodo splice()

Il metodo Array.splice() è un metodo generico che esegue l'inserimento o l'eliminazione di elementi dell'array. A differenza dei metodi slice() e concat(), il metodo splice() modifica l'array originale su cui è stato chiamato. Tieni presente che i metodi splice() e slice() hanno nomi molto simili, ma eseguono operazioni completamente diverse.

Il metodo splice() può rimuovere elementi da un array, inserire nuovi elementi o eseguire entrambe le operazioni contemporaneamente. Gli elementi dell'array vengono spostati secondo necessità per creare una sequenza continua dopo l'inserimento o l'eliminazione.

Il primo argomento del metodo splice() specifica la posizione nell'array da cui verrà eseguito l'inserimento e/o la cancellazione. Il secondo argomento specifica il numero di elementi che dovrebbero essere rimossi (tagliati) dall'array. Se il secondo argomento viene omesso, tutti gli elementi dell'array da quello specificato fino alla fine dell'array verranno rimossi. Il metodo splice() restituisce un array degli elementi rimossi o (se non è stato rimosso alcun elemento) un array vuoto.

I primi due argomenti del metodo splice() specificano gli elementi dell'array da rimuovere. Questi argomenti possono essere seguiti da un numero qualsiasi di argomenti aggiuntivi che specificano gli elementi da inserire nell'array, a partire dalla posizione specificata nel primo argomento.

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

metodi push() e pop()

I metodi push() e pop() ti permettono di lavorare con gli array come se fossero stack. Il metodo push() aggiunge uno o più nuovi elementi alla fine dell'array e ne restituisce la nuova lunghezza. Il metodo pop() esegue l'operazione inversa: rimuove l'ultimo elemento dell'array, riduce la lunghezza dell'array e restituisce il valore rimosso. Tieni presente che entrambi questi metodi modificano l'array originale anziché crearne una copia modificata.

metodi unshift() e shift()

I metodi unshift() e shift() si comportano quasi allo stesso modo di push() e pop(), tranne per il fatto che inseriscono e rimuovono elementi all'inizio dell'array anziché alla fine. Il metodo unshift() sposta gli elementi esistenti su indici più grandi per liberare spazio, aggiunge l'elemento o gli elementi all'inizio dell'array e restituisce la nuova lunghezza dell'array. Il metodo shift() rimuove e restituisce il primo elemento dell'array, spostando tutti gli elementi successivi verso il basso di una posizione per occupare lo spazio lasciato libero all'inizio dell'array.

Il metodo push() aggiunge uno o più elementi alla fine di un array e restituisce il nuovo lunghezza dell'array.

L'origine di questo esempio interattivo è archiviata in un repository GitHub. Se desideri contribuire al progetto di esempi interattivi, clona https://github.com/mdn/interactive-examples e inviaci una richiesta pull.

Sintassi arr .push(elemento1 [, ...[, elementoN ]]) Parametri elemento N Gli elementi da aggiungere alla fine dell'array. Valore restituito Esempi Aggiunta di elementi a un array

Il codice seguente crea l'array sportivo contenente due elementi, quindi vi aggiunge due elementi. La variabile totale contiene la nuova lunghezza dell'array.

Let sports = ["calcio", "baseball"] let total = sports.push("calcio", "nuoto") console.log(sport) // ["calcio", "baseball", "calcio", "nuoto " "] console.log(totale) // 4

Unione di due array

Questo esempio utilizza apply() per inserire tutti gli elementi da un secondo array.

Fare non utilizzare questo metodo se il secondo array (moreVegs nell'esempio) è molto grande, perché il numero massimo di parametri che una funzione può accettare è in pratica limitato. Vedi apply() per maggiori dettagli.

Let verdure = ["pastinaca", "patata"] let moreVegs = ["sedano", "barbabietola"] // Unisci il secondo array nel primo // Equivalente a verdure.push("sedano", "barbabietola") Array.prototype.push.apply(vegetables, moreVegs) console.log(vegetables) // ["pastinaca", "patata", "sedano", "barbabietola"]

Utilizzo di un oggetto in modo simile ad un array

Come accennato in precedenza, il push è intenzionalmente generico e possiamo usarlo a nostro vantaggio. Array.prototype.push può funzionare perfettamente su un oggetto, come mostra questo esempio.

Tieni presente che non creiamo un array per memorizzare una raccolta di oggetti. Invece, memorizziamo la raccolta sull'oggetto stesso e usiamo la chiamata su Array.prototype.push per ingannare il metodo facendogli credere che abbiamo a che fare con un array, e questo funziona e basta, grazie al modo in cui JavaScript ci consente di stabilire il contesto di esecuzione come preferiamo.

Let obj = ( length: 0, addElem: function addElem(elem) ( // obj.length viene automaticamente incrementato // ogni volta che viene aggiunto un elemento. .push.call(this, elem) ) ) // Aggiungiamo alcuni elementi vuoti oggetti solo per illustrare. obj.addElem(()) obj.addElem(()) console.log(obj.length) // → 2

Si noti che sebbene obj non sia un array, il metodo push ha incrementato con successo la proprietà di lunghezza di obj proprio come se avessimo a che fare con un array reale.

Specifiche Commento sullo stato delle specifiche

ECMAScript 3a edizione (ECMA-262)	Standard	Definizione iniziale. Implementato in JavaScript 1.2.
ECMAScript 5.1 (ECMA-262)	Standard
ECMAScript 2015 (sesta edizione, ECMA-262) La definizione di "Array.prototype.push" in tale specifica.	Standard
Ultima bozza ECMAScript (ECMA-262) La definizione di "Array.prototype.push" in tale specifica.	Bozza

Compatibilità del browser

La tabella di compatibilità in questa pagina è generata da dati strutturati. Se desideri contribuire ai dati, consulta https://github.com/mdn/browser-compat-data e inviaci una richiesta pull.

Aggiorna i dati di compatibilità su GitHub

Server mobile da tavolo Chrome Edge Firefox Internet Explorer Opera Safari Visualizzazione web Android Chrome per Android Firefox per Android Opera per Android Safari su iOS Samsung Internet Node.jsspingere

Supporto completo per Chrome 1

Supporto completo Edge 12

Supporto completo per Firefox 1

IE Pieno supporto 5.5

Opera Supporto completo Sì

Safari Supporto completo 1

WebView Android Supporto completo Sì

Chrome Android Supporto completo 18

Firefox Android Supporto completo 4

Opera Android Supporto completo Sì

Safari iOS Supporto completo 1

SAMSUNG InternetAndroid Pieno supporto Sì

nodejs Supporto completo Sì