Entfernen Sie das letzte Element aus dem Array

Ich habe das folgende Array.

var arr = [1,0,2];

Ich möchte das letzte Element entfernen, dh 2.

Ich habe verwendet, arr.slice(-1);aber es entfernt den Wert nicht.

Verwenden Sie Spleiß (Index, Howmany)

arr.splice(-1,1)

Array.prototype.pop () nach JavaScript-Konvention.

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

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

Sie können dies mit folgenden .slice()Methoden tun :

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

Hier ist eine 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>

anstatt zu tun:

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

Hier ist eine 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>

Erläuterung:-

Die grundlegende Syntax der Array.prototype.slice()oder kurz slice()Methode lautet nun:

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

Hier,

Der beginParameter ist ein auf Null basierender Index, bei dem die Extraktion aus einem Array beginnt. Nehmen wir also am obigen Beispiel an, wenn wir so etwas tun

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

es würde alle Array-Elemente vom Beginn der Sequenz von Position 0 zurückgeben und das heißt [1,0,2]. Ebenso, wenn wir es tun

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

es würde zurückkehren, [0,2]da 0 hier an Position 1 ist und alles danach. In Ihrem Fall haben Sie nun einen negativen Index -1als Startparameter übergeben, der einen Versatz vom Ende der Sequenz angibt. Also, slice(-1)in Ihrem Fall extrahiert das letzte Array - Element in der Sequenz und das ist2 ( wie wir bereits in der obigen Demo gesehen haben ).

Lassen Sie uns nun über den endParameter in der slice()Methodensyntax sprechen . Es ist wieder ein auf Null basierender Index, bei dem die Extraktion aus einem Array endet. Nehmen wir also an, wir haben ein Array wie: -

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

und wir wollen nur die 2,5,3Elemente im Array bekommen. Nun Position 2aus der Sequenz starten ist 2und für letztes Element 3ist 4. Wir müssen die Extraktion hier um Position 5 beenden, da wir das Element vor dieser Position erhalten müssen. Also werden wir einfach implementierenslice() Methode wie

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

In Ihrem Fall haben wir als Endparameter implementiert -1, sodass unser Code wie folgt ist

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

Gibt als negativer Index endeinen Versatz vom Ende der Sequenz an. So, slice(0,-1)extrahiert das erste Element durch das zweite bis letztes Element in der Sequenz. So erhalten wir die gewünschte Ausgabe. Wir können auch gerne machen

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

Wir werden die gleiche Ausgabe erhalten. Aber ich habe -1hier verwendet , da es einfacher zu implementieren ist, selbst für ein langes Array wie

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

Wenn Sie nur das letzte Element entfernen möchten, möchten Sie hier nicht sitzen und die Position der letzten 9 berechnen arr.slice(0, 22). Sie können dann einfach die negative Indexlogik hier & do implementieren

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

Ich hoffe es hilft!

Lernen Sie anhand eines Beispiels:

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]

Sie müssten dies tun, da slicedas ursprüngliche Array nicht geändert wird.

arr = arr.slice(-1);

Wenn Sie das ursprüngliche Array ändern möchten, können Sie Folgendes verwenden splice:

arr.splice(-1, 1);

oder pop:

arr.pop();

Ich würde es als .pop()die 'richtigste' Lösung betrachten, aber manchmal funktioniert es möglicherweise nicht, da Sie ein Array ohne das letzte Element genau dort verwenden müssen ...

In einem solchen Fall möchten Sie möglicherweise Folgendes verwenden, es wird zurückgegeben [1,2,3]

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

während .pop()würde zurückkehren 4:

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

was vielleicht nicht wünschenswert ist ...

Hoffe das spart dir etwas Zeit.

Dafür gibt es eine Funktion, Erklärung hier :

arr.pop();

Sie könnten einfach verwenden, arr.pop()

Dadurch wird der letzte Eintrag des Arrays entfernt.

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

Verwenden Sie einfach Folgendes für Ihren Anwendungsfall:

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

