Apa perbedaan antara menggunakan yang deleteoperator yang pada elemen array sebagai lawan menggunakan satu Array.splicemetode ?

Sebagai contoh:

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

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

Mengapa bahkan memiliki metode sambungan jika saya dapat menghapus elemen array seperti saya dapat dengan objek?

deleteakan menghapus properti objek, tetapi tidak akan mengindeks ulang array atau memperbarui panjangnya. Ini membuatnya tampak seolah-olah tidak terdefinisi:

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

Perhatikan bahwa sebenarnya tidak disetel ke nilai undefined, melainkan properti dihapus dari array, membuatnya tampak tidak terdefinisi. Alat dev Chrome membuat perbedaan ini jelas dengan mencetak emptysaat mencatat array.

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

myArray.splice(start, deleteCount) sebenarnya menghapus elemen, mengindeks ulang array, dan mengubah panjangnya.

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

Metode Array.remove ()

John Resig , pencipta jQuery menciptakan Array.removemetode yang sangat berguna yang selalu saya gunakan dalam proyek saya.

// 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);
};

dan inilah beberapa contoh cara penggunaannya:

// 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);

Situs web John

Karena delete hanya menghapus objek dari elemen dalam array, panjang array tidak akan berubah. Splice menghapus objek dan mempersingkat array.

Kode berikut akan menampilkan "a", "b", "undefined", "d"

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

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

Sedangkan ini akan menampilkan "a", "b", "d"

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

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

Saya menemukan pertanyaan ini sambil mencoba memahami cara menghapus setiap kemunculan elemen dari Array. Berikut adalah perbandingan dari splicedan deleteuntuk menghapus setiap 'c'dari 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"]
​

Dari Core JavaScript 1.5 Referensi> Operator> Operator Khusus> hapus Operator :

Ketika Anda menghapus elemen array, panjang array tidak terpengaruh. Misalnya, jika Anda menghapus [3], a [4] masih berupa [4] dan a [3] tidak ditentukan. Ini berlaku bahkan jika Anda menghapus elemen terakhir dari array (hapus a [a.length-1]).

splice akan bekerja dengan indeks numerik.

sedangkan deletedapat digunakan terhadap jenis indeks lainnya ..

contoh:

delete myArray['text1'];

Mungkin juga perlu disebutkan bahwa sambungan hanya berfungsi pada array. (Properti objek tidak dapat diandalkan untuk mengikuti urutan yang konsisten.)

Untuk menghapus pasangan nilai kunci dari suatu objek, hapus sebenarnya yang Anda inginkan:

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

hapus sambatan Vs

ketika Anda menghapus item dari sebuah array

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

ketika Anda sambatan

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

dalam kasus delete tersebut elemen dihapus namun indeks tetap kosong

sementara dalam kasus elemen sambatan dihapus dan indeks elemen sisanya dikurangi sesuai

Seperti yang dinyatakan berkali-kali di atas, menggunakan splice()sepertinya cocok. Dokumentasi di Mozilla:

The splice()Metode mengubah isi array dengan menghapus elemen yang ada dan / atau menambahkan elemen baru.

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

Sintaksis

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

Parameter

Mulailah

Indeks di mana untuk mulai mengubah array. Jika lebih besar dari panjang array, indeks awal aktual akan ditetapkan ke panjang array. Jika negatif, akan mulai banyak elemen dari akhir.

deleteCount

Integer yang menunjukkan jumlah elemen array lama untuk dihapus. Jika deleteCount adalah 0, tidak ada elemen yang dihapus. Dalam hal ini, Anda harus menentukan setidaknya satu elemen baru. Jika deleteCount lebih besar dari jumlah elemen yang tersisa dalam array mulai dari awal, maka semua elemen hingga akhir array akan dihapus.

Jika deleteCount dihilangkan, deleteCount akan sama dengan (arr.length - start).

item1, item2, ...

Elemen-elemen untuk ditambahkan ke array, mulai dari indeks awal. Jika Anda tidak menentukan elemen apa pun, splice()hanya akan menghapus elemen dari array.

Nilai pengembalian

