Sự khác biệt giữa việc sử dụng là gì các deletenhà điều hành trên phần tử mảng như trái ngược với việc sử dụng các Array.splicephương pháp ?

Ví dụ:

myArray = ['a', 'b', 'c', 'd'];

delete myArray[1];
//  or
myArray.splice (1, 1);

Tại sao thậm chí có phương thức mối nối nếu tôi có thể xóa các phần tử mảng như tôi có thể với các đối tượng?

deletesẽ xóa thuộc tính đối tượng, nhưng sẽ không reindex mảng hoặc cập nhật chiều dài của nó. Điều này làm cho nó xuất hiện như thể nó không được xác định:

> myArray = ['a', 'b', 'c', 'd']
  ["a", "b", "c", "d"]
> delete myArray[0]
  true
> myArray[0]
  undefined

Lưu ý rằng trên thực tế nó không được đặt thành giá trị undefined, thay vào đó thuộc tính được xóa khỏi mảng, làm cho nó xuất hiện không xác định. Các công cụ phát triển Chrome giúp phân biệt rõ ràng bằng cách in emptykhi ghi nhật ký mảng.

> myArray[0]
  undefined
> myArray
  [empty, "b", "c", "d"]

myArray.splice(start, deleteCount) thực sự loại bỏ phần tử, giới thiệu lại mảng và thay đổi độ dài của nó.

> myArray = ['a', 'b', 'c', 'd']
  ["a", "b", "c", "d"]
> myArray.splice(0, 2)
  ["a", "b"]
> myArray
  ["c", "d"]

Phương thức Array.remove ()

John Resig , người tạo ra jQuery đã tạo ra một Array.removephương thức rất tiện dụng mà tôi luôn sử dụng nó trong các dự án của mình.

// Array Remove - By John Resig (MIT Licensed)
Array.prototype.remove = function(from, to) {
  var rest = this.slice((to || from) + 1 || this.length);
  this.length = from < 0 ? this.length + from : from;
  return this.push.apply(this, rest);
};

và đây là một số ví dụ về cách sử dụng nó:

// Remove the second item from the array
array.remove(1);
// Remove the second-to-last item from the array
array.remove(-2);
// Remove the second and third items from the array
array.remove(1,2);
// Remove the last and second-to-last items from the array
array.remove(-2,-1);

Trang web của John

Vì xóa chỉ xóa đối tượng khỏi thành phần trong mảng, nên độ dài của mảng sẽ không thay đổi. Splice loại bỏ đối tượng và rút ngắn mảng.

Đoạn mã sau sẽ hiển thị "a", "b", "không xác định", "d"

myArray = ['a', 'b', 'c', 'd']; delete myArray[2];

for (var count = 0; count < myArray.length; count++) {
    alert(myArray[count]);
}

Trong khi đó, điều này sẽ hiển thị "a", "b", "d"

myArray = ['a', 'b', 'c', 'd']; myArray.splice(2,1);

for (var count = 0; count < myArray.length; count++) {
    alert(myArray[count]);
}

Tôi vấp phải câu hỏi này trong khi cố gắng hiểu làm thế nào để loại bỏ mọi sự xuất hiện của một phần tử khỏi Mảng. Dưới đây là một so sánh của splicevà deleteđể loại bỏ tất cả các 'c'từ itemsArray.

var items = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'];

while (items.indexOf('c') !== -1) {
  items.splice(items.indexOf('c'), 1);
}

console.log(items); // ["a", "b", "d", "a", "b", "d"]

items = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'];

while (items.indexOf('c') !== -1) {
  delete items[items.indexOf('c')];
}

console.log(items); // ["a", "b", undefined, "d", "a", "b", undefined, "d"]
​

Từ Core JavaScript 1.5 Tham khảo> Toán tử> Toán tử đặc biệt> xóa Toán tử :

Khi bạn xóa một phần tử mảng, độ dài mảng không bị ảnh hưởng. Ví dụ: nếu bạn xóa [3], [4] vẫn là [4] và [3] không xác định. Điều này giữ ngay cả khi bạn xóa phần tử cuối cùng của mảng (xóa [a.length-1]).

splice sẽ làm việc với các chỉ số số.

