Bagaimana cara menghapus elemen tertentu dari array di JavaScript?

Saya tidak tahu bagaimana Anda mengharapkan array.remove(int) berperilaku. Ada tiga kemungkinan yang dapat saya pikirkan yang mungkin Anda inginkan.

Untuk menghapus elemen array pada indeks i:

array.splice(i, 1);

Jika Anda ingin menghapus setiap elemen dengan nilai number dari array:

for(var i = array.length - 1; i >= 0; i--) {
    if(array[i] === number) {
       array.splice(i, 1);
    }
}

Jika Anda hanya ingin membuat elemen di indeks i tidak ada lagi, tetapi Anda tidak ingin indeks elemen lainnya berubah:

delete array[i];

Diedit pada 2016 oktober

• Lakukan dengan sederhana, intuitif, dan eksplisit ( https://en.wikipedia.org/wiki/Occam%27s_razor )
• Lakukan itu tidak berubah (array asli tetap tidak berubah)
• Lakukan dengan fungsi JS standar, jika browser Anda tidak mendukungnya - gunakan polyfill

Dalam contoh kode ini saya menggunakan fungsi "array.filter (...)" untuk menghapus item yang tidak diinginkan dari array, fungsi ini tidak mengubah array asli dan membuat yang baru. Jika browser Anda tidak mendukung fungsi ini (mis. IE sebelum versi 9, atau Firefox sebelum versi 1.5), pertimbangkan untuk menggunakan filter polyfill dari Mozilla .

Menghapus item (ECMA-262 Edition 5 kode alias oldstyle JS)

var value = 3

var arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(function(item) { 
    return item !== value
})

console.log(arr)
// [ 1, 2, 4, 5 ]

Menghapus item (kode ES2015)

let value = 3

let arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(item => item !== value)

console.log(arr)
// [ 1, 2, 4, 5 ]

IMPORTANT ES2015 "() => {}" sintaks fungsi panah tidak didukung di IE sama sekali, Chrome sebelum 45 versi, Firefox sebelum 22 versi, Safari sebelum 10 versi. Untuk menggunakan sintaks ES2015 di browser lama, Anda dapat menggunakan BabelJS

Menghapus banyak item (kode ES2016)

Keuntungan tambahan dari metode ini adalah Anda dapat menghapus banyak item

let forDeletion = [2, 3, 5]

let arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(item => !forDeletion.includes(item))
// !!! Read below about array.includes(...) support !!!

console.log(arr)
// [ 1, 4 ]

IMPORTANT "array.includes (...)" fungsi sama sekali tidak didukung di IE, Chrome sebelum versi 47, Firefox sebelum versi 43, Safari versi sebelum 9 dan versi Edge sebelum 14 jadi di sini adalah polyfill dari Mozilla

Menghapus banyak item (JavaScript ES2018 Eksperimental canggih?)

// array-lib.js

export function remove(...forDeletion) {
    return this.filter(item => !forDeletion.includes(item))
}

// main.js

import { remove } from './array-lib.js'

let arr = [1, 2, 3, 4, 5, 3]

// :: This-Binding Syntax Proposal
// using "remove" function as "virtual method"
// without extending Array.prototype
arr = arr::remove(2, 3, 5)

console.log(arr)
// [ 1, 4 ]

Coba sendiri di BabelJS :)

Referensi

• Array.prototype.includes
• Proposal Sintaks Mengikat Ini
• Komposisi fungsional

Tergantung pada apakah Anda ingin menyimpan tempat kosong atau tidak.

Jika Anda ingin slot kosong, hapus tidak apa-apa:

delete array[ index ];

Jika tidak, Anda harus menggunakan metode splice :

array.splice( index, 1 );

Dan jika Anda membutuhkan nilai item itu, Anda bisa menyimpan elemen array yang dikembalikan:

var value = array.splice( index, 1 )[0];

Jika Anda ingin melakukannya dalam urutan tertentu, Anda dapat menggunakan array.pop() untuk yang terakhir atau array.shift() untuk yang pertama (dan keduanya mengembalikan nilai item juga).

Dan jika Anda tidak tahu indeks item, Anda bisa menggunakan array.indexOf( item ) untuk mendapatkannya (dalam if() untuk mendapatkan satu item atau dalam while() untuk mendapatkan semuanya). array.indexOf( item ) mengembalikan indeks atau -1 jika tidak ditemukan.

Seorang teman mengalami masalah di Internet Explorer 8 , dan menunjukkan kepada saya apa yang dia lakukan. Saya mengatakan kepadanya bahwa itu salah, dan dia memberi tahu saya bahwa dia mendapatkan jawabannya di sini. Jawaban teratas saat ini tidak akan berfungsi di semua browser (misalnya Internet Explorer 8), dan itu hanya akan menghilangkan kemunculan item pertama.

Hapus SEMUA instance dari array

function remove(arr, item) {
    for (var i = arr.length; i--;) {
        if (arr[i] === item) {
            arr.splice(i, 1);
        }
    }
}

Itu loop melalui array mundur (karena indeks dan panjang akan berubah saat item dihapus) dan menghapus item jika ditemukan. Ini bekerja di semua browser.

Ada dua pendekatan utama:

1. sambatan (): anArray.splice(index, 1);

2. hapus: delete anArray[index];

Hati-hati saat Anda menggunakan delete untuk sebuah array. Ini bagus untuk menghapus atribut objek tetapi tidak begitu bagus untuk array. Lebih baik menggunakan splice untuk array.

Ingatlah bahwa ketika Anda menggunakan delete untuk sebuah array, Anda bisa mendapatkan hasil yang salah untuk anArray.length. Dengan kata lain, delete akan menghapus elemen tetapi tidak akan memperbarui nilai properti length.

Anda juga bisa berharap memiliki lubang pada angka indeks setelah menggunakan delete, mis. Anda bisa berakhir dengan memiliki indeks 1,3,4,8,9,11 dan panjang seperti sebelum menggunakan delete. Dalam hal itu, semua loop for yang diindeks akan macet, karena indeks tidak lagi berurutan.

Jika Anda terpaksa menggunakan delete karena suatu alasan, maka Anda harus menggunakan for each loop ketika Anda perlu mengulang-ulang array. Faktanya, selalu hindari menggunakan indeks untuk loop, jika memungkinkan. Dengan begitu kode akan lebih kuat dan kurang rentan terhadap masalah dengan indeks.

Array.prototype.remByVal = function(val) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] === val) {
            this.splice(i, 1);
            i--;
        }
    }
    return this;
}
//Call like
[1, 2, 3, 4].remByVal(3);

Array.prototype.remByVal = function(val) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] === val) {
            this.splice(i, 1);
            i--;
        }
    }
    return this;
}

var rooms = ['hello', 'something']

rooms = rooms.remByVal('hello')

console.log(rooms)

Tidak perlu menggunakan indexOf atau splice. Namun, berkinerja lebih baik jika Anda hanya ingin menghapus satu kemunculan elemen. 

Temukan dan pindahkan (pindah):

function move(arr, val) {
  var j = 0;
  for (var i = 0, l = arr.length; i < l; i++) {
    if (arr[i] !== val) {
      arr[j++] = arr[i];
    }
  }
  arr.length = j;
}

Gunakan indexOf dan splice (indexof):

function indexof(arr, val) {
  var i;
  while ((i = arr.indexOf(val)) != -1) {
    arr.splice(i, 1);
  }
}

Gunakan hanya splice (sambatan):

function splice(arr, val) {
  for (var i = arr.length; i--;) {
    if (arr[i] === val) {
      arr.splice(i, 1);
    }
  }
}

