Usuń ostatni element z tablicy

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

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

Dokumentacja tablicy.prototyp.pop na MDN

Możesz to zrobić za pomocą .slice() metoda jak:

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

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>

Zamiast robić :

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

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>

Wyjaśnienie:-

Teraz podstawowa składnia metody Array.prototype.slice() lub w skrócie slice() to:

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

Tutaj,

Parametr begin jest indeksem bazującym na 0, od którego rozpoczyna się ekstrakcja z tablicy. Tak więc, powiedzmy na podstawie powyższy przykład jeśli zrobimy coś w rodzaju

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

Zwróci wszystkie elementy tablicy od początku sekwencji z pozycji 0, czyli [1,0,2]. Podobnie, jeśli zrobimy

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

Zwróci [0,2] ponieważ 0 jest na pozycji 1 tutaj i wszystko po tym. W Twoim przypadku przekazałeś indeks ujemny, tj. -1 jako parametr begin, który wskazuje przesunięcie od końca sekwencji. Więc slice(-1) w Twoim przypadku wyciąga ostatni element tablicy w sekwencji i to jest 2 (Jak już widzieliśmy w powyższym demo ).

Porozmawiajmy teraz o parametrze end w składni metody slice(). Jest to ponownie indeks bazujący na 0, na którym kończy się ekstrakcja z tablicy. Tak więc, powiedzmy, że mamy tablicę w stylu: -

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

I chcemy uzyskać tylko 2,5,3 elementy w tablicy. Pozycja 2 Od początku sekwencji to 2, A Dla ostatniego elementu {[29] } to 4. Musimy zakończyć wydobycie tutaj a Pozycja 5, ponieważ musimy dostać element przed tą pozycją. Tak więc po prostu zaimplementujemy tutaj metodę slice() Jak

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

W Twoim przypadku zaimplementowaliśmy -1 jako parametr końcowy, więc nasz kod wygląda tak:

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

Jako indeks ujemny, end wskazuje przesunięcie od końca sekwencji. Tak więc slice(0,-1) wyciąga pierwszy element przez przedostatni element w sekwencji. Otrzymujemy więc pożądaną wydajność. Możemy również zrobić jak

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

Otrzymamy to samo wyjście. Ale użyłem -1 tutaj jako łatwiejsze do zaimplementowania nawet dla długiej tablicy, takiej jak

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

Jeśli chcesz usunąć ostatni element, nie chcesz siedzieć i obliczać pozycji ostatnich 9 tutaj i zrobić jak arr.slice(0, 22). Następnie możesz po prostu zaimplementować logikę indeksu ujemnego tutaj & do

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

Musiałbyś to zrobić, ponieważ slice nie zmienia oryginalnej tablicy.

arr = arr.slice(-1);

Jeśli chcesz zmienić oryginalną tablicę możesz użyć splice:

arr.splice(-1, 1);

Lub pop:

arr.pop();

Dowiedz się na przykładzie:

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]

Istnieje na to funkcja, Wyjaśnienie Tutaj :

arr.pop();

Możesz po prostu użyć, arr.pop()

Usuwa ostatni wpis tablicy.

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

arr.slice(-1) zwraca kopię ostatniego elementu tablicy, ale pozostawia oryginalną tablicę niezmodyfikowaną.

Aby usunąć ostatnie n elementy z tablicy, użyj arr.splice(-n) (zwróć uwagę na "p" w "splice"). Zwracaną wartością będzie nowa tablica zawierająca usunięte elementy.

Prostsze, dla n == 1, Użyj val = arr.pop()

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

// usuwa ostatni element // trzeba sprawdzić, czy arr.Długość > 0

Ta metoda jest bardziej pomocna w usuwaniu i przechowywaniu ostatniego elementu / align = "left" /

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.

Teraz wyniki są:

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

Uznałbym .pop() za najbardziej 'poprawne' rozwiązanie, jednak czasami może nie działać, ponieważ trzeba użyć tablicy bez ostatniego elementu...

W takim przypadku możesz użyć następującego

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

While .pop() zwróci to (4):

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

Splice (index,howmany) - To rozwiązanie brzmi dobrze. Ale to howmany będzie działać tylko dla dodatniego indeksu tablicy. Aby usunąć ostatnie dwa lub trzy elementy, użyj samego indeksu.

Na przykład, splice(-2), aby usunąć ostatnie dwa elementy. splice (-3) do usuwania ostatnich trzech elementów.

Warto zauważyć, że slicezwróci nową tablicę, podczas gdy .pop() i .splice()zmutują istniejącą tablicę.

Jeśli lubisz obsługiwać zbiory danych za pomocą łańcuchowego stylu poleceń, naprawdę będziesz chciał trzymać się slice dla czegoś takiego.

Na przykład:

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

Jest to ten sam rodzaj rzeczy z push, który dodaje element na końcu tablicy. Może lepiej Ci będzie z concat, ponieważ pozwala ci to utrzymać przepływ.

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
  

Możesz to zrobić na dwa sposoby używając splice():

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

splice(position_to_start_deleting, how_many_data_to_delete) przyjmuje dwa parametry.

position_to_start_deleting : indeks zerowy, od którego należy rozpocząć usuwanie. how_many_data_to_delete: ze wskazanego indeksu, ile kolejnych danych należy usunąć.

Możesz również usunąć ostatni element używając pop(), ponieważ pop() usuwa ostatni element z tablicy.
Użyj arr.pop()

Powiedz, że masz var arr = [1,0,2]

arr.splice(-1,1) powróci do ciebie array [1,0]; podczas gdy arr.slice(-1,1) powróci do ciebie array [2];

Jest to dobry sposób na usunięcie ostatniego elementu:

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

Szczegóły splotu w następujący sposób:

splice (startIndex, liczba splice)

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

stack.reverse().shift();

stack.push(0);

Wyjście będzie: Array[0,1,2,3,4,5] . Pozwoli to zachować taką samą ilość elementów tablicy, w jakiej wprowadzana jest nowa wartość.

Z Lodash możesz użyć dropRight , Jeśli nie chcesz wiedzieć, które elementy zostały usunięte:

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

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