Array yang mengandung elemen yang dihapus. Jika hanya satu elemen yang dihapus, array satu elemen dikembalikan. Jika tidak ada elemen yang dihapus, array kosong dikembalikan.

[...]

hapus tindakan seperti situasi dunia nyata, itu hanya menghapus item, tetapi panjang array tetap sama:

contoh dari terminal simpul:

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

Berikut adalah fungsi untuk menghapus item array dengan indeks, menggunakan slice () , dibutuhkan arr sebagai argumen pertama, dan indeks anggota yang ingin Anda hapus sebagai argumen kedua. Seperti yang Anda lihat, itu benar-benar menghapus anggota array, dan akan mengurangi panjang array sebesar 1

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

Apa fungsi yang dilakukan di atas adalah mengambil semua anggota ke indeks, dan semua anggota setelah indeks, dan menggabungkan mereka bersama-sama, dan mengembalikan hasilnya.

Berikut adalah contoh menggunakan fungsi di atas sebagai modul simpul, melihat terminal akan berguna:

> 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

harap dicatat bahwa ini tidak akan bekerja satu array dengan dupes di dalamnya, karena indexOf ("c") hanya akan mendapatkan kejadian pertama, dan hanya memisahkan dan menghapus "c" pertama yang ditemukannya.

Jika Anda ingin mengulangi array besar dan menghapus elemen secara selektif, akan mahal untuk memanggil splice () untuk setiap delete karena splice () harus mengindeks ulang elemen berikutnya setiap kali. Karena array asosiatif dalam Javascript, akan lebih efisien untuk menghapus elemen individu kemudian indeks ulang array setelahnya.

Anda dapat melakukannya dengan membangun array baru. misalnya

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

Tapi saya tidak berpikir Anda dapat memodifikasi nilai-nilai kunci dalam array asli, yang akan lebih efisien - sepertinya Anda harus membuat array baru.

Perhatikan bahwa Anda tidak perlu memeriksa entri "tidak ditentukan" karena tidak benar-benar ada dan untuk loop tidak mengembalikannya. Ini adalah artefak dari pencetakan array yang menampilkannya sebagai tidak terdefinisi. Tampaknya tidak ada dalam memori.

Akan lebih baik jika Anda bisa menggunakan sesuatu seperti slice () yang akan lebih cepat, tetapi tidak mengindeks ulang. Adakah yang tahu cara yang lebih baik?

Sebenarnya, Anda mungkin dapat melakukannya di tempat sebagai berikut yang mungkin lebih efisien, dari segi kinerja:

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)
},

Anda dapat menggunakan sesuatu seperti ini

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]

Kenapa tidak disaring saja? Saya pikir ini adalah cara yang paling jelas untuk mempertimbangkan array di js.

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

Perbedaannya dapat dilihat dengan mencatat panjang setiap larik setelah deleteoperator dan splice()metode diterapkan. Sebagai contoh:

hapus operator

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

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

The deleteOperator menghilangkan elemen dari array, tetapi "placeholder" elemen masih ada. oaktelah dihapus tetapi masih membutuhkan ruang dalam array. Karena itu, panjang array tetap 5.

metode splice ()

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

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

The splice()metode yang sama sekali menghilangkan nilai target dan yang "placeholder" juga. oaktelah dihapus serta ruang yang digunakan untuk menempati dalam array. Panjang array sekarang 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;
}

contoh:

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

pisang dihapus dan panjang array = 2

Mereka adalah hal-hal berbeda yang memiliki tujuan berbeda.

splicespesifik array dan, ketika digunakan untuk menghapus, menghapus entri dari array dan memindahkan semua entri sebelumnya ke atas untuk mengisi celah. (Ini juga dapat digunakan untuk memasukkan entri, atau keduanya pada saat yang bersamaan.) spliceAkan mengubah lengtharray (dengan asumsi itu bukan panggilan no-op:) theArray.splice(x, 0).