Run-times pada nodejs untuk array dengan 1000 elemen (rata-rata lebih dari 10000 run):

indexof sekitar 10x lebih lambat dari move. Bahkan jika ditingkatkan dengan menghapus panggilan ke indexOf di splice kinerjanya jauh lebih buruk daripada move. 

Remove all occurrences:
    move 0.0048 ms
    indexof 0.0463 ms
    splice 0.0359 ms

Remove first occurrence:
    move_one 0.0041 ms
    indexof_one 0.0021 ms

Terlalu tua untuk menjawab, tetapi semoga membantu seseorang, dengan memberikan predikat alih-alih nilai.

CATATAN: itu akan memperbarui array yang diberikan, dan mengembalikan baris yang terpengaruh

Pemakaian

var removed = helper.removeOne(arr, row => row.id === 5 );

var removed = helper.remove(arr, row => row.name.startsWith('BMW'));

Definisi

var helper = {

    // Remove and return the first occurrence     

    removeOne: function(array, predicate) {
        for (var i = 0; i < array.length; i++) {
            if (predicate(array[i])) {
                return array.splice(i, 1);
            }
        }
    },

    // Remove and return all occurrences  

    remove: function(array, predicate) {
        var removed = [];

        for (var i = 0; i < array.length;) {

            if (predicate(array[i])) {
                removed.Push(array.splice(i, 1));
                continue;
            }

            i++;                
        }

        return removed;
    }
};

John Resig memposting implementasi yang bagus :

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

Jika Anda tidak ingin memperluas objek global, Anda dapat melakukan sesuatu seperti berikut ini, sebagai gantinya:

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

Tetapi alasan utama saya memposting ini adalah untuk memperingatkan pengguna terhadap implementasi alternatif yang disarankan dalam komentar di halaman itu (14 Des 2007):

Array.prototype.remove = function(from, to){
  this.splice(from, (to=[0,from||1,++to-from][arguments.length])<0?this.length+to:to);
  return this.length;
};

Tampaknya bekerja dengan baik pada awalnya, tetapi melalui proses yang menyakitkan saya menemukan itu gagal ketika mencoba untuk menghapus elemen kedua hingga terakhir dalam sebuah array. Misalnya, jika Anda memiliki array 10-elemen dan Anda mencoba menghapus elemen ke-9 dengan ini:

myArray.remove(8);

Anda berakhir dengan array 8-elemen. Tidak tahu mengapa, tetapi saya mengkonfirmasi implementasi asli John tidak memiliki masalah ini.

Underscore.js dapat digunakan untuk menyelesaikan masalah dengan beberapa browser. Ini menggunakan metode browser built-in jika ada. Jika mereka tidak ada seperti dalam kasus versi Internet Explorer yang lebih lama itu menggunakan metode kustom sendiri.

Contoh sederhana untuk menghapus elemen dari array (dari situs web):

_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]

Anda dapat melakukannya dengan mudah dengan filter metode:

function remove(arrOriginal, elementToRemove){
    return arrOriginal.filter(function(el){return el !== elementToRemove});
}
console.log( remove([1, 2, 1, 0, 3, 1, 4], 1) );

Ini menghapus semua elemen dari array dan juga bekerja lebih cepat dari kombinasi slice dan indexOf

Jika Anda ingin array baru dengan posisi yang dihapus dihapus, Anda selalu dapat menghapus elemen tertentu dan menyaring array. Mungkin perlu ekstensi objek array untuk browser yang tidak menerapkan metode filter tetapi dalam jangka panjang lebih mudah karena semua yang Anda lakukan adalah 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';}));

Harus menampilkan [1, 2, 3, 4, 6]

Anda dapat menggunakan ES6. 

var array=['1','2','3','4','5','6']
var index = array.filter((value)=>value!='3');

Keluaran: 

["1", "2", "4", "5", "6"]

Lihatlah kode ini. Ia bekerja di setiap browser utama .

remove_item = function (arr, value) {
    var b = '';
    for (b in arr) {
        if (arr[b] === value) {
            arr.splice(b, 1);
            break;
        }
    }
    return arr;
}

Panggil fungsi ini 

remove_item(array,value);

Anda dapat menggunakan lodash _.pull (array bermutasi), _.pullAt (array bermutasi) atau _.without (array tidak bermutasi), 

var array1 = ['a', 'b', 'c', 'd']
_.pull(array1, 'c')
console.log(array1) // ['a', 'b', 'd']

var array2 = ['e', 'f', 'g', 'h']
_.pullAt(array2, 0)
console.log(array2) // ['f', 'g', 'h']

var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without(array3, 'i') // ['j', 'k', 'l']
console.log(array3) // ['i', 'j', 'k', 'l']

OK, misalnya Anda memiliki array di bawah ini:

var num = [1, 2, 3, 4, 5];

Dan kami ingin menghapus nomor 4, Anda cukup melakukan kode di bawah ini:

num.splice(num.indexOf(4), 1); //num will be [1, 2, 3, 5];

Jika Anda menggunakan kembali fungsi ini, Anda menulis fungsi yang dapat digunakan kembali yang akan dilampirkan ke fungsi array asli seperti di bawah ini:

Array.prototype.remove = Array.prototype.remove || function(x) {
  const i = this.indexOf(x);
  if(i===-1) return;
  this.splice(i, 1); //num.remove(5) === [1, 2, 3];
}

Tetapi bagaimana jika Anda memiliki array di bawah ini dengan beberapa [5] dalam Array?

var num = [5, 6, 5, 4, 5, 1, 5];

Kami membutuhkan loop untuk memeriksa semuanya, tetapi cara yang lebih mudah dan efisien menggunakan fungsi JavaScript bawaan, jadi kami menulis fungsi yang menggunakan filter seperti di bawah ini sebagai gantinya:

const _removeValue = (arr, x) => arr.filter(n => n!==x);
//_removeValue([1, 2, 3, 4, 5, 5, 6, 5], 5) //return [1, 2, 3, 4, 6]

Juga ada perpustakaan pihak ketiga yang membantu Anda melakukan ini, seperti Lodash atau Underscore, untuk info lebih lanjut lihat di lodash _.pull, _.pullAt atau _.without.

Saya cukup baru dalam JavaScript dan membutuhkan fungsi ini. Saya hanya menulis ini:

function removeFromArray(array, item, index) {
  while((index = array.indexOf(item)) > -1) {
    array.splice(index, 1);
  }
}

Lalu ketika saya ingin menggunakannya:

//Set-up some dummy data
var dummyObj = {name:"meow"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];

//Remove the dummy data
removeFromArray(dummyArray, dummyObj);
removeFromArray(dummyArray, "item2");

Output - Seperti yang diharapkan . ["Item1", "item1"]

Anda mungkin memiliki kebutuhan yang berbeda dari saya, sehingga Anda dapat dengan mudah memodifikasinya sesuai dengan mereka. Saya harap ini membantu seseorang.

ES6 & tanpa mutasi: (Oktober 2016)

const removeByIndex = (list, index) =>
  [
    ...list.slice(0, index),
    ...list.slice(index + 1)
  ];

Kemudian : 

removeByIndex([33,22,11,44],1) //=> [33,11,44]

Perbarui: Metode ini disarankan hanya jika Anda tidak dapat menggunakan ECMAScript 2015 (sebelumnya dikenal sebagai ES6). Jika Anda dapat menggunakannya, jawaban lain di sini menyediakan implementasi yang lebih rapi.

Intisari di sini akan menyelesaikan masalah Anda, dan juga menghapus semua kemunculan argumen, bukan hanya 1 (atau nilai yang ditentukan).