trong khi đó deletecó thể được sử dụng để chống lại các loại chỉ số khác ..

thí dụ:

delete myArray['text1'];

Có lẽ cũng đáng đề cập rằng mối nối chỉ hoạt động trên mảng. (Thuộc tính đối tượng không thể dựa vào để tuân theo một trật tự nhất quán.)

Để xóa cặp khóa-giá trị khỏi một đối tượng, xóa thực sự là những gì bạn muốn:

delete myObj.propName;     // , or:
delete myObj["propName"];  // Equivalent.

xóa Vs mối nối

khi bạn xóa một mục từ một mảng

var arr = [1,2,3,4]; delete arr[2]; //result [1, 2, 3:, 4]
console.log(arr)

khi bạn nối

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

trong trường hợp xóa các phần tử được xóa nhưng chỉ số vẫn còn trống

trong khi trong trường hợp phần tử mối nối bị xóa và chỉ số của các phần tử còn lại bị giảm theo

Như đã nói nhiều lần ở trên, sử dụng splice()có vẻ như là một sự phù hợp hoàn hảo. Tài liệu tại Mozilla:

Các splice()phương pháp làm thay đổi nội dung của một mảng bằng cách loại bỏ các yếu tố hiện hữu và / hoặc thêm các yếu tố mới.

var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];

myFish.splice(2, 0, 'drum'); 
// myFish is ["angel", "clown", "drum", "mandarin", "sturgeon"]

myFish.splice(2, 1); 
// myFish is ["angel", "clown", "mandarin", "sturgeon"]

Cú pháp

array.splice(start)
array.splice(start, deleteCount)
array.splice(start, deleteCount, item1, item2, ...)

Thông số

khởi đầu

Chỉ mục để bắt đầu thay đổi mảng. Nếu lớn hơn chiều dài của mảng, chỉ số bắt đầu thực tế sẽ được đặt thành chiều dài của mảng. Nếu tiêu cực, sẽ bắt đầu mà nhiều yếu tố từ cuối.

xóaCount

Một số nguyên chỉ số lượng phần tử mảng cũ cần loại bỏ. Nếu xóaCount là 0, không có phần tử nào bị xóa. Trong trường hợp này, bạn nên chỉ định ít nhất một yếu tố mới. Nếu removeCount lớn hơn số phần tử còn lại trong mảng bắt đầu từ lúc bắt đầu, thì tất cả các phần tử cho đến cuối mảng sẽ bị xóa.

Nếu xóaCount bị bỏ qua, xóaCount sẽ bằng (arr.length - start).

mục1, mục2, ...

Các yếu tố để thêm vào mảng, bắt đầu tại chỉ mục bắt đầu. Nếu bạn không chỉ định bất kỳ phần tử nào, splice()sẽ chỉ xóa các phần tử khỏi mảng.

Giá trị trả về

Một mảng chứa các phần tử bị xóa. Nếu chỉ có một phần tử bị loại bỏ, một mảng của một phần tử được trả về. Nếu không có phần tử nào bị xóa, một mảng trống được trả về.

[...]

xóa các hành động như một tình huống không có trong thế giới thực, nó chỉ xóa các mục, nhưng độ dài mảng vẫn giữ nguyên:

ví dụ từ thiết bị đầu cuối nút:

> var arr = ["a","b","c","d"];
> delete arr[2]
true
> arr
[ 'a', 'b', , 'd', 'e' ]

Đây là một hàm để loại bỏ một mục của một mảng theo chỉ mục, sử dụng lát () , nó lấy mảng làm đối số đầu tiên và chỉ mục của thành viên bạn muốn xóa làm đối số thứ hai. Như bạn có thể thấy, nó thực sự xóa thành viên của mảng và sẽ giảm 1 chiều dài mảng

function(arr,arrIndex){
    return arr.slice(0,arrIndex).concat(arr.slice(arrIndex + 1));
}

Những gì chức năng trên thực hiện là đưa tất cả các thành viên lên chỉ mục và tất cả các thành viên sau chỉ mục và nối chúng lại với nhau và trả về kết quả.

Dưới đây là một ví dụ sử dụng hàm trên dưới dạng mô-đun nút, xem thiết bị đầu cuối sẽ hữu ích:

