Eliminar el último elemento de la matriz

Tengo la siguiente matriz.

var arr = [1,0,2];

Me gustaría eliminar el último elemento, es decir, 2.

Solía arr.slice(-1);pero no elimina el valor.

Usar empalme (índice, cuántos)

arr.splice(-1,1)

Array.prototype.pop () por convención de JavaScript.

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

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

Puedes hacer esto usando un .slice()método como:

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

Aquí hay una demostración:

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>

en lugar de hacer:

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

Aquí hay una demostración:

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>

Explicación:-

Ahora la sintaxis básica de Array.prototype.slice()o en slice()método corto es:

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

Aquí,

el beginparámetro es un índice basado en cero en el que comienza la extracción de una matriz. Entonces, digamos basado en el ejemplo anterior si hacemos algo como

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

devolvería todos los elementos de la matriz desde el inicio de la secuencia desde la posición 0 y eso es [1,0,2]. Del mismo modo, si lo hacemos

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

volvería [0,2]ya que 0 está en la posición 1 aquí y todo después de eso. Ahora, en su caso, ha pasado un índice negativo, es decir, -1como el parámetro de inicio, que indica un desplazamiento desde el final de la secuencia. Entonces, slice(-1)en su caso, extrae el último elemento de la matriz en la secuencia y eso es 2( como ya hemos visto en la demostración anterior ).

Ahora, hablemos sobre el endparámetro en la slice()sintaxis del método aquí. Es nuevamente un índice de base cero en el que finaliza la extracción de una matriz. Entonces, digamos que tenemos una matriz como: -

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

y queremos obtener solo los 2,5,3elementos en la matriz. Ahora, la posición 2desde el inicio de la secuencia es 2y para el último elemento 3es 4. Tendremos que finalizar la extracción aquí en una posición 5, ya que necesitamos obtener el elemento antes de esa posición. Entonces, simplemente implementaremos un slice()método aquí como

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

En su caso, lo hemos implementado -1como parámetro final, por lo que nuestro código es como

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

Como índice negativo, endindica un desplazamiento desde el final de la secuencia. Entonces, slice(0,-1)extrae el primer elemento a través del penúltimo elemento de la secuencia. Entonces, obtenemos la salida deseada. También podemos hacer como

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

obtendremos la misma salida. Pero, he usado -1aquí porque es más fácil de implementar, incluso para una matriz larga como

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

Si solo desea eliminar el último elemento, no desea sentarse y calcular la posición de los últimos 9 aquí y hacer lo mismo arr.slice(0, 22). Luego puede simplemente implementar la lógica de índice negativo aquí y hacer

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

¡Espero eso ayude!

aprender con el ejemplo:

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]

Debería hacer esto ya sliceque no altera la matriz original.

arr = arr.slice(-1);

Si desea alterar la matriz original, puede usar splice:

arr.splice(-1, 1);

o pop:

arr.pop();

Considero .pop()que es la solución más 'correcta', sin embargo, a veces puede no funcionar ya que necesita usar una matriz sin el último elemento allí ...

En tal caso, es posible que desee utilizar lo siguiente, devolverá [1,2,3]

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

mientras .pop()volvería 4:

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

lo que podría no ser deseable ...

Espero que esto te ahorre algo de tiempo.

Hay una función para eso, explicación aquí :

arr.pop();

Simplemente podrías usar, arr.pop()

Esto elimina la última entrada de la matriz.

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

Simplemente use lo siguiente para su caso de 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. Cuando ejecuta la pop()función aunque la línea devuelve el elemento emergente, la matriz original se efectúa y el elemento emergente se elimina.

Puedes hacerlo de dos maneras usando splice():

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

splice(position_to_start_deleting, how_many_data_to_delete) Toma dos parámetros.

position_to_start_deleting: El índice basado en cero desde donde comenzar a eliminar. how_many_data_to_delete: Del índice indicado, cuántos datos consecutivos se deben eliminar.

También puede eliminar el último elemento utilizando pop()como pop()elimina el último elemento de alguna matriz.
Utilizararr.pop()

arr.slice(-1)devolverá una copia del último elemento de la matriz, pero deja la matriz original sin modificar.

Para eliminar los últimos nelementos de una matriz, use arr.splice(-n)(observe la "p" en "empalme"). El valor de retorno será una nueva matriz que contiene los elementos eliminados.

Más simple aún, para n == 1usarval = arr.pop()

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

// elimina el último elemento // es necesario verificar si arr.length> 0

Este método es más útil para eliminar y almacenar el último elemento de una matriz.

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.

Ahora los resultados son:

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

Vale la pena señalar que slicetanto devolverá una nueva matriz, mientras que .pop()y .splice()mute la existente matriz.

Si le gusta manejar colecciones de datos con un estilo de comando encadenado, realmente querrá quedarse con slice algo como esto.

Por ejemplo:

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

Se puede requerir mucho más perder el tiempo, y la gestión de variables, para hacer el mismo tipo de cosa con "pop", ya que a diferencia map,filter , etc, no obtiene una nueva vuelta matriz.

Es el mismo tipo de cosas con push, que agrega un elemento al final de una matriz. Es posible que esté mejor concatya que eso le permite mantener el flujo.

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
  

empalme (índice, cuántos) - Esta solución suena bien. Pero esto, muchas solo funcionará para el índice de matriz positiva. Para eliminar los últimos dos o tres elementos, use el índice en sí.

Por ejemplo, empalme (-2) para eliminar los dos últimos elementos. empalme (-3) para eliminar los últimos tres elementos.

Con Lodash puede usar dropRight , si no le importa saber qué elementos se eliminaron:

_.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 ]

Solución ECMA5 2019:

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

No destructivo, genérico, de una sola línea y solo requiere copiar y pegar al final de su matriz.

di que tienes var arr = [1,0,2]

arr.splice(-1,1)volverá a ti array [1,0];mientras arr.slice(-1,1)volveremos a tiarray [2];

Esta es una buena manera de eliminar el último elemento:

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

Detalle del empalme como sigue:

empalme (startIndex, número de empalmes)

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

stack.reverse().shift();

stack.push(0);

La salida será: Array [0,1,2,3,4,5] . Esto le permitirá mantener la misma cantidad de elementos de matriz a medida que ingresa un nuevo valor.

Otro enfoque es filtrar según el índice:

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

Nota: filter()crea una nueva matriz, no cambia la existente.

Si desea eliminar n elemento del final de la matriz en javascript, puede usar fácilmente:

arr.splice(-n, n);