Array.prototype.destroy = function(obj){
    // Return null if no objects were found and removed
    var destroyed = null;

    for(var i = 0; i < this.length; i++){

        // Use while-loop to find adjacent equal objects
        while(this[i] === obj){

            // Remove this[i] and store it within destroyed
            destroyed = this.splice(i, 1)[0];
        }
    }

    return destroyed;
}

Pemakaian:

var x = [1, 2, 3, 3, true, false, undefined, false];

x.destroy(3);         // => 3
x.destroy(false);     // => false
x;                    // => [1, 2, true, undefined]

x.destroy(true);      // => true
x.destroy(undefined); // => undefined
x;                    // => [1, 2]

x.destroy(3);         // => null
x;                    // => [1, 2]

Jika Anda memiliki objek kompleks dalam array, Anda dapat menggunakan filter? Dalam situasi di mana $ .inArray atau array.splice tidak mudah digunakan. Terutama jika objek mungkin dangkal dalam array.

Misalnya. jika Anda memiliki objek dengan bidang Id dan Anda ingin objek dihapus dari array:

this.array = this.array.filter(function(element, i) {
    return element.id !== idToRemove;
});

Berikut adalah beberapa cara untuk menghapus item dari array menggunakan JavaScript.

Semua metode yang dijelaskan jangan bermutasi array asli, dan sebagai gantinya buat yang baru.

Jika Anda tahu indeks suatu barang

Misalkan Anda memiliki array, dan Anda ingin menghapus item di posisi i.

Salah satu metode adalah menggunakan slice():

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const i = 3
const filteredItems = items.slice(0, i-1).concat(items.slice(i, items.length))

console.log(filteredItems)

slice() membuat array baru dengan indeks yang diterimanya. Kami cukup membuat array baru, dari awal hingga indeks yang ingin kami hapus, dan menggabungkan array lain dari posisi pertama mengikuti yang kami hapus ke akhir array.

Jika Anda tahu nilainya

Dalam kasus ini, satu opsi yang baik adalah menggunakan filter(), yang menawarkan lebih banyak deklaratif pendekatan:

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter(item => item !== valueToRemove)

console.log(filteredItems)

Ini menggunakan fungsi panah ES6. Anda dapat menggunakan fungsi tradisional untuk mendukung browser lama:

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter(function(item) {
  return item !== valueToRemove
})

console.log(filteredItems)

atau Anda dapat menggunakan Babel dan mengubah kode ES6 kembali ke ES5 untuk membuatnya lebih mudah dicerna oleh browser lama, namun tulislah JavaScript modern dalam kode Anda.

Menghapus banyak item

Bagaimana jika alih-alih satu item, Anda ingin menghapus banyak item?

Mari temukan solusi paling sederhana.

Menurut indeks

Anda cukup membuat fungsi dan menghapus item secara seri:

const items = ['a', 'b', 'c', 'd', 'e', 'f']

const removeItem = (items, i) =>
  items.slice(0, i-1).concat(items.slice(i, items.length))

let filteredItems = removeItem(items, 3)
filteredItems = removeItem(filteredItems, 5)
//["a", "b", "c", "d"]

console.log(filteredItems)

Berdasarkan nilai

Anda dapat mencari penyertaan di dalam fungsi panggilan balik:

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valuesToRemove = ['c', 'd']
const filteredItems = items.filter(item => !valuesToRemove.includes(item))
// ["a", "b", "e", "f"]

console.log(filteredItems)

Hindari mutasi array asli

splice() (jangan bingung dengan slice()) bermutasi array asli, dan harus dihindari.

(awalnya diposting di https://flaviocopes.com/how-to-remove-item-from-array/ )

Anda seharusnya tidak pernah mengubah array array Anda. Karena ini bertentangan dengan pola pemrograman fungsional. Apa yang dapat Anda lakukan adalah membuat array baru tanpa referensi array yang ingin Anda ubah data menggunakan metode es6 filter;

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

Misalkan Anda ingin menghapus 5 dari array, Anda cukup melakukannya seperti ini.

myArray = myArray.filter(value => value !== 5);

Ini akan memberi Anda array baru tanpa nilai yang ingin Anda hapus. Jadi hasilnya akan seperti itu

 [1,2,3,4,6]; // 5 has been removed from this array

Untuk pemahaman lebih lanjut, Anda dapat membaca dokumentasi MDN di Array.filter https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

Pendekatan yang lebih modern, ECMAScript 2015 (sebelumnya dikenal sebagai Harmony atau ES 6). Diberikan:

const items = [1, 2, 3, 4];
const index = 2;

Kemudian:

items.filter((x, i) => i !== index);

Menghasilkan: 

[1, 2, 4]

Anda dapat menggunakan Babel dan layanan polyfill untuk memastikan ini didukung dengan baik di seluruh browser.

Saya tahu sudah ada banyak jawaban, tetapi banyak dari mereka tampaknya terlalu memperumit masalah. Berikut ini adalah cara sederhana, rekursif untuk menghapus semua instance kunci - panggilan sendiri hingga indeks tidak ditemukan. Ya, itu hanya berfungsi di browser dengan indexOf, tetapi sederhana dan dapat dengan mudah diisi.

Fungsi yang berdiri sendiri

function removeAll(array, key){
    var index = array.indexOf(key);

    if(index === -1) return;

    array.splice(index, 1);
    removeAll(array,key);
}

Metode prototipe

Array.prototype.removeAll = function(key){
    var index = this.indexOf(key);

    if(index === -1) return;

    this.splice(index, 1);
    this.removeAll(key);
}

Saya punya solusi bagus untuk menghapus dari array:

var words = ['spray', 'limit', 'Elite', 'exuberant', 'destruction', 'present'];

const result = words.filter(Word => Word.length > 6);

console.log(result);
// expected output: Array ["exuberant", "destruction", "present"]

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

Anda dapat melakukan loop mundur untuk memastikan tidak mengacaukan indeks, jika ada beberapa contoh elemen.

var myElement = "chocolate";
var myArray = ['chocolate', 'poptart', 'poptart', 'poptart', 'chocolate', 'poptart', 'poptart', 'chocolate'];

/* Important code */
for (var i = myArray.length - 1; i >= 0; i--) {
    if (myArray[i] == myElement) myArray.splice(i, 1);
}

Demo Langsung

Berdasarkan semua jawaban yang sebagian besar benar dan dengan mempertimbangkan praktik terbaik yang disarankan (terutama tidak menggunakan Array.prototype secara langsung), saya datang dengan kode di bawah ini:

function arrayWithout(arr, values) {
  var isArray = function(canBeArray) {
    if (Array.isArray) {
      return Array.isArray(canBeArray);
    }
    return Object.prototype.toString.call(canBeArray) === '[object Array]';
  };

  var excludedValues = (isArray(values)) ? values : [].slice.call(arguments, 1);
  var arrCopy = arr.slice(0);

  for (var i = arrCopy.length - 1; i >= 0; i--) {
    if (excludedValues.indexOf(arrCopy[i]) > -1) {
      arrCopy.splice(i, 1);
    }
  }

  return arrCopy;
}

Meninjau fungsi di atas, meskipun faktanya berfungsi dengan baik, saya menyadari mungkin ada beberapa peningkatan kinerja. Juga menggunakan ES6 daripada ES5 adalah pendekatan yang jauh lebih baik. Untuk itu, ini adalah kode yang ditingkatkan:

const arrayWithoutFastest = (() => {
  const isArray = canBeArray => ('isArray' in Array) 
    ? Array.isArray(canBeArray) 
    : Object.prototype.toString.call(canBeArray) === '[object Array]';

  let mapIncludes = (map, key) => map.has(key);
  let objectIncludes = (obj, key) => key in obj;
  let includes;

  function arrayWithoutFastest(arr, ...thisArgs) {
    let withoutValues = isArray(thisArgs[0]) ? thisArgs[0] : thisArgs;

    if (typeof Map !== 'undefined') {
      withoutValues = withoutValues.reduce((map, value) => map.set(value, value), new Map());
      includes = mapIncludes;
    } else {
      withoutValues = withoutValues.reduce((map, value) => { map[value] = value; return map; } , {}); 
      includes = objectIncludes;
    }

    const arrCopy = [];
    const length = arr.length;

    for (let i = 0; i < length; i++) {
      // If value is not in exclude list
      if (!includes(withoutValues, arr[i])) {
        arrCopy.Push(arr[i]);
      }
    }

    return arrCopy;
  }

  return arrayWithoutFastest;  
})();

Bagaimana cara menggunakan:

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

arrayWithoutFastest(arr, 1); // will return array [2,3,4,5,"name", false]
arrayWithoutFastest(arr, 'name'); // will return [2,3,4,5, false]
arrayWithoutFastest(arr, false); // will return [2,3,4,5]
arrayWithoutFastest(arr,[1,2]); // will return [3,4,5,"name", false];
arrayWithoutFastest(arr, {bar: "foo"}); // will return the same array (new copy)

Saat ini saya sedang menulis posting blog di mana saya telah membandingkan beberapa solusi untuk Array tanpa masalah dan membandingkan waktu yang diperlukan untuk menjalankannya. Saya akan memperbarui jawaban ini dengan tautan setelah saya menyelesaikan posting itu. Sekadar untuk memberi tahu, saya telah membandingkan hal di atas dengan lodash tanpa dan jika peramban mendukung Map, itu mengalahkan lodash! Perhatikan bahwa saya tidak menggunakan Array.prototype.indexOf atau Array.prototype.includes sebagai pembungkus exlcudeValues ​​dalam Map atau Object membuat pencarian menjadi lebih cepat!

Anda memiliki 1 hingga 9 array dan Anda ingin menghapus 5 gunakan kode di bawah ini.

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

var newNumberArray = numberArray.filter(m => {
  return m !== 5;
});

console.log("new Array, 5 removed", newNumberArray);

Jika Anda ingin beberapa nilai mis: - 1,7,8

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

var newNumberArray = numberArray.filter(m => {
  return (m !== 1) && (m !== 7) && (m !== 8);
});

console.log("new Array, 5 removed", newNumberArray);

Jika Anda ingin menghapus nilai array di array ex: - [3,4,5]

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];