> var arr = ["a","b","c","d"]
> arr
[ 'a', 'b', 'c', 'd' ]
> arr.length
4 
> var arrayRemoveIndex = require("./lib/array_remove_index");
> var newArray = arrayRemoveIndex(arr,arr.indexOf('c'))
> newArray
[ 'a', 'b', 'd' ] // c ya later
> newArray.length
3

xin lưu ý rằng điều này sẽ không hoạt động một mảng với các bản sao trong đó, bởi vì indexOf ("c") sẽ chỉ có lần xuất hiện đầu tiên, và chỉ tách ra và loại bỏ "c" đầu tiên mà nó tìm thấy.

Nếu bạn muốn lặp lại một mảng lớn và xóa có chọn lọc các phần tử, sẽ rất tốn kém khi gọi splice () cho mỗi lần xóa vì splice () sẽ phải lập chỉ mục lại các phần tử tiếp theo mỗi lần. Vì các mảng được liên kết trong Javascript, nên sẽ hiệu quả hơn khi xóa các thành phần riêng lẻ sau đó lập chỉ mục lại mảng sau đó.

Bạn có thể làm điều đó bằng cách xây dựng một mảng mới. ví dụ

function reindexArray( array )
{
       var result = [];
        for( var key in array )
                result.push( array[key] );
        return result;
};

Nhưng tôi không nghĩ rằng bạn có thể sửa đổi các giá trị chính trong mảng ban đầu, sẽ hiệu quả hơn - có vẻ như bạn có thể phải tạo một mảng mới.

Lưu ý rằng bạn không cần kiểm tra các mục "không xác định" vì chúng không thực sự tồn tại và vòng lặp for không trả lại chúng. Đó là một tạo tác của việc in mảng hiển thị chúng là không xác định. Chúng dường như không tồn tại trong bộ nhớ.

Sẽ thật tuyệt nếu bạn có thể sử dụng một cái gì đó như lát () sẽ nhanh hơn, nhưng nó không lập chỉ mục lại. Bất cứ ai biết một cách tốt hơn?

Trên thực tế, bạn có thể có thể làm điều đó đúng như sau, điều này có thể hiệu quả hơn, hiệu quả hơn:

reindexArray : function( array )
{
    var index = 0;                          // The index where the element should be
    for( var key in array )                 // Iterate the array
    {
        if( parseInt( key ) !== index )     // If the element is out of sequence
        {
            array[index] = array[key];      // Move it to the correct, earlier position in the array
            ++index;                        // Update the index
        }
    }

    array.splice( index );  // Remove any remaining elements (These will be duplicates of earlier items)
},

bạn có thể sử dụng một cái gì đó như thế này

var my_array = [1,2,3,4,5,6];
delete my_array[4];
console.log(my_array.filter(function(a){return typeof a !== 'undefined';})); // [1,2,3,4,6]

Tại sao không chỉ lọc? Tôi nghĩ đó là cách rõ ràng nhất để xem xét các mảng trong js.

myArray = myArray.filter(function(item){
    return item.anProperty != whoShouldBeDeleted
});

Có thể thấy sự khác biệt bằng cách ghi lại độ dài của mỗi mảng sau khi deletetoán tử và splice()phương thức được áp dụng. Ví dụ:

xóa toán tử

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
delete trees[3];

console.log(trees); // ["redwood", "bay", "cedar", empty, "maple"]
console.log(trees.length); // 5

Các deletenhà điều hành loại bỏ các phần tử từ mảng, nhưng "giữ chỗ" của nguyên tố này vẫn còn tồn tại. oakđã được gỡ bỏ nhưng nó vẫn chiếm không gian trong mảng. Bởi vì điều này, chiều dài của mảng vẫn là 5.

phương thức splice ()

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
trees.splice(3,1);

console.log(trees); // ["redwood", "bay", "cedar", "maple"]
console.log(trees.length); // 4

Các splice()phương pháp hoàn toàn loại bỏ các giá trị mục tiêu và các "giữ chỗ" là tốt. oakđã được loại bỏ cũng như không gian nó được sử dụng để chiếm trong mảng. Độ dài của mảng bây giờ là 4.

