Remover o último item da matriz

Eu tenho a seguinte matriz.

var arr = [1,0,2];

Gostaria de remover o último elemento, ou seja, 2.

Eu usei, arr.slice(-1);mas ele não remove o valor.

Usar emenda (índice, quantos)

arr.splice(-1,1)

Array.prototype.pop () por convenção de JavaScript.

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

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

Você pode fazer isso usando o .slice()método como:

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

Aqui está uma demonstração:

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>

em vez de fazer:

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

Aqui está uma demonstração:

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>

Explicação:-

Agora, a sintaxe básica do método, Array.prototype.slice()ou resumidamente slice(), é:

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

Aqui,

o beginparâmetro é o índice baseado em zero no qual a extração de uma matriz é iniciada. Então, digamos, com base no exemplo acima, se fizermos algo como

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

retornaria todos os elementos da matriz do início da sequência da posição 0 e é isso [1,0,2]. Da mesma forma, se fizermos

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

retornaria [0,2]uma vez que 0 está na posição 1 aqui e tudo depois disso. Agora, no seu caso, você passou um índice negativo, ou seja, -1como o parâmetro begin, que indica um deslocamento do final da sequência. Portanto, slice(-1)no seu caso, extrai o último elemento da matriz na sequência e é isso 2( como já vimos na demonstração acima ).

Agora, vamos falar sobre o endparâmetro na slice()sintaxe do método aqui. É novamente um índice baseado em zero no qual a extração de uma matriz termina. Então, digamos que temos uma matriz como: -

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

e queremos obter apenas os 2,5,3elementos da matriz. Agora, a posição 2do início da sequência é 2e, para o último elemento 3, é 4. Precisamos terminar a extração aqui na posição 5, pois precisamos obter o elemento antes dessa posição. Então, vamos simplesmente implementar o slice()método aqui como

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

No seu caso, implementamos -1como parâmetro final, portanto, nosso código é como

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

Como um índice negativo, endindica um deslocamento do final da sequência. Portanto, slice(0,-1)extrai o primeiro elemento pelo penúltimo elemento na sequência. Então, obtemos a saída desejada. Nós também podemos fazer como

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

obteremos a mesma saída. Mas, eu usei -1aqui como é mais fácil de implementar, mesmo para uma longa matriz como

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

Se você apenas deseja remover o último elemento, não deseja sentar e calcular a posição dos últimos 9 aqui e assim por diante arr.slice(0, 22). Você pode simplesmente implementar a lógica do índice negativo aqui e fazer

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

Espero que ajude!

aprenda pelo exemplo:

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]

Você precisaria fazer isso, pois slicenão altera a matriz original.

arr = arr.slice(-1);

Se você deseja alterar a matriz original, pode usar splice:

arr.splice(-1, 1);

ou pop:

arr.pop();

Eu consideraria .pop()a solução mais 'correta', no entanto, às vezes pode não funcionar, pois você precisa usar a matriz sem o último elemento ali ...

Nesse caso, você pode querer usar o seguinte, ele retornará [1,2,3]

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

while .pop()retornaria 4:

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

o que pode não ser desejável ...

Espero que isso poupe algum tempo.

Há uma função para isso, explicação aqui :

arr.pop();

Você poderia simplesmente usar, arr.pop()

Isso remove a última entrada da matriz.

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

Basta usar o seguinte para o seu 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

Apenas uma nota. Quando você executa a pop()função mesmo que a linha retorne o item pop-up, a matriz original é efetuada e o elemento pop-up é removido.

Você pode fazer isso de duas maneiras usando splice():

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

splice(position_to_start_deleting, how_many_data_to_delete) leva dois parâmetros.

position_to_start_deleting: O índice baseado em zero de onde começar a excluir. how_many_data_to_delete: Do índice indicado, quantos dados consecutivos devem ser excluídos.

Você também pode remover o último elemento usando pop()as pop()remove o último elemento de alguma matriz.
Usararr.pop()

arr.slice(-1)retornará uma cópia do último elemento da matriz, mas deixa a matriz original não modificada.

Para remover os últimos nelementos de uma matriz, use arr.splice(-n)(observe o "p" em "emenda"). O valor de retorno será uma nova matriz que contém os elementos removidos.

Mais simples ainda, para n == 1usarval = arr.pop()

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

// remove o último elemento // precisa verificar se arr.length> 0

Este método é mais útil para excluir e armazenar o último elemento de uma 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.

Agora os resultados são:

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

emenda (índice, quantos) - Esta solução parece boa. Porém, este número funcionará apenas para o índice de matriz positivo. Para remover os últimos dois itens ou três itens, use o próprio índice.

Por exemplo, emenda (-2) para remover os dois últimos itens. emenda (-3) para remover os três últimos itens.

É importante notar que sliceirá retornar tanto uma nova matriz, enquanto que .pop()e .splice()vai transformar a existente matriz.

Se você gosta de lidar com coleções de dados com um estilo de comando encadeado, você realmente vai querer ficar com slicealgo assim.

Por exemplo:

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

Pode exigir muito mais confusão e gerenciamento de variáveis, para fazer o mesmo tipo de coisa com "pop", pois map, ao contrário de filter, etc, você não recebe uma nova matriz de volta.

É o mesmo tipo de coisa pushque adiciona um item ao final de uma matriz. Você pode se sair melhor, concatpois isso permite manter o fluxo.

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
  

Com o Lodash, você pode usar o dropRight , se não quiser saber quais elementos foram removidos:

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

Solução ECMA5 de 2019:

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

Não destrutivo, genérico, de uma linha e requer apenas copiar e colar no final da sua matriz.

diga que você tem var arr = [1,0,2]

arr.splice(-1,1)retornará para você array [1,0];enquanto arr.slice(-1,1)retornará para vocêarray [2];

Esta é uma boa maneira de remover o último item:

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

Detalhe da emenda da seguinte forma:

emenda (startIndex, número de emenda)

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

stack.reverse().shift();

stack.push(0);

A saída será: Matriz [0,1,2,3,4,5] . Isso permitirá que você mantenha a mesma quantidade de elementos da matriz ao inserir um novo valor.

Outra abordagem é filtrar com base no índice:

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

Nota: filter()cria uma nova matriz, não altera a existente.

Se você deseja remover o item n do final da matriz em javascript, você pode facilmente usar:

arr.splice(-n, n);