Menghapus elemen array dalam JavaScript - hapus vs sambatan


1334

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?


3
Untuk .splicedalam loop, lihat pertanyaan ini: Hapus dari array di javascript .
Rob W

6
@andynormancx Ya, tapi jawaban ini diposting hanya sehari setelahnya, dan mendapat lebih banyak suara - saya akan mengatakan itu lebih baik ditulis, itu pasti.
Camilo Martin

@andynormancx - Tampaknya bukan duplikat yang tepat. Pertanyaan yang Anda tautkan pada dasarnya menanyakan mengapa menghapus elemen dari sebuah array (sehingga membuatnya jarang) tidak akan mengurangi panjangnya. Pertanyaan ini menanyakan perbedaan antara deletedan Array.prototype.splice.
chharvey

@chharvey setuju, yang lebih penting adalah bagaimana pertanyaan ini telah diposting 9 tahun yang lalu! Membuat saya merasa tua untuk kembali ke sini mengomentarinya
andynormancx

Jawaban:


1693

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

74
Sebenarnya, delete tidak menghapus elemen, tetapi tidak mengindeks ulang array atau memperbarui panjangnya (yang sudah tersirat oleh sebelumnya karena panjang selalu indeks tertinggi +1).
Felix Kling

3
JSlint tidak suka delete myArray[0]sintaks yang mengatakan " Diharapkan operator dan bukannya melihat 'hapus'. " spliceDisarankan menggunakan.
Eye

21
@ Eye: Sebenarnya, JSLint hanya mengeluh tentang kurangnya titik koma di baris sebelumnya. Dan Anda tidak dapat benar-benar merekomendasikan satu dari yang lain, karena mereka melakukan hal-hal yang sangat berbeda ...
Ry-

3
"Hapus dalam hal ini hanya akan menetapkan elemen sebagai tidak terdefinisi:" Tidak, itu tidak benar. Ada perbedaan mendasar antara delete myArray[0]dan myArray[0] = undefined. Dalam kasus sebelumnya, properti dihapus dari objek array sepenuhnya. Dalam kasus kedua, properti tetap, dengan nilainya undefined.
TJ Crowder

1
FYI, alat dev Chrome menampilkan kata kunci emptyalih-alih undefineduntuk meningkatkan perbedaan antara elemen array yang benar-benar dihapus (atau tidak diinisialisasi) versus elemen yang memiliki nilai sebenarnya undefined. Perhatikan bahwa saat saya mengatakan ini, maksud saya hanya menampilkan sebagai empty, dan tidak merujuk ke nilai nyata yang disebut empty(yang tidak ada).
chharvey

340

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


4
+1 Untuk Array.remove (). Namun itu tidak senang dilewatkan argumen string (tidak seperti kebanyakan metode Array, misalnya [1,2,3].slice('1'); // =[2,3]), jadi lebih aman untuk mengubahnya kevar rest = this.slice(parseInt(to || from) + 1 || this.length);
Richard Inglis

1
@tomwrong, tidak ada utas dalam javascript, dan fungsi dijalankan this.push.apply(this, rest), lalu mengembalikan nilai yang dikembalikan
billy

59
Ini sama sekali tidak menjawab pertanyaan.
Ry-

16
Mengapa tidak menggunakan splice () saja? Nama fungsi ini, nama parameter dan hasilnya tidak jelas. Rekomendasi saya adalah hanya menggunakan sambatan (indeks, panjang) - (lihat jawaban Andy Hume)
auco

3
Fungsi yang disediakan di atas berfungsi seperti yang dijelaskan, namun itu menciptakan efek samping yang tidak diinginkan ketika beralih melalui array dengan for(var i in array)siklus. Saya telah menghapusnya dan menggunakan sambungan.
alexykot

104

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

11
contoh yang bagus kecuali ambiguitas pada contoh kedua dengan menggunakan 1,1 - yang pertama merujuk pada indeks dalam array untuk memulai sambungan, yang kedua adalah jumlah elemen yang harus dihapus. Jadi untuk menghapus 'c' dari array asli, gunakanmyArray.splice(2,1)
iancoleman

68

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



10

splice akan bekerja dengan indeks numerik.

sedangkan deletedapat digunakan terhadap jenis indeks lainnya ..

contoh:

delete myArray['text1'];

9
Ketika Anda mengatakan 'jenis indeks lain', Anda tidak lagi berbicara tentang array, melainkan objek, yang merupakan pertanyaan OP.
Yi Jiang

2
@YiJiang: Array adalah Objek. Mengindikasikan adalah properti. Tidak ada perbedaan.
Bergi

9

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.

delete tidak menyusun ulang kunci array, jadi: var arr = [1,2,3,4,5]; hapus arr [3]; untuk (var i = 0; i <= arr.length; i ++) console.log (arr [i]); akan menunjukkan hasil yang tidak terduga.
Kristian Williams

Ini benar. Jadi, kecuali Anda ingin meninggalkan item yang tidak ditentukan di lokasi itu, JANGAN gunakan hapus pada kunci array! Saya awalnya menambahkan komentar ini untuk menyertakan referensi tentang penggunaan delete yang benar.
jtrick

tetapi mengapa menghapus akan membuang hasil yang tidak terduga ??
Alex

9

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


8

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.

[...]


@ downvoter: mengapa downvote? mau menjelaskan, atau tidak?
serv-inc

7

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.


6

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

Saya percaya indeks ++; perlu terjadi di luar 'jika'. Melakukan edit
mishal153

6

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]


ini lebih intuitif daripada slicejika Anda berasal dari latar belakang fungsional (meskipun mungkin kurang efisien).
jethro

3

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

Bagaimana dengan array dengan ratusan (jika tidak ribuan) catatan di mana hanya 3 dari mereka yang perlu dihapus?
Joel Hernandez

Poin yang bagus. saya menggunakan metode ini untuk array jarang yang panjangnya tidak lebih dari 200 atau 300 dan berkinerja sangat baik. Namun, saya pikir perpustakaan seperti garis bawah harus lebih disukai jika Anda harus mengelola array yang lebih besar.
Asqan

1
Namun, tampaknya jauh lebih baik daripada deleteatau slicebagi saya.
Juneyoung Oh

3

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.


2
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


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)


2

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.


1

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


1

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.


1

Jika Anda memiliki array kecil, Anda dapat menggunakan filter:

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

0

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


1
Haruskah seseorang tersandung pada ini bertanya-tanya tentang compact... tidak perlu untuk penginapan. CobamyArray.filter(function(n){return n;})
dat

0

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

0

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

0

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

0

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

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


@ ChrisDennis mengapa? (tidak ada sarkasme atau niat jahat, ini adalah pertanyaan yang tulus)
Chris Bier 18'15

Selain fakta bahwa jawaban ini tidak menjawab pertanyaan OP
Chris Bier
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.