function remove_array_value(array, value) {
    var index = array.indexOf(value);
    if (index >= 0) {
        array.splice(index, 1);
        reindex_array(array);
    }
}
function reindex_array(array) {
   var result = [];
    for (var key in array) {
        result.push(array[key]);
    }
    return result;
}

thí dụ:

var example_arr = ['apple', 'banana', 'lemon'];   // length = 3
remove_array_value(example_arr, 'banana');

chuối bị xóa và chiều dài mảng = 2

Chúng là những thứ khác nhau có mục đích khác nhau.

splicelà đặc trưng cho mảng và, khi được sử dụng để xóa, sẽ xóa các mục khỏi mảng và di chuyển tất cả các mục trước đó lên để lấp đầy khoảng trống. (Nó cũng có thể được sử dụng để chèn các mục nhập hoặc cả hai cùng một lúc.) spliceSẽ thay đổi lengthmảng (giả sử đó không phải là cuộc gọi không hoạt động theArray.splice(x, 0):).

deletekhông phải là mảng cụ thể; nó được thiết kế để sử dụng trên các đối tượng: Nó loại bỏ một thuộc tính (cặp khóa / giá trị) khỏi đối tượng bạn sử dụng. Nó chỉ áp dụng cho các mảng vì các mảng tiêu chuẩn (ví dụ: không được gõ) trong JavaScript hoàn toàn không phải là mảng *, chúng là các đối tượng có xử lý đặc biệt cho các thuộc tính nhất định, chẳng hạn như các tên có "chỉ mục mảng" (là được định nghĩa là tên chuỗi "... có giá trị số inằm trong phạm vi +0 ≤ i < 2^32-1") và length. Khi bạn sử dụng deleteđể loại bỏ một mục mảng, tất cả những gì nó làm là loại bỏ mục nhập; nó không di chuyển các mục khác theo sau nó để lấp đầy khoảng trống, và do đó mảng trở nên "thưa thớt" (có một số mục bị thiếu hoàn toàn). Nó không có tác dụng length.

Một vài câu trả lời hiện tại cho câu hỏi này nói không chính xác rằng sử dụng delete"đặt mục nhập thành undefined". Điều đó không đúng. Nó loại bỏ hoàn toàn mục (tài sản), để lại một khoảng cách.

Hãy sử dụng một số mã để minh họa sự khác biệt:

console.log("Using `splice`:");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
a.splice(0, 1);
console.log(a.length);            // 4
console.log(a[0]);                // "b"

console.log("Using `delete`");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
delete a[0];
console.log(a.length);            // still 5
console.log(a[0]);                // undefined
console.log("0" in a);            // false
console.log(a.hasOwnProperty(0)); // false

console.log("Setting to `undefined`");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
a[0] = undefined;
console.log(a.length);            // still 5
console.log(a[0]);                // undefined
console.log("0" in a);            // true
console.log(a.hasOwnProperty(0)); // true

* (đó là một bài đăng trên blog nhỏ thiếu máu của tôi)

Hiện tại có hai cách để làm điều này

1. sử dụng mối nối ()

   arrayObject.splice(index, 1);

2. sử dụng xóa

   delete arrayObject[index];

Nhưng tôi luôn đề nghị sử dụng mối nối cho các đối tượng mảng và xóa cho các thuộc tính đối tượng vì xóa không cập nhật chiều dài mảng.

OK, hãy tưởng tượng chúng ta có mảng này dưới đây:

const arr = [1, 2, 3, 4, 5];

Trước tiên hãy xóa:

delete arr[1];

Và đây là kết quả:

[1, empty, 3, 4, 5];

trống! và hãy lấy nó:

arr[1]; //undefined

Vì vậy, có nghĩa là chỉ giá trị bị xóa và hiện tại nó không được xác định , vì vậy độ dài là như nhau, nó cũng sẽ trả về đúng ...

Hãy thiết lập lại mảng của chúng tôi và thực hiện nó với mối nối lần này:

arr.splice(1, 1);

và đây là kết quả lần này:

[1, 3, 4, 5];

Như bạn thấy chiều dài mảng đã thay đổi và giờ arr[1]là 3 ...

Ngoài ra, điều này sẽ trả về mục đã xóa trong một mảng [3]trong trường hợp này ...

Những người khác đã được so sánh đúng deletevới splice.