var newNumberArray = numberArray.filter(m => {
    return !removebleArray.includes(m);
});

console.log("new Array, [3,4,5] removed", newNumberArray);

termasuk browser yang didukung adalah tautan

  Array.prototype.removeItem = function(a) {
            for (i = 0; i < this.length; i++) {
                if (this[i] == a) {
                    for (i2 = i; i2 < this.length - 1; i2++) {
                        this[i2] = this[i2 + 1];
                    }
                    this.length = this.length - 1
                    return;
                }
            }
        }

    var recentMovies = ['Iron Man', 'Batman', 'Superman', 'Spiderman'];
    recentMovies.removeItem('Superman');

Hapus berdasarkan Indeks

Fungsi yang mengembalikan salinan array tanpa elemen pada indeks.

/**
* removeByIndex
* @param {Array} array
* @param {Number} index
*/
function removeByIndex(array, index){
    return array.filter(function(elem, _index){
        return index != _index;
    });
}
l = [1,3,4,5,6,7];
console.log(removeByIndex(l, 1));

$> [ 1, 4, 5, 6, 7 ]

Hapus berdasarkan Nilai

Fungsi yang mengembalikan salinan array tanpa Nilai.

/**
* removeByValue
* @param {Array} array
* @param {Number} value
*/
function removeByValue(array, value){
    return array.filter(function(elem, _index){
        return value != elem;
    });
}
l = [1,3,4,5,6,7];
console.log(removeByValue(l, 5));

$> [ 1, 3, 4, 6, 7]

Saya ingin menjawab berdasarkanES6. Asumsikan, Anda memiliki array seperti di bawah ini:

let arr = [1,2,3,4];

Jika Anda ingin menghapus indeks khusus seperti 2, tulis kode di bawah ini:

arr.splice(2, 1); //=> arr became [1,2,4]

Tetapi jika Anda ingin menghapus item khusus seperti 3 dan Anda tidak tahu indeksnya seperti di bawah ini:

arr = arr.filter(e => e !== 3); //=> arr became [1,2,4]

Petunjuk : silakan gunakan fungsi panah untuk menyaring panggilan balik kecuali Anda akan mendapatkan array kosong.

Buat array baru:

var my_array = new Array();

Tambahkan elemen ke array ini:

my_array.Push("element1");

Function indexOf (Pengembalian indeks atau -1 bila tidak ditemukan):

var indexOf = function(needle) 
{
    if(typeof Array.prototype.indexOf === 'function') // newer browsers
    {
        indexOf = Array.prototype.indexOf;
    } 
    else // older browsers
    {
        indexOf = function(needle) 
        {
            var index = -1;

            for(var i = 0; i < this.length; i++) 
            {
                if(this[i] === needle) 
                {
                    index = i;
                    break;
                }
            }
            return index;
        };
    }

    return indexOf.call(this, needle);
};

Periksa indeks elemen ini (diuji dengan firefox dan IE8 +):

var index = indexOf.call(my_array, "element1");

Hapus 1 elemen yang terletak di indeks dari array

my_array.splice(index, 1);

Saya juga berlari dalam situasi di mana saya harus menghapus elemen dari Array. .indexOf tidak berfungsi di IE* jadi bagikan solusi jQuery.inArray() kerja saya.

var index = jQuery.inArray(val,arr);
if (index > -1) {
    arr.splice(index, 1);
    //console.log(arr);
}

2017-05-08

Sebagian besar jawaban yang diberikan bekerja untuk perbandingan yang ketat, artinya kedua objek mereferensikan objek yang sama persis di memori (atau tipe primitif), tetapi sering kali Anda ingin menghapus objek non-primitif dari array yang memiliki nilai tertentu. Misalnya, jika Anda melakukan panggilan ke server dan ingin memeriksa objek yang diambil terhadap objek lokal.

const a = {'field': 2} // Non-primitive object
const b = {'field': 2} // Non-primitive object with same value
const c = a            // Non-primitive object that reference the same object as "a"

assert(a !== b) // Don't reference the same item, but have same value
assert(a === c) // Do reference the same item, and have same value (naturally)

//Note: there are many alternative implementations for valuesAreEqual
function valuesAreEqual (x, y) {
   return  JSON.stringify(x) === JSON.stringify(y)
}


//filter will delete false values
//Thus, we want to return "false" if the item
// we want to delete is equal to the item in the array
function removeFromArray(arr, toDelete){
    return arr.filter(target => {return !valuesAreEqual(toDelete, target)})
}

const exampleArray = [a, b, b, c, a, {'field': 2}, {'field': 90}];
const resultArray = removeFromArray(exampleArray, a);

//resultArray = [{'field':90}]

Ada implementasi alternatif/lebih cepat untuk valuesAreEqual, tetapi ini berhasil. Anda juga dapat menggunakan komparator khusus jika Anda memiliki bidang khusus untuk memeriksa (misalnya, beberapa UUID yang diambil vs UUID lokal).

Perhatikan juga bahwa ini adalah operasi fungsional, yang berarti ia tidak mengubah array asli.