Nur eine Notiz. Wenn Sie die pop()Funktion ausführen , obwohl die Zeile das geknallte Element zurückgibt, wird das ursprüngliche Array ausgeführt und das geknallte Element entfernt.

Sie können dies auf zwei Arten tun splice():

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

splice(position_to_start_deleting, how_many_data_to_delete) nimmt zwei Parameter.

position_to_start_deleting: Der auf Null basierende Index, von dem aus das Löschen beginnen soll. how_many_data_to_delete: Aus dem angegebenen Index, wie viele aufeinanderfolgende Daten gelöscht werden sollen.

Sie können auch das letzte Element mit entfernen , pop()wie pop()entfernt von einem Array das letzte Element.
Verwendenarr.pop()

arr.slice(-1)wird eine Kopie zurückgeben des letzten Elements des Arrays zurück, lässt jedoch das ursprüngliche Array unverändert.

nVerwenden Sie, um die letzten Elemente aus einem Array zu entfernenarr.splice(-n) Sie (beachten Sie das "p" in "splice"). Der Rückgabewert ist ein neues Array, das die entfernten Elemente enthält.

Noch einfacher, für den n == 1Gebrauchval = arr.pop()

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

// entfernt das letzte Element // muss überprüft werden, ob arr.length> 0 ist

Diese Methode ist hilfreicher, um das letzte Element eines Arrays zu löschen und zu speichern.

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.

Jetzt sind die Ergebnisse:

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

Spleiß (Index, wie viele) - Diese Lösung klingt gut. Diese Anleitung funktioniert jedoch nur für den positiven Array-Index. Verwenden Sie den Index selbst, um die letzten zwei oder drei Elemente zu entfernen.

Spleißen Sie beispielsweise (-2), um die letzten beiden Elemente zu entfernen. Spleiß (-3) zum Entfernen der letzten drei Elemente.

Es ist erwähnenswert , dass die Feststellung slicewird sowohl ein Rückkehr neues Array, während .pop()und .splice()das mutiert bestehendes Array.

Wenn Sie gerne Datensammlungen mit einem verketteten Befehlsstil verarbeiten, sollten Sie sich wirklich an sliceso etwas halten.

Zum Beispiel:

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

Es kann viel mehr Flickschusterei erfordern, und variable Management, die gleiche Art der Sache zu tun mit „Pop“, da im Gegensatz zu map, filterusw, bekommt man nicht ein neues Array zurück.

Es ist dasselbe, bei pushdem ein Element am Ende eines Arrays hinzugefügt wird. Sie könnten besser dran sein, concatda Sie so den Fluss am Laufen halten können.

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
  

Mit Lodash können Sie dropRight verwenden , wenn Sie nicht wissen möchten , welche Elemente entfernt wurden:

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

2019 ECMA5-Lösung:

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

Zerstörungsfrei, generisch, einzeilig und erfordert nur ein Kopieren und Einfügen am Ende Ihres Arrays.

sag du hast var arr = [1,0,2]

arr.splice(-1,1)wird zu dir zurückkehren, array [1,0];während arr.slice(-1,1)zu dir zurückkehren wirdarray [2];

Dies ist ein guter Weg, um das letzte Element zu entfernen:

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

Detail des Spleißes wie folgt:

Spleiß (startIndex, Anzahl der Spleiße)

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

stack.reverse().shift();

stack.push(0);

Die Ausgabe lautet : Array [0,1,2,3,4,5] . Auf diese Weise können Sie die gleiche Anzahl von Array-Elementen beibehalten, während Sie einen neuen Wert eingeben.

Ein anderer Ansatz besteht darin, basierend auf dem Index zu filtern:

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

Hinweis: filter()Erstellt ein neues Array und ändert das vorhandene nicht.

Wenn Sie n Elemente in Javascript vom Ende des Arrays entfernen möchten, können Sie einfach Folgendes verwenden:

arr.splice(-n, n);