Rimuovi l'ultimo elemento dall'array

Ho il seguente array.

var arr = [1,0,2];

Vorrei rimuovere l'ultimo elemento, ad es. 2.

Ho usato arr.slice(-1);ma non rimuove il valore.

Usa giunzione (indice, howmany)

arr.splice(-1,1)

Array.prototype.pop () per convenzione JavaScript.

let fruit = ['apple', 'orange', 'banana', 'tomato'];
let popped = fruit.pop();

console.log(popped); // "tomato"
console.log(fruit); // ["apple", "orange", "banana"]

Puoi farlo usando un .slice()metodo come:

arr.slice(0, -1);    // returns [1,0]

Ecco una demo:

var arr = [1, 0, 2];
var newArr = arr.slice(0, -1);    // returns [1,0]

console.log(newArr);
$('#div1').text('[' + arr + ']');
$('#div2').text('[' + newArr + ']');

<script src="http://code.jquery.com/jquery.min.js"></script>
<b>Original Array    : </b>
<div id="div1"></div>
<br/>
<b>After slice(0, -1): </b>
<div id="div2"></div>

invece di fare:

arr.slice(-1);   // returns [2]

Ecco una demo:

var arr = [1, 0, 2];
var newArr = arr.slice(-1);    // returns [2]

console.log(newArr);
$('#div1').text('[' + arr + ']');
$('#div2').text('[' + newArr + ']');

<script src="http://code.jquery.com/jquery.min.js"></script>
<b>Original Array    : </b>
<div id="div1"></div>
<br/>
<b>After slice(-1): </b>
<div id="div2"></div>

Spiegazione:-

Ora la sintassi di base Array.prototype.slice()del slice()metodo o in breve è:

arr.slice([begin[, end]])

Qui,

il beginparametro è un indice a base zero in corrispondenza del quale inizia l'estrazione da un array. Quindi, diciamo basandoci sull'esempio sopra se facciamo qualcosa di simile

arr.slice(0)    // returns [1,0,2]

restituirebbe tutti gli elementi dell'array dall'inizio della sequenza dalla posizione 0 e cioè [1,0,2]. Allo stesso modo, se lo facciamo

arr.slice(1)    // returns [0,2]

ritornerebbe [0,2]dal momento che 0 è in posizione 1 qui e tutto il resto. Ora, nel tuo caso, hai superato un indice negativo, ad esempio -1come parametro iniziale, che indica un offset dalla fine della sequenza. Quindi, slice(-1)nel tuo caso estrae l'ultimo elemento dell'array nella sequenza e cioè 2( come abbiamo già visto nella demo sopra ).

Ora parliamo del endparametro nella slice()sintassi del metodo qui. È di nuovo un indice a base zero in corrispondenza del quale termina l'estrazione da un array. Quindi, supponiamo di avere un array come: -

var arr = [1, 0, 2, 5, 3, 9];

e vogliamo ottenere solo gli 2,5,3elementi dell'array. Ora, la posizione di 2dall'inizio della sequenza è 2e per l'ultimo elemento 3lo è 4. Dovremo terminare qui l'estrazione una posizione 5, poiché dobbiamo ottenere l'elemento prima di quella posizione. Quindi, implementeremo semplicemente il slice()metodo qui come

arr.slice(2, 5)    // returns [2,5,3]

Nel tuo caso, abbiamo implementato -1come parametro end, quindi il nostro codice è simile

arr.slice(0, -1)   // returns [1,0]

Come indice negativo, endindica un offset dalla fine della sequenza. Quindi, slice(0,-1)estrae il primo elemento attraverso il penultimo elemento della sequenza. Quindi, otteniamo l'output desiderato. Possiamo anche fare come

arr.slice(0, 2)    // returns [1,0]

otterremo lo stesso output. Ma, ho usato -1qui come è più facile da implementare anche per un lungo array come

[0,2,3,1,2,9,3,6,3,9,1,0,2,9,0,1,1,2,3,4,7,9,1]

Se vuoi solo rimuovere l'ultimo elemento, non vuoi sederti e calcolare la posizione degli ultimi 9 qui e fare così arr.slice(0, 22). Puoi quindi semplicemente implementare la logica dell'indice negativo qui e fai

arr.slice(0, -1) // same result as arr.slice(0, 22)

Spero che sia d'aiuto!

impara con l'esempio:

let array_1 = [1,2,3,4];
let array_2 = [1,2,3,4];
let array_3 = [1,2,3,4];

array_1.splice(-1,1)  // output --> [4]      array_1 = [1,2,3]
array_2.slice(0,-1);  // output --> [1,2,3]  array_2 = [1,2,3,4]
array_3.pop();        // output --> 4        array_3 = [1,2,3]

Dovresti farlo poiché slicenon altera l'array originale.

arr = arr.slice(-1);

Se si desidera modificare l'array originale è possibile utilizzare splice:

arr.splice(-1, 1);

oppure pop:

arr.pop();

Vorrei prendere in considerazione .pop() la soluzione più 'corretta', tuttavia a volte potrebbe non funzionare poiché è necessario utilizzare l'array senza l'ultimo elemento lì ...

In tal caso potresti voler usare quanto segue, tornerà [1,2,3]

var arr = [1,2,3,4];
console.log(arr.splice(0,arr.length-1));

mentre .pop()ritornerebbe 4:

var arr = [1,2,3,4];
console.log(arr.pop());