Saya pikir banyak instruksi JavaScript tidak dipikirkan dengan baik untuk pemrograman fungsional. Splice mengembalikan elemen yang dihapus di mana sebagian besar waktu Anda membutuhkan array yang dikurangi. Ini buruk.

Bayangkan Anda melakukan panggilan rekursif dan harus melewati array dengan satu item lebih sedikit, mungkin tanpa item yang diindeks saat ini. Atau bayangkan Anda sedang melakukan panggilan rekursif lain dan harus melewati array dengan elemen yang didorong.

Dalam kedua kasus ini Anda tidak dapat melakukan myRecursiveFunction(myArr.Push(c)) atau myRecursiveFunction(myArr.splice(i,1)). Idiot pertama sebenarnya akan melewati panjang array dan idiot kedua akan melewati elemen yang dihapus sebagai parameter.

Jadi apa yang saya lakukan sebenarnya ... Untuk menghapus elemen array dan melewatkan hasil ke fungsi sebagai parameter pada saat yang sama saya lakukan sebagai berikut

myRecursiveFunction(myArr.slice(0,i).concat(a.slice(i+1)))

Ketika berbicara tentang Push, itu lebih konyol ... Saya suka,

myRecursiveFunction((myArr.Push(c),myArr))

Saya percaya pada bahasa fungsional yang tepat suatu metode bermutasi objek yang dipanggil harus mengembalikan referensi ke objek sebagai hasilnya.

Dalam CoffeeScript :

my_array.splice(idx, 1) for ele, idx in my_array when ele is this_value

Gunakan jQuery's InArray:

A = [1, 2, 3, 4, 5, 6];
A.splice($.inArray(3, A), 1);
//It will return A=[1, 2, 4, 5, 6]`   

Catatan: inArray akan mengembalikan -1, jika elemen tidak ditemukan.

JavaScript Vanilla (ES5.1) - di tempat edisi

Dukungan browser: Internet Explorer 9 atau lebih baru ( dukungan browser terperinci )

/**
 * Removes all occurences of the item from the array.
 *
 * Modifies the array “in place”, i.e. the array passed as an argument
 * is modified as opposed to creating a new array. Also returns the modified
 * array for your convenience.
 */
function removeInPlace(array, item) {
    var foundIndex, fromIndex;

    // Look for the item (the item can have multiple indices)
    fromIndex = array.length - 1;
    foundIndex = array.lastIndexOf(item, fromIndex);

    while (foundIndex !== -1) {
        // Remove the item (in place)
        array.splice(foundIndex, 1);

        // Bookkeeping
        fromIndex = foundIndex - 1;
        foundIndex = array.lastIndexOf(item, fromIndex);
    }

    // Return the modified array
    return array;
}

JavaScript Vanilla (ES5.1) - tidak berubah edisi

Dukungan browser: Sama seperti Vanilla JavaScript di edisi tempat

/**
 * Removes all occurences of the item from the array.
 *
 * Returns a new array with all the items of the original array except
 * the specified item.
 */
function remove(array, item) {
    var arrayCopy;

    arrayCopy = array.slice();

    return removeInPlace(arrayCopy, item);
}

Vanilla ES6 - tidak berubah edisi

Dukungan browser: Chrome 46, Edge 12, Firefox 16, Opera 37, Safari 8 ( dukungan browser terperinci )

/**
 * Removes all occurences of the item from the array.
 *
 * Returns a new array with all the items of the original array except
 * the specified item.
 */
function remove(array, item) {
    // Copy the array
    array = [...array];

    // Look for the item (the item can have multiple indices)
    let fromIndex = array.length - 1;
    let foundIndex = array.lastIndexOf(item, fromIndex);

    while (foundIndex !== -1) {
        // Remove the item by generating a new array without it
        array = [
            ...array.slice(0, foundIndex),
            ...array.slice(foundIndex + 1),
        ];

        // Bookkeeping
        fromIndex = foundIndex - 1;
        foundIndex = array.lastIndexOf(item, fromIndex)
    }

    // Return the new array
    return array;
}

[2,3,5].filter(i => ![5].includes(i))

Hapus elemen pada indeks i, tanpa mengubah array asli:

/**
* removeElement
* @param {Array} array
* @param {Number} index
*/
function removeElement(array, index) {
   return Array.from(array).splice(index, 1);
}

// Another way is
function removeElement(array, index) {
   return array.slice(0).splice(index, 1);
}

Saya suka versi sambatan ini, menghapus elemen berdasarkan nilainya menggunakan $.inArray:

$(document).ready(function(){
    var arr = ["C#","Ruby","PHP","C","C++"];
    var itemtoRemove = "PHP";
    arr.splice($.inArray(itemtoRemove, arr),1);
});

Anda dapat mengulangi setiap array- item dan splice jika ada di array Anda.

function destroy(arr, val) {
    for (var i = 0; i < arr.length; i++) if (arr[i] === val) arr.splice(i, 1);
    return arr;
}

Saya baru saja membuat polyfill pada Array.prototype melalui Object.defineProperty untuk menghapus elemen yang diinginkan dalam array tanpa menyebabkan kesalahan saat iterating di kemudian hari melalui for .. in ..

if (!Array.prototype.remove) {
  // Object.definedProperty is used here to avoid problems when iterating with "for .. in .." in Arrays
  // https://stackoverflow.com/questions/948358/adding-custom-functions-into-array-prototype
  Object.defineProperty(Array.prototype, 'remove', {
    value: function () {
      if (this == null) {
        throw new TypeError('Array.prototype.remove called on null or undefined')
      }

      for (var i = 0; i < arguments.length; i++) {
        if (typeof arguments[i] === 'object') {
          if (Object.keys(arguments[i]).length > 1) {
            throw new Error('This method does not support more than one key:value pair per object on the arguments')
          }
          var keyToCompare = Object.keys(arguments[i])[0]

          for (var j = 0; j < this.length; j++) {
            if (this[j][keyToCompare] === arguments[i][keyToCompare]) {
              this.splice(j, 1)
              break
            }
          }
        } else {
          var index = this.indexOf(arguments[i])
          if (index !== -1) {
            this.splice(index, 1)
          }
        }
      }
      return this
    }
  })
} else {
  var errorMessage = 'DANGER ALERT! Array.prototype.remove has already been defined on this browser. '
  errorMessage += 'This may lead to unwanted results when remove() is executed.'
  console.log(errorMessage)
}

Menghapus nilai integer

var a = [1, 2, 3]
a.remove(2)
a // Output => [1, 3]

Menghapus nilai string

var a = ['a', 'ab', 'abc']
a.remove('abc')
a // Output => ['a', 'ab']

Menghapus nilai boolean

var a = [true, false, true]
a.remove(false)
a // Output => [true, true]

Dimungkinkan juga untuk menghapus objek di dalam array melalui metode Array.prototype.remove ini. Anda hanya perlu menentukan key => value dari Object yang ingin Anda hapus.

Menghapus nilai objek

var a = [{a: 1, b: 2}, {a: 2, b: 2}, {a: 3, b: 2}]
a.remove({a: 1})
a // Output => [{a: 2, b: 2}, {a: 3, b: 2}]

Saya membuat ekstensi yang cukup efisien ke array JavaScript dasar:

Array.prototype.drop = function(k) {
  var valueIndex = this.indexOf(k);
  while(valueIndex > -1) {
    this.removeAt(valueIndex);
    valueIndex = this.indexOf(k);
  }
};

Dengan solusi saya, Anda dapat menghapus satu atau lebih dari satu item dalam array berkat JavaScript murni. Tidak perlu perpustakaan JavaScript lain.

var myArray = [1,2,3,4,5]; // First array

