Xóa mục cuối cùng khỏi mảng

Tôi có mảng sau.

var arr = [1,0,2];

Tôi muốn loại bỏ phần tử cuối cùng tức là 2.

Tôi đã sử dụng arr.slice(-1);nhưng nó không loại bỏ giá trị.

Sử dụng mối nối (index, howmany)

arr.splice(-1,1)

Array.prototype.pop () theo quy ước JavaScript.

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

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

Bạn có thể làm điều này bằng .slice()phương pháp như:

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

Đây là một bản 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>

thay vì làm:

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

Đây là một bản 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>

Giải trình:-

Bây giờ cú pháp cơ bản của Array.prototype.slice()hoặc trong slice()phương thức ngắn là:

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

Đây,

các begintham số là không dựa trên chỉ số mà tại đó khai thác từ một mảng bắt đầu. Vì vậy, hãy nói dựa trên ví dụ trên nếu chúng ta làm một cái gì đó như

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

nó sẽ trả về tất cả các phần tử mảng từ đầu chuỗi từ vị trí 0 và đó là [1,0,2]. Tương tự, nếu chúng ta làm

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

nó sẽ trở lại [0,2]vì 0 ở vị trí 1 ở đây và mọi thứ sau đó. Bây giờ, trong trường hợp của bạn, bạn đã vượt qua một chỉ số âm nghĩa -1là tham số bắt đầu, biểu thị phần bù từ cuối chuỗi. Vì vậy, slice(-1)trong trường hợp của bạn trích xuất phần tử một mảng cuối cùng trong chuỗi và đó là2 ( như chúng ta đã thấy trong bản demo ở trên ).

Bây giờ, hãy nói về endtham số trong slice()cú pháp phương thức ở đây. Nó lại là một chỉ số dựa trên zero mà tại đó trích xuất từ ​​một mảng kết thúc. Vì vậy, giả sử chúng ta có một mảng như: -

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

và chúng tôi muốn chỉ lấy các 2,5,3phần tử trong mảng. Bây giờ, vị trí của 2từ bắt đầu của chuỗi là 2và cho yếu tố cuối cùng 3nó là 4. Chúng ta sẽ cần kết thúc việc trích xuất ở đây một vị trí 5, vì chúng ta cần lấy phần tử trước vị trí đó. Vì vậy, chúng tôi sẽ đơn giản thực hiện slice()phương pháp ở đây như

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

Trong trường hợp của bạn, chúng tôi đã triển khai -1như là tham số cuối, vì vậy mã của chúng tôi giống như

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

Là một chỉ số âm, endchỉ ra một phần bù từ cuối chuỗi. Vì vậy, slice(0,-1)trích xuất phần tử đầu tiên thông qua phần tử thứ hai đến cuối cùng trong chuỗi. Vì vậy, chúng tôi nhận được đầu ra mong muốn. Chúng ta cũng có thể làm như

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

chúng ta sẽ nhận được cùng một đầu ra. Nhưng, tôi đã sử dụng -1ở đây vì nó dễ thực hiện hơn ngay cả đối với một mảng dài như

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

Nếu bạn chỉ muốn xóa phần tử cuối cùng, bạn không muốn ngồi và tính toán vị trí của 9 phần cuối ở đây và làm như thế nào arr.slice(0, 22). Sau đó, bạn có thể thực hiện logic chỉ mục phủ định ở đây & làm

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

Hy vọng nó giúp!

học bằng ví dụ:

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]

Bạn sẽ cần phải làm điều này vì slicekhông thay đổi mảng ban đầu.

arr = arr.slice(-1);

Nếu bạn muốn thay đổi mảng ban đầu, bạn có thể sử dụng splice:

arr.splice(-1, 1);

hoặc pop:

arr.pop();

Tôi sẽ cân nhắc .pop() là giải pháp 'đúng' nhất, tuy nhiên, đôi khi nó có thể không hoạt động vì bạn cần sử dụng mảng mà không có phần tử cuối cùng ngay tại đó ...

Trong trường hợp như vậy bạn có thể muốn sử dụng như sau, nó sẽ trả về [1,2,3]

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

trong khi .pop()sẽ trở lại 4:

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

điều có thể không được mong muốn ...

Hy vọng điều này sẽ giúp bạn tiết kiệm thời gian.