deletetidak spesifik-array; itu dirancang untuk digunakan pada objek: Ini menghapus properti (pasangan kunci / nilai) dari objek tempat Anda menggunakannya. Ini hanya berlaku untuk array karena array standar (misalnya, non-mengetik) dalam JavaScript tidak benar-benar sama sekali array *, mereka objek dengan penanganan khusus untuk properti tertentu, seperti yang namanya "indeks array" (yang merupakan didefinisikan sebagai nama string "... yang nilai numeriknya idalam kisaran +0 ≤ i < 2^32-1") dan length. Ketika Anda menggunakan deleteuntuk menghapus entri array, yang dilakukannya hanyalah menghapus entri; itu tidak memindahkan entri lain yang mengikutinya untuk mengisi celah, dan array menjadi "jarang" (ada beberapa entri yang hilang seluruhnya). Itu tidak berpengaruh length.

Beberapa jawaban saat ini untuk pertanyaan ini salah menyatakan bahwa menggunakan delete"set entri ke undefined". Itu tidak benar. Ini menghapus entri (properti) sepenuhnya, meninggalkan celah.

Mari kita gunakan beberapa kode untuk menggambarkan perbedaan:

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

* (itu posting di blog kecil saya yang anemia)

Saat ini ada dua cara untuk melakukan ini

1. menggunakan sambatan ()

   arrayObject.splice(index, 1);

2. menggunakan delete

   delete arrayObject[index];

Tapi saya selalu menyarankan untuk menggunakan sambatan untuk objek array dan menghapus atribut objek karena menghapus tidak memperbarui panjang array.

OK, bayangkan kita memiliki array ini di bawah ini:

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

Mari kita lakukan hapus dulu:

delete arr[1];

dan inilah hasilnya:

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

kosong! dan mari kita dapatkan:

arr[1]; //undefined

Jadi artinya hanya nilai yang dihapus dan tidak terdefinisi sekarang, jadi panjangnya sama, juga akan mengembalikan nilai sebenarnya ...

Mari atur ulang array kita dan lakukan ini dengan sambungan kali ini:

arr.splice(1, 1);

dan inilah hasilnya kali ini:

[1, 3, 4, 5];

Seperti yang Anda lihat panjang array berubah dan arr[1]adalah 3 sekarang ...

Juga ini akan mengembalikan item yang dihapus dalam Array yang [3]dalam hal ini ...

Yang lain sudah dibandingkan deletedengan splice.

Perbandingan menarik lainnya adalah deleteversus undefined: item array yang dihapus menggunakan lebih sedikit memori daripada yang baru saja diatur undefined;

Misalnya, kode ini tidak akan selesai:

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);

Ini menghasilkan kesalahan ini:

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

Jadi, seperti yang Anda lihat undefinedsebenarnya membutuhkan memori tumpukan.

Namun, jika Anda juga deleteitem-ary (alih-alih hanya mengaturnya undefined), kode perlahan-lahan akan selesai:

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}.`);

Ini adalah contoh ekstrem, tetapi mereka menunjukkan deletebahwa saya belum pernah melihat orang menyebutkan di mana pun.

Jika Anda memiliki array kecil, Anda dapat menggunakan filter:

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

Cara termudah mungkin

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'];

Semoga ini membantu. Referensi: https://lodash.com/docs#compact

Bagi yang ingin menggunakan Lodash dapat menggunakan: myArray = _.without(myArray, itemToRemove)

Atau seperti yang saya gunakan di Angular2

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

delete : delete akan menghapus properti objek, tetapi tidak akan mengindeks ulang array atau memperbarui panjangnya. Ini membuatnya tampak seolah-olah tidak terdefinisi:

splice : benar-benar menghapus elemen, mengindeks ulang array, dan mengubah panjangnya.

Hapus elemen dari yang terakhir

arrName.pop();

Hapus elemen dari dulu

arrName.shift();

Hapus dari tengah

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

Ex: arrName.splice(1,1);

Hapus satu elemen dari yang terakhir

arrName.splice(-1);

Hapus dengan menggunakan nomor indeks array

 delete arrName[1];

Jika elemen yang diinginkan untuk dihapus ada di tengah (katakanlah kami ingin menghapus 'c', yang indeksnya adalah 1), Anda dapat menggunakan:

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

IndexOfmenerima juga tipe referensi. Misalkan skenario berikut:

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

Berbeda:

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);

// hasil: myArray = ['b', 'c', 'd'];