var removeItem = function(array,value) {  // My clear function
    if(Array.isArray(value)) {  // For multi remove
        for(var i = array.length - 1; i >= 0; i--) {
            for(var j = value.length - 1; j >= 0; j--) {
                if(array[i] === value[j]) {
                    array.splice(i, 1);
                };
            }
        }
    }
    else { // For single remove
        for(var i = array.length - 1; i >= 0; i--) {
            if(array[i] === value) {
                array.splice(i, 1);
            }
        }
    }
}

removeItem(myArray,[1,4]); // myArray will be [2,3,5]

Hapus satu nilai, menggunakan perbandingan longgar, tanpa mengubah array asli, ES6

/**
 * Removes one instance of `value` from `array`, without mutating the original array. Uses loose comparison.
 * 
 * @param {Array} array Array to remove value from
 * @param {*} value Value to remove
 * @returns {Array} Array with `value` removed
 */
export function arrayRemove(array, value) {
    for(let i=0; i<array.length; ++i) {
        if(array[i] == value) {
            let copy = [...array];
            copy.splice(i, 1);
            return copy;
        }
    }
    return array;
}

Namun jawaban lain, bagi saya yang lebih sederhana adalah yang lebih baik, dan seperti kita pada tahun 2018 (dekat 2019) saya memberikan Anda ini (dekat) satu liner untuk menjawab pertanyaan asli:

Array.prototype.remove = function (value) { 
    return this.filter(f => f != value) 
}

Yang berguna adalah Anda bisa menggunakannya dalam ekspresi kari seperti:

[1,2,3].remove(2).sort()

Sementara sebagian besar jawaban di atas menjawab pertanyaan, tidak cukup jelas mengapa metode slice() belum digunakan. Ya, filter() memenuhi kriteria ketetapan, tetapi bagaimana dengan melakukan hal berikut yang lebih pendek:

const myArray = [1,2,3,4];

Dan sekarang katakanlah kita harus menghapus elemen kedua dari array, kita cukup melakukan: const newArray = myArray.slice(0,1).concat(myArray.slice(2,4));// [1,3,4]

Cara menghapus elemen dari array sangat dianjurkan saat ini di komunitas karena sifatnya yang sederhana dan tidak berubah. Secara umum, metode yang menyebabkan mutasi harus dihindari. Misalnya, Anda disarankan untuk mengganti Push() dengan concat() dan splice() dengan slice() 

Gunakan jQuery.grep () :

var y = [1, 2, 3, 9, 4]
var removeItem = 9;

y = jQuery.grep(y, function(value) {
  return value != removeItem;
});
console.log(y)

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.2/jquery.min.js"></script>

Menghapus elemen/string tertentu dari array dapat dilakukan dalam satu liner: Saya masih berpikir ini adalah liner paling elegan yang bisa Anda dapatkan untuk jenis masalah ini: 

theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);

di mana 'theArray' adalah larik yang ingin Anda hapus.

Posting kode saya yang menghapus elemen array di tempatnya, dan mengurangi panjang array juga.

function removeElement(idx, arr) {
    // check the index value
    if (idx < 0 || idx >= arr.length) {
        return;
    }
    // shift the elements
    for (var i = idx; i > 0; --i) {
        arr[i] = arr[i - 1];
    }
    // remove the first element in array
    arr.shift();
}

Ada banyak jawaban yang fantastis di sini, tetapi bagi saya, apa yang paling berhasil tidak menghilangkan elemen saya dari array sepenuhnya tetapi hanya mengatur nilai itu menjadi nol. Ini berfungsi untuk sebagian besar kasus yang saya miliki, dan merupakan solusi yang baik karena saya akan menggunakan variabel nanti dan tidak ingin itu hilang, kosongkan saja untuk saat ini. Juga, pendekatan ini sepenuhnya kompatibel lintas browser.

array.key = null;

Hapus kejadian terakhir atau semua kejadian, atau kejadian pertama? 

var array = [2, 5, 9, 5];

// Remove last occurrence (or all occurrences)
for (var i = array.length; i--;) {
  if (array[i] === 5) {
     array.splice(i, 1);
     break; // Remove this line to remove all occurrences
  }
}

atau

var array = [2, 5, 9, 5];

// Remove first occurrence
for (var i = 0; array.length; i++) {
  if (array[i] === 5) {
     array.splice(i, 1);
     break; // Do not remove this line
  }
}

Bagi siapa pun yang ingin mereplikasi metode yang akan mengembalikan array baru yang memiliki angka duplikat atau string dihapus, ini telah disatukan dari jawaban yang ada:

function uniq(array) {
  var len = array.length;
  var dupFree = [];
  var tempObj = {};

  for (var i = 0; i < len; i++) {
    tempObj[array[i]] = 0;
  }

  console.log(tempObj);

  for (var i in tempObj) {
    var element = i;
    if (i.match(/\d/)) {
      element = Number(i);
    }
    dupFree.Push(element);
  }

  return dupFree;
}

Saya membuat suatu fungsi 

function pop(valuetoremove, myarray) {
var indexofmyvalue = myarray.indexOf(valuetoremove);
myarray.splice(indexofmyvalue, 1);
}

Dan digunakan seperti ini.

pop(valuetoremove,myarray);

Tepuk tangan!

Implementasi yang sangat naif adalah sebagai berikut:

Array.prototype.remove = function(data) {
    const dataIdx = this.indexOf(data)
    if(dataIdx >= 0) {
        this.splice(dataIdx ,1);
    }
    return this.length;
}

let a = [1,2,3];
// this will change arr a to [1, 3]
a.remove(2);

Saya mengembalikan panjang array dari fungsi untuk mematuhi metode lain seperti Array.prototype.Push().

Saya memiliki masalah ini sendiri (dalam situasi di mana mengganti array dapat diterima) dan menyelesaikannya dengan sederhana:

var filteredItems = this.items.filter(function (i) {
    return i !== item;
});

Untuk memberikan potongan konteks di atas:

self.thingWithItems = {
        items: [],
        removeItem: function (item) {
            var filteredItems = this.items.filter(function (i) {
                return i !== item;
            });

            this.items = filteredItems;
        }
    };

Solusi ini harus bekerja dengan item referensi dan nilai. Itu semua tergantung apakah Anda perlu mempertahankan referensi ke array asli, apakah solusi ini berlaku. 

Seringkali lebih baik membuat array baru dengan fungsi filter.

const array = [1,2,3,4];
array = array.filter(i => i !== 4); // [1,2,3]

Ini juga meningkatkan keterbacaan imho. Saya bukan penggemar irisan, meskipun terkadang Anda harus tahu.

var array = [2, 5, 9];
array.splice(array.findIndex(x => x==5), 1);

Dengan menggunakan Array.findindex, kita dapat mengurangi jumlah baris kode.

developer.mozilla.org

var index,
    input = [1,2,3],
    indexToRemove = 1;
    integers = [];

for (index in input) {
    if (input.hasOwnProperty(index)) {
        if (index !== indexToRemove) {
            integers.Push(result); 
        }
    }
}
input = integers;

Solusi ini akan mengambil array input dan akan mencari input untuk nilai yang akan dihapus. Ini akan mengulang seluruh array input dan hasilnya akan menjadi integer array kedua yang telah menghapus indeks spesifik. Array integer kemudian disalin kembali ke array input. 

Pertanyaan Anda tidak menunjukkan apakah pesanan atau nilai yang berbeda merupakan persyaratan.

Jika Anda tidak peduli dengan pesanan, dan tidak akan memiliki nilai yang sama dalam wadah lebih dari sekali, gunakan Set. Ini akan menjadi cara yang lebih cepat, dan lebih ringkas. 

var aSet = new Set();