Một so sánh thú vị là deleteso với undefined: a mục mảng xóa sử dụng ít bộ nhớ hơn một mà chỉ được thiết lập để undefined;

Ví dụ: mã này sẽ không hoàn thành:

let y = 1;
let ary = [];
console.log("Fatal Error Coming Soon");
while (y < 4294967295)
{
    ary.push(y);
    ary[y] = undefined;
    y += 1;
}
console(ary.length);

Nó tạo ra lỗi này:

FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed - JavaScript heap out of memory.

Vì vậy, như bạn có thể thấy undefinedthực sự chiếm bộ nhớ heap.

Tuy nhiên, nếu bạn cũng là deletemục ary (thay vì chỉ đặt nó thành undefined), mã sẽ từ từ kết thúc:

let x = 1;
let ary = [];
console.log("This will take a while, but it will eventually finish successfully.");
while (x < 4294967295)
{
    ary.push(x);
    ary[x] = undefined;
    delete ary[x];
    x += 1;
}
console.log(`Success, array-length: ${ary.length}.`);

Đây là những ví dụ cực đoan, nhưng chúng đưa ra quan điểm deleterằng tôi chưa thấy ai nhắc đến ở bất cứ đâu.

Nếu bạn có mảng nhỏ, bạn có thể sử dụng filter:

myArray = ['a', 'b', 'c', 'd'];
myArray = myArray.filter(x => x !== 'b');

Cách dễ nhất có lẽ là

var myArray = ['a', 'b', 'c', 'd'];
delete myArray[1]; // ['a', undefined, 'c', 'd']. Then use lodash compact method to remove false, null, 0, "", undefined and NaN
myArray = _.compact(myArray); ['a', 'c', 'd'];

Hi vọng điêu nay co ich. Tham khảo: https://lodash.com/docs#compact

Đối với những người muốn sử dụng Lodash có thể sử dụng: myArray = _.without(myArray, itemToRemove)

Hoặc như tôi sử dụng trong Angular2

import { without } from 'lodash';
...
myArray = without(myArray, itemToRemove);
...

xóa : xóa sẽ xóa thuộc tính đối tượng, nhưng sẽ không reindex mảng hoặc cập nhật chiều dài của nó. Điều này làm cho nó xuất hiện như thể nó không được xác định:

splice : thực sự loại bỏ phần tử, giới thiệu lại mảng và thay đổi độ dài của nó.

Xóa phần tử từ cuối cùng

arrName.pop();

Xóa phần tử từ đầu tiên

arrName.shift();

Xóa từ giữa

arrName.splice(starting index,number of element you wnt to delete);

Ex: arrName.splice(1,1);

Xóa một yếu tố cuối cùng

arrName.splice(-1);

Xóa bằng cách sử dụng số chỉ mục mảng

 delete arrName[1];

Nếu phần tử mong muốn xóa nằm ở giữa (giả sử chúng tôi muốn xóa 'c', chỉ số của nó là 1), bạn có thể sử dụng:

var arr = ['a','b','c'];
var indexToDelete = 1;
var newArray = arr.slice(0,indexToDelete).combine(arr.slice(indexToDelete+1, arr.length))

IndexOfcũng chấp nhận một loại tham chiếu. Giả sử kịch bản sau đây:

var arr = [{item: 1}, {item: 2}, {item: 3}];
var found = find(2, 3); //pseudo code: will return [{item: 2}, {item:3}]
var l = found.length;

while(l--) {
   var index = arr.indexOf(found[l])
      arr.splice(index, 1);
   }
   
console.log(arr.length); //1

Khác nhau:

var item2 = findUnique(2); //will return {item: 2}
var l = arr.length;
var found = false;
  while(!found && l--) {
  found = arr[l] === item2;
}

console.log(l, arr[l]);// l is index, arr[l] is the item you look for

function deleteFromArray(array, indexToDelete){
  var remain = new Array();
  for(var i in array){
    if(array[i] == indexToDelete){
      continue;
    }
    remain.push(array[i]);
  }
  return remain;
}

myArray = ['a', 'b', 'c', 'd'];
deleteFromArray(myArray , 0);

// kết quả: myArray = ['b', 'c', 'd'];