Usuń ostatni element z tablicy

Mam następującą tablicę.

var arr = [1,0,2];

Chciałbym usunąć ostatni element, tj. 2.

Użyłem, arr.slice(-1);ale nie usuwa wartości.

Użyj splice (indeks, howmany)

arr.splice(-1,1)

Array.prototype.pop () według konwencji JavaScript.

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

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

Możesz to zrobić przy użyciu .slice()metody takiej jak:

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

Oto 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>

zamiast robić:

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

Oto 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>

Wyjaśnienie:-

Teraz podstawową składnią Array.prototype.slice()lub w skrócie slice()jest:

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

Tutaj,

beginparametr zera wskaźnik na jakim wyrzutu z rozpoczęciem tablicy. Powiedzmy na podstawie powyższego przykładu, jeśli zrobimy coś takiego

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

zwróci wszystkie elementy tablicy od początku sekwencji od pozycji 0 i to znaczy [1,0,2]. Podobnie, jeśli to zrobimy

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

powróci, [0,2]ponieważ 0 jest tutaj na pozycji 1, a potem wszystko. Teraz w twoim przypadku minąłeś indeks ujemny, tj. -1Jako parametr początkowy, który wskazuje przesunięcie od końca sekwencji. Tak więc, slice(-1)w przypadku ekstraktów ostatni element tablicy w kolejności i to 2( jak widzieliśmy już w powyższym demo ).

Teraz porozmawiajmy o endparametrze w slice()składni metody tutaj. Jest to ponownie indeks zerowy, przy którym kończy się ekstrakcja z tablicy. Powiedzmy, że mamy tablicę typu: -

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

i chcemy uzyskać tylko 2,5,3elementy z tablicy. Teraz pozycja 2od początku sekwencji jest 2i dla ostatniego elementu 3jest 4. Będziemy musieli zakończyć ekstrakcję tutaj pozycję 5, ponieważ musimy zdobyć element przed tą pozycją. Tak więc po prostu zaimplementujemy slice()tutaj metodę jak

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

W twoim przypadku zaimplementowaliśmy -1jako parametr końcowy, więc nasz kod jest podobny

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

Jako indeks ujemny endwskazuje przesunięcie od końca sekwencji. Wyodrębnia więc slice(0,-1)pierwszy element od drugiego do ostatniego elementu w sekwencji. Otrzymujemy więc pożądaną wydajność. Możemy również zrobić jak

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

otrzymamy taką samą wydajność. Ale użyłem -1tutaj, ponieważ jest łatwiejszy do wdrożenia, nawet dla długiej tablicy

[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 po prostu usunąć ostatni element, nie chcesz usiąść i obliczyć pozycji ostatnich 9 tutaj i zrobić to arr.slice(0, 22). Następnie możesz po prostu zaimplementować logikę indeksu ujemnego tutaj i wykonaj

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

Mam nadzieję, że to pomoże!

ucz 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]

Musisz to zrobić, ponieważ slicenie 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();

Uważam to za .pop()najbardziej „poprawne” rozwiązanie, jednak czasami może nie działać, ponieważ musisz użyć tablicy bez ostatniego elementu ...

W takim przypadku możesz skorzystać z następujących opcji, funkcja zwróci [1,2,3]

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

podczas gdy .pop()wróci 4:

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

co może być niepożądane ...

Mam nadzieję, że to pozwoli Ci zaoszczędzić trochę czasu.

Jest na to funkcja, wyjaśnienie tutaj :

arr.pop();

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

Spowoduje to usunięcie ostatniego wpisu tablicy.

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

Po prostu skorzystaj z następujących opcji dla swojego przypadku użycia:

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

Tylko uwaga. Gdy wykonasz pop()funkcję, mimo że linia zwraca wyskakujący element, zachowana jest oryginalna tablica i usuwany jest wyskakujący element.

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 liczony od zera, od którego zacząć usuwanie. how_many_data_to_delete: Ze wskazanego indeksu, ile kolejnych danych należy usunąć.

Możesz także usunąć ostatni element, używając pop()as pop()usuwa ostatni element z jakiejś tablicy.
Posługiwać sięarr.pop()

arr.slice(-1)zwróci kopię ostatniego elementu tablicy, ale pozostawi oryginalną tablicę niezmodyfikowaną.

Aby usunąć ostatnie nelementy z tablicy, użyjarr.splice(-n) (zwróć uwagę na „p” w „splice”). Zwrócona wartość będzie nową tablicą zawierającą usunięte elementy.

Jeszcze prostsze w n == 1użyciuval = arr.pop()

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

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

Ta metoda jest bardziej przydatna do usuwania i przechowywania ostatniego elementu tablicy.

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ą następujące:

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

Warto zauważyć, że slicezarówno zwróci nową tablicę, jak .pop()i .splice()zmutuje istniejącą tablicę.

Jeśli lubisz obsługiwać kolekcje danych w stylu łańcucha poleceń, naprawdę będziesz chciał się trzymać slice 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

To może wymagać dużo bardziej ingerować i zmienną zarządzania, do tego samego rodzaju rzeczy z „pop”, ponieważ w przeciwieństwie do map,filter itp, nie dostaniesz nową tablicę plecy.

Jest to ten sam rodzaj rzeczy push, który dodaje element na końcu tablicy. Lepiej może być, concatponieważ pozwala to utrzymać płynność.

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) - To rozwiązanie brzmi dobrze. Ale to howmany będzie działać tylko dla pozytywnego indeksu tablicy. Aby usunąć ostatnie dwa lub trzy elementy, użyj samego indeksu.

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

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]

var a = [1,2,3,4,5,6]; 
console.log(a.reverse().slice(1).reverse());
//Array(5) [ 1, 2, 3, 4, 5 ]

Rozwiązanie ECMA5 2019:

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

Nieniszczący, ogólny, jednowarstwowy i wymaga tylko kopiowania i wklejania na końcu tablicy.

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

arr.splice(-1,1)wróci do ciebie, array [1,0];a arr.slice(-1,1)wróci do ciebiearray [2];

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, jak następuje:

splice (startIndex, liczba splice)

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

stack.reverse().shift();

stack.push(0);

Dane wyjściowe to: Array [0,1,2,3,4,5] . Pozwoli ci to zachować taką samą liczbę elementów tablicy, jak wpychasz nową wartość.

Innym podejściem jest filtrowanie na podstawie indeksu:

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

Uwaga: filter()tworzy nową tablicę, nie zmienia istniejącej.

Jeśli chcesz usunąć n elementu z końca tablicy w javascript, możesz łatwo użyć:

arr.splice(-n, n);