aSet.add(1);
aSet.add(2);
aSet.add(3);

aSet.delete(2);

Menghapus nilai dengan indeks dan sambatan!

function removeArrValue(arr,value) {
    var index = arr.indexOf(value);
    if (index > -1) {
        arr.splice(index, 1);
    }
    return arr;
}

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

Sayang sekali Anda memiliki array bilangan bulat, bukan objek di mana kunci adalah string yang setara dengan bilangan bulat ini.

Saya telah melihat banyak jawaban ini dan mereka semua tampaknya menggunakan "kekuatan kasar" sejauh yang saya bisa lihat. Saya belum memeriksa setiap orang, minta maaf jika tidak demikian. Untuk array bertubuh kecil ini tidak apa-apa, tetapi bagaimana jika Anda memiliki ribuan bilangan bulat di dalamnya?

Koreksi saya jika saya salah, tetapi tidak dapatkah kita berasumsi bahwa dalam peta key => value, dari jenis objek JS, bahwa mekanisme pengambilan kunci dapat diasumsikan sangat direkayasa dan dioptimalkan? (NB jika beberapa ahli super memberi tahu saya bahwa ini bukan masalahnya, saya dapat menyarankan menggunakan kelas Peta ES6 sebagai gantinya, yang tentunya akan menjadi).

Saya hanya menyarankan bahwa, dalam keadaan tertentu, solusi terbaik mungkin untuk mengubah array Anda menjadi objek ... masalahnya adalah, tentu saja, bahwa Anda mungkin telah mengulangi nilai integer. Saya sarankan untuk meletakkannya di ember sebagai bagian "nilai" dari entri key => value. (NB jika Anda yakin Anda tidak memiliki elemen array berulang ini bisa jauh lebih sederhana: nilai kunci "sama dengan", dan hanya pergi Object.values(...) untuk mendapatkan kembali array yang diubah).

Jadi Anda bisa melakukannya:

const arr = [ 1, 2, 55, 3, 2, 4, 55 ];
const f =   function( acc, val, currIndex ){ 
    // not seen this val before: make bucket... NB although val's typeof is 'number'
    // there is seamless equivalence between the object key (always string)
    // and this variable val 
    ! ( val in acc ) ? acc[ val ] = []: 0;
    // drop another array index in the bucket
    acc[ val ].Push( currIndex );
    return acc; 
}
const myIntsMapObj = arr.reduce( f, {});

console.log( myIntsMapObj );

keluaran:

Objek [<1 slot kosong>, Array 1 , Array [2], Array 1 , Array 1 , <5 slot kosong>, 46 lagi ...]

maka mudah untuk menghapus semua angka 55

delete myIntsMapObj[ 55 ]; // again, although keys are strings this works

Anda tidak harus menghapus semuanya: nilai indeks didorong ke dalam ember sesuai urutan tampilan, jadi (misalnya):

myIntsMapObj[ 55 ].shift(); // and
myIntsMapObj[ 55 ].pop(); 

akan menghapus kejadian pertama dan terakhir masing-masing. Anda dapat menghitung frekuensi kemunculan dengan mudah, ganti semua 55-an dengan 3-an dengan mentransfer konten dari satu ember ke yang lain, dll.

... mengembalikan array int Anda yang dimodifikasi sedikit terlibat: tetapi setiap bucket berisi indeks (dalam array asli) dari nilai yang diwakili oleh kunci (string). Masing-masing nilai bucket ini juga unik: jadi Anda mengubahnya menjadi kunci di objek baru, dengan bilangan bulat (nyata) dari "kunci bilangan integer" sebagai nilai ... lalu urutkan kunci dan buka Object.values( ... ).

Ini kedengarannya sangat terlibat dan memakan waktu ... tetapi jelas semuanya tergantung pada keadaan dan penggunaan yang diinginkan. Pemahaman saya adalah bahwa semua versi dan konteks JS hanya beroperasi dalam satu utas, dan utas tersebut tidak "melepaskan", jadi mungkin ada beberapa kemacetan yang mengerikan dengan metode "brute force": disebabkan tidak begitu banyak oleh indexOf ops , tetapi berulang berulang slicesplice ops.

_/Addendum
Jika Anda yakin ini terlalu banyak rekayasa untuk kasus penggunaan Anda tentunya pendekatan "brute force" yang paling sederhana adalah

const arr = [ 1, 2, 3, 66, 8, 2, 3, 2 ];
const newArray = arr.filter( number => number !== 3 );
console.log( newArray )

(ya, jawaban lain telah melihat Array.prototype.filter...)

Metode berikut akan menghapus semua entri dari nilai yang diberikan dari array tanpa membuat array baru dan hanya dengan satu iterasi yaitu superfast. Dan itu berfungsi di browser kuno Internet Explorer 5.5 :

function removeFromArray(arr, removeValue) {
  for (var i = 0, k = 0, len = arr.length >>> 0; i < len; i++) {
    if (k > 0)
      arr[i - k] = arr[i];

    if (arr[i] === removeValue)
      k++;
  }

  for (; k--;)
    arr.pop();
}

var a = [0, 1, 0, 2, 0, 3];

document.getElementById('code').innerHTML =
  'Initial array [' + a.join(', ') + ']';
//Initial array [0, 1, 0, 2, 0, 3]

removeFromArray(a, 0);

document.getElementById('code').innerHTML +=
  '<br>Resulting array [' + a.join(', ') + ']';
//Resulting array [1, 2, 3]

<code id="code"></code>

Untuk menghapus elemen tertentu atau elemen berikutnya, Array.splice () method berfungsi dengan baik . Metode splice () mengubah isi array dengan menghapus atau mengganti elemen yang ada dan/atau menambahkan elemen baru dan mengembalikannya. item yang dihapus.

Sintaks: _ ​​array.splice (indeks, deleteCount, item1, ....., itemX)

Di sini index wajib dan argumen lainnya opsional.

Sebagai contoh:

let arr = [1, 2, 3, 4, 5, 6];
arr.splice(2,1);
console.log(arr);
// [1, 2, 4, 5, 6]

Catatan:Array.splice () metode dapat digunakan jika Anda mengetahui indeks elemen yang ingin Anda hapus. Tapi kami mungkin memiliki beberapa kasus seperti yang disebutkan di bawah ini-

1. Jika Anda ingin menghapus hanya elemen terakhir, Anda dapat menggunakan Array.pop ()

2. Jika Anda ingin menghapus elemen pertama saja, Anda dapat menggunakan Array.shift ()

3. Jika Anda tahu elemen saja tetapi bukan posisi (atau indeks) elemen, dan ingin menghapus semua elemen yang cocok menggunakan Array.filter () metode:

   let arr = [1, 2, 1, 3, 4, 1, 5, 1];
   
   let newArr = arr.filter(function(val){
       return val !== 1;
    });
    //newArr => [2, 3, 4, 5]
   

ATAU dengan menggunakan metode splice () as-

let arr = [1, 11, 2, 11, 3, 4, 5, 11, 6, 11];
    for( let i = 0; i < arr.length-1; i++){
       if ( arr[i] === 11) {
         arr.splice(i, 1); 
       }
    }
    console.log(arr);
    // [1, 2, 3, 4, 5, 6]

ATAU Misalkan kita ingin menghapus del dari array Array:

let arr = [1, 2, 3, 4, 5, 6];
let del = 4;
if(arr.indexOf(4) >= 0) {
arr.splice(arr.indexOf(4), 1)
}

OR

let del = 4;
for(var i = arr.length - 1; i >= 0; i--) {
    if(arr[i] === del) {
       arr.splice(i, 1);
    }
}