che potrebbe non essere desiderabile ...

Spero che questo ti faccia risparmiare un po 'di tempo.

C'è una funzione per questo, spiegazione qui :

arr.pop();

Potresti semplicemente usare, arr.pop()

Ciò rimuove l'ultima voce dell'array.

var arr = [1,0,2]; 
var popped = arr.pop();//Now arr = [1,0] & popped = 2

Utilizzare solo quanto segue per il proprio caso d'uso:

var arr = [1,2,3,4];
arr.pop() //returns 4 as the value
arr // value 4 is removed from the **arr** array variable

Solo una nota. Quando si esegue la pop()funzione anche se la riga restituisce l'elemento spuntato, l'array originale viene effettuato e l'elemento saltato viene rimosso.

Puoi farlo in due modi usando splice():

1. arr.splice(-1,1)
2. arr.splice(arr.length-1,1)

splice(position_to_start_deleting, how_many_data_to_delete) accetta due parametri.

position_to_start_deleting: L'indice in base zero da dove iniziare l'eliminazione. how_many_data_to_delete: Dall'indice indicato, quanti dati consecutivi devono essere eliminati.

Puoi anche rimuovere l'ultimo elemento usando pop()as pop()rimuove l'ultimo elemento da un array.
Usoarr.pop()

arr.slice(-1)restituirà una copia dell'ultimo elemento dell'array, ma lascia l'array originale non modificato.

Per rimuovere gli ultimi nelementi da un array, utilizzarearr.splice(-n) (notare la "p" in "splice"). Il valore restituito sarà un nuovo array contenente gli elementi rimossi.

Ancora più semplice, per n == 1, usareval = arr.pop()

var arr = [1,0,2];
arr.length--; 

// rimuove l'ultimo elemento // è necessario verificare se lunghezza arr.> 0

Questo metodo è più utile per eliminare e archiviare l'ultimo elemento di un array.

var sampleArray = [1,2,3,4];// Declaring the array
var lastElement = sampleArray.pop();//this command will remove the last element of `sampleArray` and stores in a variable called `lastElement` so that you can use it if required.

Ora i risultati sono:

console.log(sampleArray); //This will give you [1,2,3]
console.log(lastElement); //this will give you 4

Vale la pena notare che sliceentrambi restituiranno un nuovo array, mentre .pop()e .splice()trasformeranno l' array esistente .

Se ti piace gestire raccolte di dati con uno stile di comando incatenato, ti consigliamo di attenersi a slicequalcosa di simile.

Per esempio:

myArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

var newArrayOfThings = myArray
  .filter(x => x > 5)              // only bigly things
  .slice(-1)                       // get rid of the last item
  .map(x => `The number is: ${x}`);// map to a set of strings

Si può richiedere molto di più Giochi per bambini, e delle variabili, a fare lo stesso tipo di cosa con "pop", dal momento che a differenza map,filter , ecc., Non si ottiene un nuovo array indietro.

È lo stesso tipo di cosa con push, che aggiunge un elemento alla fine di un array. Potresti stare meglio con ciò concatpoiché ti consente di mantenere il flusso in corso.

myArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

var newArrayOfThings = myArray
  .filter(x => x > 5)              // only bigly things
  .slice(-1)                       // get rid of the "10"
  .concat([100])                   // note with concat, you must pass an array
  .map(x => `The number is: ${x}`) // map to a set of strings
  

giuntura (indice, howmany) - Questa soluzione suona bene. Ma questo howmily funzionerà solo per l'indice di array positivo. Per rimuovere gli ultimi due elementi o tre elementi, utilizzare l'indice stesso.

Ad esempio, giuntare (-2) per rimuovere gli ultimi due elementi. giunzione (-3) per la rimozione degli ultimi tre elementi.

Con Lodash puoi usare dropRight , se non ti interessa sapere quali elementi sono stati rimossi:

_.dropRight([1, 2, 3])
// => [1, 2]

_.dropRight([1, 2, 3], 2);
// => [1]

var a = [1,2,3,4,5,6]; 
console.log(a.reverse().slice(1).reverse());
//Array(5) [ 1, 2, 3, 4, 5 ]

Soluzione ECMA5 2019:

const new_arr = arr.reduce((d, i, idx, l) => idx < l.length - 1 ? [...d, i] : d, [])

Non distruttivo, generico, one-liner e richiede solo una copia e incolla alla fine dell'array.

dire che hai var arr = [1,0,2]

arr.splice(-1,1)tornerà a te array [1,0];mentre arr.slice(-1,1)tornerà a tearray [2];

Questo è un buon modo per rimuovere l'ultimo elemento:

if (arr != null && arr != undefined && arr.length > 0) {
      arr.splice(arr.length - 1, 1);
}

Dettaglio della giunzione come segue:

giunzione (startIndex, numero di giunzione)

var stack = [1,2,3,4,5,6];

stack.reverse().shift();

stack.push(0);

L'output sarà: Array [0,1,2,3,4,5] . Ciò consentirà di mantenere la stessa quantità di elementi dell'array quando si inserisce un nuovo valore.

Un altro approccio è filtrare in base all'indice:

arr.filter((element, index) => index < arr.length - 1);

Nota: filter()crea un nuovo array, non cambia quello esistente.

Se vuoi rimuovere n elementi dalla fine dell'array in javascript, puoi facilmente usare:

arr.splice(-n, n);