Supprimer le dernier élément du tableau

J'ai le tableau suivant.

var arr = [1,0,2];

Je voudrais supprimer le dernier élément c'est-à-dire 2.

J'ai utilisé arr.slice(-1);mais cela ne supprime pas la valeur.

Utiliser une épissure (index, combien)

arr.splice(-1,1)

Array.prototype.pop () par convention JavaScript.

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

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

Vous pouvez le faire en utilisant une .slice()méthode comme:

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

Voici une démo:

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>

au lieu de faire:

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

Voici une démo:

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>

Explication:-

Maintenant, la syntaxe de base de Array.prototype.slice()ou en bref slice()est la suivante:

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

Ici,

le beginparamètre est un index de base zéro à partir duquel l'extraction à partir d'un tableau commence. Donc, disons sur la base de l'exemple ci-dessus si nous faisons quelque chose comme

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

il retournerait tous les éléments du tableau depuis le début de la séquence depuis la position 0 et c'est-à-dire [1,0,2]. De même, si nous faisons

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

il reviendrait [0,2]puisque 0 est à la position 1 ici et tout ce qui suit. Maintenant, dans votre cas, vous avez passé un indice négatif, c'est-à-dire -1comme paramètre de début, qui indique un décalage à partir de la fin de la séquence. Donc, slice(-1)dans votre cas, extrait le dernier élément de tableau de la séquence et c'est 2( comme nous l'avons déjà vu dans la démonstration ci-dessus ).

Maintenant, parlons du endparamètre dans la slice()syntaxe de la méthode ici. Il s'agit à nouveau d'un index de base zéro auquel se termine l'extraction à partir d'un tableau. Donc, disons que nous avons un tableau comme: -

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

et nous voulons obtenir uniquement les 2,5,3éléments du tableau. Maintenant, la position 2du début de la séquence est 2et pour le dernier élément 3c'est 4. Nous devrons terminer l'extraction ici à une position 5, car nous devons obtenir l'élément avant cette position. Donc, nous allons simplement implémenter la slice()méthode ici comme

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

Dans votre cas, nous avons implémenté -1comme paramètre final, donc notre code est comme

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

En tant qu'indice négatif, endindique un décalage par rapport à la fin de la séquence. Ainsi, slice(0,-1)extrait le premier élément à travers l'avant-dernier élément de la séquence. Ainsi, nous obtenons la sortie souhaitée. On peut aussi faire comme

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

nous obtiendrons la même sortie. Mais, j'ai utilisé -1ici comme son plus facile à implémenter même pour un long tableau comme

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

Si vous voulez simplement supprimer le dernier élément, vous ne voulez pas vous asseoir et calculer la position des 9 derniers ici et les faire comme arr.slice(0, 22). Vous pouvez ensuite simplement implémenter la logique d'index négatif ici et faire

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

J'espère que cela aide!

apprendre par l'exemple:

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]

Vous devrez le faire car slicene modifie pas le tableau d'origine.

arr = arr.slice(-1);

Si vous souhaitez modifier le tableau d'origine, vous pouvez utiliser splice:

arr.splice(-1, 1);

ou pop:

arr.pop();

Je considérerais .pop() la solution la plus `` correcte '', cependant, parfois, cela pourrait ne pas fonctionner car vous devez utiliser un tableau sans le dernier élément juste là ...

Dans un tel cas, vous voudrez peut-être utiliser ce qui suit, il retournera [1,2,3]

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

tandis .pop()que reviendrait 4:

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

ce qui pourrait ne pas être souhaitable ...

J'espère que cela vous fera gagner du temps.

Il y a une fonction pour cela, explication ici :

arr.pop();

Vous pouvez simplement utiliser, arr.pop()

Cela supprime la dernière entrée du tableau.

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

Utilisez simplement ce qui suit pour votre cas d'utilisation:

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

Juste une note. Lorsque vous exécutez la pop()fonction même si la ligne renvoie l'élément sauté, le tableau d'origine est effectué et l'élément sauté est supprimé.

Vous pouvez le faire de deux manières en utilisant splice():

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

splice(position_to_start_deleting, how_many_data_to_delete) prend deux paramètres.

position_to_start_deleting: L'index de base zéro d'où commencer la suppression. how_many_data_to_delete: À partir de l'index indiqué, combien de données consécutives doivent être supprimées.

Vous pouvez également supprimer le dernier élément en utilisant pop()as pop()supprime le dernier élément d'un tableau.
Utilisationarr.pop()

arr.slice(-1)retournera une copie du dernier élément du tableau, mais ne modifie pas le tableau d'origine.

Pour supprimer les derniers néléments d'un tableau, utilisezarr.splice(-n) (notez le "p" dans "splice"). La valeur de retour sera un nouveau tableau contenant les éléments supprimés.

Encore plus simple à n == 1utiliserval = arr.pop()

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

// supprime le dernier élément // doit vérifier si arr.length> 0

Cette méthode est plus utile pour supprimer et stocker le dernier élément d'un tableau.

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.

Maintenant, les résultats sont les suivants:

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

Il convient de noter que slicecela retournera à la fois un nouveau tableau, tandis que .pop()et .splice()mutera le tableau existant .

Si vous aimez gérer des collections de données avec un style de commande chaîné, vous voudrez vraiment vous en tenir à slice quelque chose comme ça.

Par exemple:

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

Cela peut nécessiter beaucoup plus de gâchis et de gestion des variables, pour faire le même genre de chose avec "pop", car contrairement à map,filter etc., vous ne recevez pas un nouveau retour de tableau.

C'est le même genre de chose avec push, qui ajoute un élément à la fin d'un tableau. Vous pourriez être mieux avec, concatcar cela vous permet de maintenir le flux.

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
  

splice (index, howmany) - Cette solution sonne bien. Mais cette howmany ne fonctionnera que pour l'indice de tableau positif. Pour supprimer les deux ou trois derniers éléments, utilisez l'index lui-même.

Par exemple, épissez (-2) pour supprimer les deux derniers éléments. épissure (-3) pour supprimer les trois derniers éléments.

Avec Lodash, vous pouvez utiliser dropRight , si vous ne vous souciez pas de savoir quels éléments ont été supprimés:

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

Solution ECMA5 2019:

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

Non destructif, générique, à une ligne et ne nécessite qu'un copier-coller à la fin de votre tableau.

dis que tu as var arr = [1,0,2]

arr.splice(-1,1)reviendra vers vous array [1,0];tout arr.slice(-1,1)reviendra vers vousarray [2];

C'est un bon moyen de supprimer le dernier élément:

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

Détail de l'épissure comme suit:

épissure (startIndex, nombre d'épissures)

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

stack.reverse().shift();

stack.push(0);

La sortie sera: Array [0,1,2,3,4,5] . Cela vous permettra de conserver la même quantité d'éléments de tableau que lorsque vous introduisez une nouvelle valeur.

Une autre approche consiste à filtrer en fonction de l'index:

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

Remarque: filter()crée un nouveau tableau, ne change pas celui existant.

Si vous souhaitez supprimer n élément de la fin du tableau en javascript, vous pouvez facilement utiliser:

arr.splice(-n, n);