4. Jika Anda tahu elemen itu sendiri tetapi bukan posisi (atau indeks) elemen tersebut, dan ingin menghapus elemen pencocokan pertama saja menggunakan metode splice ():

   let arr = [1, 11, 2, 11, 3, 4, 5, 11, 6, 11];
   
   for( let i = 0; i < arr.length-1; i++){
     if ( arr[i] === 11) {
       arr.splice(i, 1);
       break;
     }
   }
   console.log(arr);
   // [1, 11, 2, 11, 3, 4, 5, 11, 6, 11]
   

Jika Anda harus mendukung versi Internet Explorer yang lebih lama, saya sarankan menggunakan polyfill berikut (catatan: ini bukan kerangka kerja). Ini adalah pengganti 100% kompatibel mundur dari semua metode array modern (JavaScript 1.8.5/ECMAScript 5 Array Extras) yang berfungsi untuk Internet Explorer 6+, Firefox 1.5+, Chrome, Safari, & Opera.

https://github.com/plusdude/array-generics

Definisikan metode bernama remove () pada objek array menggunakan fitur pengesahan JavaScript.

Gunakan splice () metode untuk memenuhi kebutuhan Anda.

Silakan lihat kode di bawah ini.

Array.prototype.remove = function(item) {
    // index will have -1 if item does not exist
    // else it will have the index of 1st item found in array
    var index = this.indexOf(item); 

    if (index > -1) {
        // splice() method is used to add/remove items(s) in array
        this.splice(index, 1); 
    }

    return index;
}


var arr = [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];

// Printing array
// [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];
console.log(arr)

// Removing 67 (getting its index i.e. 2)
console.log("Removing 67")
var index = arr.remove(67)

if (index > 0){
    console.log("Item 67 found at ", index)
} else {
    console.log("Item 67 does not exist in array")
}

// Printing updated array
// [ 11, 22, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];
console.log(arr)

// ............... Output ................................
// [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4 ]
// Removing 67
// Item 67 found at  2
// [ 11, 22, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4 ]

Catatan: Di bawah ini adalah contoh kode lengkap yang dijalankan pada Node.js REPL yang menggambarkan penggunaan Push (), pop (), shift (), unshift (), dan splice () metode.

> // Defining an array
undefined
> var arr = [12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34];
undefined
> // Getting length of array
undefined
> arr.length;
16
> // Adding 1 more item at the end i.e. pushing an item
undefined
> arr.Push(55);
17
> arr
[ 12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34, 55 ]
> // Popping item from array (i.e. from end)
undefined
> arr.pop()
55
> arr
[ 12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> // Remove item from beginning
undefined
> arr.shift()
12
> arr
[ 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> // Add item(s) at beginning
undefined
> arr.unshift(67); // Add 67 at begining of the array and return number of items in updated/new array
16
> arr
[ 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> arr.unshift(11, 22); // Adding 2 more items at the beginning of array
18
> arr
[ 11, 22, 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> // Define a method on array (temorarily) to remove an item and return the index of removed item; if it is found else return -1
undefined
> Array.prototype.remove = function(item) {
... var index = this.indexOf(item);
... if (index > -1) {
..... this.splice(index, 1); // splice() method is used to add/remove items in array
..... }
... return index;
... }
[Function]
>
> arr
[ 11, 22, 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(45);   // Remove 45 (You will get the index of removed item)
3
> arr
[ 11, 22, 67, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(22)    // Remove 22
1
> arr
[ 11, 67, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> arr.remove(67)    // Remove 67
1
> arr
[ 11, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(89)    // Remove 89
2
> arr
[ 11, 67, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(100);  // 100 doesn't exist, remove() will return -1
-1
>

Terima kasih.

Sambungan, filter dan hapus untuk menghapus elemen dari array

Setiap array memiliki indeksnya dan itu membantu untuk menghapus elemen tertentu dengan indeks mereka.

Metode sambatan () 

array.splice (index, 1 ); Parameter pertama adalah index dan yang kedua adalah jumlah elemen yang Anda

ingin menghapus dari indeks itu.

Jadi untuk elemen tunggal kita menggunakan 1. 

Metode hapus

hapus array [indeks]

Metode filter ()

Jika Anda ingin menghapus elemen yang diulang dalam array kemudian filter array.

removeAll = array.filter (e => e! = elem);

di mana elem adalah elemen yang ingin Anda hapus dari array dan array adalah nama array Anda

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

array.splice (mulai [ deleteCount [ item1 [ item2 [ ...]]]])]

mulai

Indeks di mana untuk mulai mengubah array (dengan Origin 0). Jika lebih besar dari panjang array, indeks awal aktual akan ditetapkan ke panjang array. Jika negatif, akan mulai banyak elemen dari akhir array (dengan Origin -1) dan akan ditetapkan ke 0 jika nilai absolut lebih besar dari panjang array.

deleteCount Opsional

Integer yang menunjukkan jumlah elemen array lama untuk dihapus . Jika deleteCount dihilangkan, atau jika nilainya lebih besar dari array.length - start (yaitu, jika lebih besar dari jumlah elemen yang tersisa dalam array, mulai dari awal), maka semua elemen dari awal hingga akhir array akan dihapus ..__ Jika deleteCount bernilai 0 atau negatif, tidak ada elemen yang dihapus. Dalam hal ini, Anda harus menentukan setidaknya satu elemen baru (lihat di bawah).

item1, item2, ... Opsional

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

Untuk referensi lebih lanjut silakan kunjungi:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice

Sudah ada banyak jawaban, tetapi karena belum ada yang melakukannya dengan satu liner, saya pikir saya akan menunjukkan metode saya. Itu mengambil keuntungan dari fakta bahwa fungsi string.split () akan menghapus semua karakter yang ditentukan saat membuat array. Berikut ini sebuah contoh: 

var ary = [1,2,3,4,1234,10,4,5,7,3];
out = ary.join("-").split("-4-").join("-").split("-");
console.log(out);

Dalam contoh ini, semua 4 dihapus dari array ary. Namun, penting untuk dicatat bahwa array apa pun yang mengandung karakter "-" akan menyebabkan masalah dengan contoh ini. Singkatnya, ini akan menyebabkan fungsi join ("-") menyatukan string Anda secara tidak benar. Dalam situasi seperti itu, semua string "-" dalam snipet di atas dapat diganti dengan string apa pun yang tidak akan digunakan dalam array asli. Ini adalah contoh lain: 

var ary = [1,2,3,4,'-',1234,10,'-',4,5,7,3];
out = ary.join("[email protected]#").split("[email protected]#[email protected]#").join("[email protected]#").split("[email protected]#");
console.log(out);

Mengambil keuntungan dari metode pengurangan sebagai berikut:

huruf a) jika Anda perlu menghapus elemen dengan indeks:

function remove(arr, index) {
  return arr.reduce((prev, x, i) => prev.concat(i !== index ? [x] : []), []);
}

kasus b) jika Anda perlu menghapus elemen dengan nilai elemen (int):

function remove(arr, value) {
  return arr.reduce((prev, x, i) => prev.concat(x !== value ? [x] : []), []);
}

Jadi dengan cara ini kita dapat mengembalikan array baru (akan menjadi cara fungsional yang keren - jauh lebih baik daripada menggunakan Push atau splice) dengan elemen dihapus.

Array.prototype.remove = function(x) {
    var y=this.slice(x+1);
    var z=[];
    for(i=0;i<=x-1;i++) {
        z[z.length] = this[i];
    }

    for(i=0;i<y.length;i++){
        z[z.length]=y[i];
    }

    return z;
}

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

arr.splice(0,1)

console.log(arr)

Output [2, 3, 4, 5];