Có một chức năng cho điều đó, giải thích ở đây :

arr.pop();

Bạn chỉ có thể sử dụng, arr.pop()

Điều này loại bỏ các mục cuối cùng của mảng.

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

Chỉ cần sử dụng như sau cho trường hợp sử dụng của bạn:

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

Chỉ cần một lưu ý. Khi bạn thực thi pop()chức năng mặc dù dòng trả về mục popped, mảng ban đầu bị ảnh hưởng và phần tử popped bị loại bỏ.

Bạn có thể làm theo hai cách bằng cách sử dụng splice():

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

splice(position_to_start_deleting, how_many_data_to_delete) mất hai tham số.

position_to_start_deleting: Chỉ số dựa trên số 0 từ đâu bắt đầu xóa. how_many_data_to_delete: Từ chỉ mục được chỉ định, nên xóa bao nhiêu dữ liệu liên tiếp.

Bạn cũng có thể loại bỏ các yếu tố cuối cùng sử dụng pop()nhưpop() loại bỏ các yếu tố cuối cùng từ một số mảng.
Sử dụngarr.pop()

arr.slice(-1)sẽ trả lại một bản sao của phần tử cuối cùng của mảng, nhưng để lại mảng ban đầu không được sửa đổi.

Để loại bỏ các nphần tử cuối cùng khỏi một mảng, sử dụngarr.splice(-n) (lưu ý "p" trong "mối nối"). Giá trị trả về sẽ là một mảng mới chứa các phần tử bị loại bỏ.

Đơn giản hơn, cho n == 1, sử dụngval = arr.pop()

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

// xóa phần tử cuối cùng // cần kiểm tra xem Array.length> 0

Phương pháp này hữu ích hơn để xóa và lưu trữ phần tử cuối cùng của một mảng.

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.

Bây giờ kết quả là:

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

splice (index, howmany) - Giải pháp này nghe có vẻ tốt. Nhưng howmany này sẽ chỉ làm việc cho chỉ số mảng tích cực. Để loại bỏ hai mục cuối hoặc ba mục, hãy sử dụng chính chỉ mục.

Ví dụ: mối nối (-2) để xóa hai mục cuối. mối nối (-3) để loại bỏ ba mục cuối cùng.

Điều đáng chú ý là slicecả hai sẽ trả về một mảng mới , trong khi .pop()và .splice()sẽ làm thay đổi hiện tại mảng .

Nếu bạn thích xử lý các bộ sưu tập dữ liệu với kiểu lệnh chuỗi, bạn sẽ thực sự muốn gắn bó với slicethứ gì đó như thế này.

Ví dụ:

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

Nó có thể đòi hỏi nhiều rối tung thêm về, và quản lý thay đổi, để làm cùng một loại điều với "pop", vì không giống như map, filter, vv, bạn không nhận được một mảng mới trở lại.

Đó là cùng một loại với push, thêm một mục vào cuối một mảng. Bạn có thể tốt hơn concatvì điều đó cho phép bạn tiếp tục dòng chảy.

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
  

Với Lodash, bạn có thể sử dụng dropRight , nếu bạn không quan tâm để biết phần tử nào đã bị xóa:

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

Giải pháp ECMA5 2019:

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

Không phá hủy, chung chung, một lớp lót và chỉ yêu cầu một bản sao và dán vào cuối mảng của bạn.

nói rằng bạn có var arr = [1,0,2]

arr.splice(-1,1)sẽ trở lại với bạn array [1,0];trong khi arr.slice(-1,1)sẽ trở lại với bạnarray [2];

Đây là cách tốt để loại bỏ mục cuối cùng:

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

Chi tiết mối nối như sau:

mối nối (start Index, số lượng mối nối)

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

stack.reverse().shift();

stack.push(0);

Đầu ra sẽ là: Mảng [0,1,2,3,4,5] . Điều này sẽ cho phép bạn giữ cùng một lượng phần tử mảng khi bạn đẩy một giá trị mới vào.

Một cách tiếp cận khác là lọc dựa trên chỉ mục:

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

Lưu ý: filter()tạo mảng mới, không thay đổi mảng hiện có.

Nếu bạn muốn xóa n mục khỏi cuối mảng trong javascript, bạn có thể dễ dàng sử dụng:

arr.splice(-n, n);