Ben bir sayı dizisi var ve ben .push()ona öğe eklemek için yöntem kullanıyorum .

Bir diziden belirli bir öğeyi kaldırmanın basit bir yolu var mı?

Gibi bir şey eşdeğer arıyorum:

array.remove(number);

Temel JavaScript kullanmak zorundayım . Çerçevelere izin verilmez.

indexKullanarak kaldırmak istediğiniz dizi öğesini bulun indexOfve ardından bu dizini ile kaldırın splice.

Splice () yöntemi, var olan öğeleri kaldırarak ve / veya yeni öğeler ekleyerek bir dizinin içeriğini değiştirir.

const array = [2, 5, 9];

console.log(array);

const index = array.indexOf(5);
if (index > -1) {
  array.splice(index, 1);
}

// array = [2, 9]
console.log(array); 

İkinci parametresi splicekaldırılacak öğe sayısıdır. spliceDiziyi yerinde değiştirdiğini ve kaldırılan öğeleri içeren yeni bir dizi döndürdüğünü unutmayın .

Bütünlük nedeniyle, fonksiyonlar burada. İlk işlev (yani, ilk maçı çıkarılması sadece tek bir oluşumunu ortadan kaldırır 5gelen [2,5,9,1,5,8,5]ikinci işlev tüm oluşumları yok ederken,):

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

function removeItemAll(arr, value) {
    var i = 0;
    while (i < arr.length) {
        if(arr[i] === value) {
            arr.splice(i, 1);
        } else {
            ++i;
        }
    }
    return arr;
}

Nasıl beklediğini bilmiyorum array.remove(int) davranmayı . İstediğinizi düşünebileceğim üç olasılık var.

Dizindeki bir dizinin bir öğesini kaldırmak için i:

array.splice(i, 1);

Değer içeren her öğeyi numberdiziden kaldırmak istiyorsanız :

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

Yalnızca dizindeki öğeyi iartık oluşturmak istemiyorsanız, ancak diğer öğelerin dizinlerinin değişmesini istemiyorsanız:

delete array[i];

2016 Ekim tarihinde düzenlendi

• Basit, sezgisel ve açık yapın ( Occam'ın ustura )
• Değişmez mi (orijinal dizi değişmeden kalır)
• Tarayıcınız bunları desteklemiyorsa standart JavaScript işlevleriyle yapın - çoklu dolgu kullanın

Bu kod örneğinde , bir diziden istenmeyen öğeleri kaldırmak için "array.filter (...)" işlevini kullanıyorum. Bu işlev orijinal diziyi değiştirmez ve yeni bir dizi oluşturur. Tarayıcınız bu işlevi desteklemiyorsa (örneğin, sürüm 9'dan önceki Internet Explorer veya sürüm 1.5'ten önce Firefox), Mozilla'dan filtre çoklu dolgusunu kullanmayı düşünün .

Öğe kaldırılıyor (ECMA-262 Edition 5 kodu, eski stil JavaScript)

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 ]

Öğe kaldırılıyor (ECMAScript 6 kodu)

let value = 3

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

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

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

ÖNEMLİ ECMAScript 6 "() => {}" ok işlevi sözdizimi Internet Explorer'da, 45 sürümünden önceki Chrome'da, 22 sürümünden önce Firefox'ta ve 10 sürümünden önce Safari'de desteklenmemektedir. ECMAScript 6 sözdizimini eski tarayıcılarda kullanmak için BabelJS'yi kullanabilirsiniz .

Birden çok öğeyi kaldırma (ECMAScript 7 kodu)

Bu yöntemin ek bir avantajı, birden çok öğeyi kaldırabilmenizdir

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 ]

ÖNEMLİ "array.includes (...)" işlevi Internet Explorer'da, 47 sürümünden önce Chrome, 43 sürümünden önce Firefox, 9 sürümünden önce Safari ve 14 sürümünden önce Edge'de desteklenmemektedir, bu nedenle burada Mozilla'dan çok dolgu vardır .

Birden fazla öğeyi kaldırma (gelecekte, belki de)

"Bu Bağlayıcı Sözdizimi" teklifi kabul edilirse, bunu yapabilirsiniz:

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

BabelJS'de kendiniz deneyin :)

Referans

• Array.prototype.includes
• Fonksiyonel kompozisyon

Boş bir yer tutmak isteyip istemediğinize bağlıdır.

Boş bir yuva istiyorsanız, silme iyidir:

delete array[index];

Bunu yapmazsanız, splice yöntemini kullanmalısınız :

array.splice(index, 1);

Ve bu öğenin değerine ihtiyacınız varsa, döndürülen dizinin öğesini depolayabilirsiniz:

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

Bir sırayla yapmak isterseniz array.pop(), sonuncusu veya array.shift()birincisi için kullanabilirsiniz (ve her ikisi de öğenin değerini de döndürür).

Ve öğenin dizinini bilmiyorsanız, array.indexOf(item)almak için kullanabilirsiniz ( if()bir öğeyi almak için a veya while()hepsini almak için a). array.indexOf(item)dizini ya da bulunmazsa -1 değerini döndürür. 

Bir arkadaşım Internet Explorer 8'de sorunlar yaşıyordu ve bana ne yaptığını gösterdi. Ona bunun yanlış olduğunu söyledim ve yanıtı burada bulduğunu söyledi. Geçerli en iyi yanıt tüm tarayıcılarda (örneğin Internet Explorer 8) çalışmaz ve öğenin yalnızca ilk oluşumunu kaldırır.

Bir diziden TÜM örnekleri kaldır

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

Diziyi geriye doğru döndürür (öğeler kaldırıldıkça dizinler ve uzunluk değişeceğinden) ve bulunursa öğeyi kaldırır. Tüm tarayıcılarda çalışır.

İki ana yaklaşım vardır:

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

2. sil :delete anArray[index];

Bir dizi için sil komutunu kullanırken dikkatli olun. Nesnelerin niteliklerini silmek için iyidir, ancak diziler için çok iyi değildir. spliceDiziler için kullanmak daha iyidir .

deleteBir dizi için kullandığınızda bunun için yanlış sonuçlar alabileceğinizi unutmayın anArray.length. Başka bir deyişle, deleteöğeyi kaldırır, ancak length özelliğinin değerini güncellemez.

Ayrıca delete komutunu kullandıktan sonra dizin numaralarında delikler olmasını bekleyebilirsiniz; örneğin, index 1, 3, 4, 8, 9 ve 11 dizinlerini ve delete komutunu kullanmadan önceki uzunluğuna sahip olabilirsiniz. Bu durumda, fordizinler artık sıralı olmadığından dizinlenmiş tüm döngüler kilitlenir.

Herhangi bir deletenedenle kullanmak zorunda kalırsanız, for eachdiziler arasında döngü yapmanız gerektiğinde döngüler kullanmalısınız . Aslında, formümkünse her zaman dizinlenmiş döngüler kullanmaktan kaçının . Bu şekilde kod daha sağlam ve dizinlerle ilgili sorunlara daha az eğilimli olacaktır.

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)

indexOfVeya kullanımına gerek yoktur splice. Ancak, bir öğenin yalnızca bir örneğini kaldırmak istiyorsanız daha iyi performans gösterir.

Bul ve taşı (taşı):

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

indexOfVe splice(indexof) kullanın :

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

Yalnızca splice(ek yeri) kullanın :

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

1000 elemanlı dizi için düğümlerde çalışma süreleri (ortalama 10000'den fazla çalışma):

indexof yaklaşık olarak 10x yavaştır hareket . Çağrısına kaldırarak geliştirilmiş olsa bile indexOfiçinde ek yeri o çok daha kötü performans gösteren hareket .

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

Bu değer yerine bir yüklem sağlar.

NOT: verilen diziyi günceller ve etkilenen satırları döndürür.

kullanım

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

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

Tanım

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

Filtre yöntemiyle kolayca yapabilirsiniz :

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

Bu diziden tüm öğeleri kaldırır ve aynı zamanda bir kombinasyonu daha hızlı çalışır sliceve indexOf.

John Resig iyi bir uygulama yayınladı :

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

Genel bir nesneyi genişletmek istemiyorsanız, bunun yerine aşağıdakine benzer bir şey yapabilirsiniz:

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

Ancak bunu göndermemin ana nedeni, kullanıcıları bu sayfadaki yorumlarda önerilen alternatif uygulamaya karşı uyarmaktır (14 Aralık 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;
};

İlk başta iyi çalışıyor gibi görünüyor, ancak acı verici bir süreçle bir dizideki ikinci son öğeyi kaldırmaya çalışırken başarısız olduğunu keşfettim. Örneğin, 10 öğeli bir diziniz varsa ve 9. öğeyi bununla kaldırmaya çalışırsanız:

myArray.remove(8);

Sonunda 8 elemanlı bir dizi elde edersiniz. Nedenini bilmiyorum ama John'un orijinal uygulamasında bu sorun olmadığını doğruladım.

Underscore.js , birden çok tarayıcıyla ilgili sorunları çözmek için kullanılabilir. Varsa, yerleşik tarayıcı yöntemlerini kullanır. Eski Internet Explorer sürümlerinde olduğu gibi yoksa, kendi özel yöntemlerini kullanır.

Diziden öğeleri kaldırmak için basit bir örnek (web sitesinden):

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

ES6'yı kullanabilirsiniz. Örneğin, bu durumda '3' değerini silmek için:

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

Çıktı :

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

Silinmiş konumların kaldırıldığı yeni bir dizi istiyorsanız, istediğiniz öğeyi her zaman silebilir ve diziyi filtreleyebilirsiniz. Filtre yöntemini uygulamayan tarayıcılar için dizi nesnesinin bir uzantısına ihtiyaç duyabilir , ancak uzun vadede yapmanız gereken tek şey budur:

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

Görüntülenmelidir [1, 2, 3, 4, 6].

Bu kodu inceleyin. Her büyük tarayıcıda çalışır .

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

Bu işlevi ara

remove_item(array,value);

Lodash kullanabilirsiniz _.pull (diziyi değiştir), _.pullAt (diziyi değiştir) veya _.without (diziyi değiştirmez),

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

ES6 ve mutasyon olmadan: (Ekim 2016)

const removeByIndex = (list, index) =>
      [
        ...list.slice(0, index),
        ...list.slice(index + 1)
      ];
         
output = removeByIndex([33,22,11,44],1) //=> [33,11,44]
      
console.log(output)

Bir diziden belirli bir öğeyi / dizeyi kaldırmak tek bir astarda yapılabilir:

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

nerede:

theArray : belirli bir şeyi kaldırmak istediğiniz dizi

stringToRemoveFromArray : kaldırılmasını istediğiniz dize ve 1, kaldırmak istediğiniz öğelerin miktarıdır.

NOT : "stringToRemoveFromArray" dizininizde bulunmuyorsa, dizinin son öğesini kaldırır.

Öğeyi kaldırmadan önce dizinizde var olup olmadığını kontrol etmek her zaman iyi bir uygulamadır.

if (theArray.indexOf("stringToRemoveFromArray") >= 0){
   theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);
}

İstemcinizin bilgisayarlarındaki daha yeni Ecmascript sürümlerine erişiminiz varsa (UYARI, eski istasyonlarda çalışmayabilir):

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

Burada '3' diziden kaldırılmasını istediğiniz değerdir. Dizi daha sonra:['1','2','4','5','6']

JavaScript kullanarak bir diziden bir öğeyi kaldırmanın birkaç yolu .

Açıklanan tüm yöntem orijinal diziyi değiştirmez ve bunun yerine yeni bir oluşturur.

Bir öğenin dizinini biliyorsanız

Bir diziniz olduğunu ve konumdaki bir öğeyi kaldırmak istediğinizi varsayalım i.

Bir yöntem kullanmaktır slice():

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

console.log(filteredItems)

slice()aldığı dizinlerle yeni bir dizi oluşturur. Baştan kaldırmak istediğimiz dizine kadar yeni bir dizi oluştururuz ve kaldırdığımız diziden sonraki ilk konumdan dizinin sonuna kadar başka bir diziyi birleştiririz.

Değeri biliyorsanız

Bu durumda, filter()daha bildirimsel bir yaklaşım sunan iyi bir seçenek kullanmaktır :

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

console.log(filteredItems)

ES6 ok işlevlerini kullanır. Eski tarayıcıları desteklemek için geleneksel işlevleri kullanabilirsiniz:

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

console.log(filteredItems)

veya Babel'i kullanabilir ve eski tarayıcılar için daha sindirilebilir hale getirmek için ES6 kodunu ES5'e geri aktarabilir, ancak kodunuza modern JavaScript yazabilirsiniz.

Birden çok öğeyi kaldırma

Tek bir öğe yerine birçok öğeyi kaldırmak isterseniz ne olur?

En basit çözümü bulalım.

Dizine göre

Sadece bir işlev oluşturabilir ve serideki öğeleri kaldırabilirsiniz:

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)

Değere göre

Geri arama işlevinin içine dahil edilmesini arayabilirsiniz:

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)

Orijinal diziyi değiştirmekten kaçının

splice()(karıştırılmamalıdır slice()) orijinal diziyi değiştirir ve bundan kaçınılmalıdır.

(aslen https://flaviocopes.com/how-to-remove-item-from-array/ adresinde yayınlanmıştır )

Tamam, örneğin aşağıdaki diziye sahipsiniz:

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

Ve biz 4 sayısını silmek istiyoruz. Sadece aşağıdaki kodu kullanabilirsiniz:

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

Bu işlevi yeniden kullanıyorsanız, aşağıdaki gibi yerel dizi işlevine eklenecek yeniden kullanılabilir bir işlev yazarsınız :

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

Peki, dizide birkaç [5] s ile aşağıdaki diziye sahipseniz ne olur?

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

Hepsini kontrol etmek için bir döngüye ihtiyacımız var, ancak yerleşik JavaScript işlevlerini kullanmak için daha kolay ve daha verimli bir yol olduğundan, bunun yerine aşağıdaki gibi bir filtre kullanan bir işlev yazıyoruz:

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]

Ayrıca, Lodash veya Undercore gibi, bunu yapmanıza yardımcı olan üçüncü taraf kütüphaneleri de vardır. Daha fazla bilgi için bkz. Lodash _.pull, _.pullAt veya _.without.

JavaScript için oldukça yeniyim ve bu işlevselliğe ihtiyacım vardı. Ben sadece şunu yazdım:

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

Sonra kullanmak istediğinizde:

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

Çıktı - Beklendiği gibi. ["item1", "item1"]

Benden farklı ihtiyaçlarınız olabilir, bu yüzden onlara uyacak şekilde kolayca değiştirebilirsiniz. Umarım bu birine yardımcı olur.

Dizide karmaşık nesneleriniz varsa filtreleri kullanabilirsiniz? $ .İnArray veya array.splice öğesinin kullanımı o kadar kolay değildir. Özellikle nesneler dizide belki de sığsa.

Örneğin, Kimlik alanına sahip bir nesneniz varsa ve nesnenin bir diziden kaldırılmasını istiyorsanız:

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

ECMAScript 6'ya göre cevap vermek istiyorum . Aşağıdaki gibi bir diziniz olduğunu varsayın:

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

Gibi özel bir dizinde silmek istiyorsanız 2, aşağıdaki kodu yazın:

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

Ancak, gibi özel bir öğeyi silmek istiyorsanız 3ve dizinini bilmiyorsanız, aşağıdakileri yapın:

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

İpucu : boş bir dizi elde etmediğiniz sürece lütfen filtre geri araması için bir ok işlevi kullanın.

Güncelleme: Bu yöntem yalnızca ECMAScript 2015'i (eski adıyla ES6) kullanamıyorsanız önerilir. Kullanabiliyorsanız, buradaki diğer cevaplar çok daha temiz uygulamalar sağlar.

Buradaki özgeçmiş sorununuzu çözecek ve aynı zamanda argümanın sadece 1 (veya belirtilen bir değer) yerine tüm oluşumlarını silecektir.

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

Kullanımı:

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]

Verim

Bugün (2019-12-09) Seçilen çözümler için macOS v10.13.6 (High Sierra) üzerinde performans testleri yürütüyorum. Ben delete(A) göstermek , ama diğer yöntemlerle karşılaştırıldığında kullanmıyorum, çünkü dizi boş alan bıraktı.

Sonuçlar

• en hızlı çözüm array.splice(C) 'dir (ikinci kez bulunduğu küçük diziler için Safari hariç)
• büyük diziler için, array.slice+splice(H) Firefox ve Safari için en hızlı değişmez çözümdür; Array.from(B) Chrome'da en hızlı
• değişebilen çözeltiler genellikle değişmezden 1.5x-6x daha hızlıdır
• Safari'deki küçük masalar için şaşırtıcı bir şekilde değişebilir çözelti (C) değişmez çözeltiden (G) daha yavaştır

ayrıntılar

Testlerde orta elemanı diziden farklı şekillerde kaldırırım. A, C, çözeltiler yerinde bulunmaktadır. B, D, E, F, G, H çözeltileri değişken değildir.

10 elemanlı dizi sonuçları

Chrome'da array.splice(C) en hızlı yerinde çözümdür. array.filter(D) en hızlı değişmez bir çözümdür. En yavaş array.slice(F). Testi makinenizde buradan yapabilirsiniz .

1.000.000 element içeren dizi sonuçları

Chrome'da array.splice(C) en hızlı yerinde çözümdür ( delete(C) benzer hızlıdır - ancak dizide boş bir yuva bırakmıştır (bu nedenle 'tam kaldırma' gerçekleştirmez)). array.slice-splice(H) en hızlı değişmez bir çözümdür. En yavaş array.filter(D ve E). Testi makinenizde buradan yapabilirsiniz .

var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (letter,array) => console.log(letter, array.join `,`);

function A(array) {
  var index = array.indexOf(5);
  delete array[index];
  log('A', array);
}

function B(array) {
  var index = array.indexOf(5);
  var arr = Array.from(array);
  arr.splice(index, 1)
  log('B', arr);
}

function C(array) {
  var index = array.indexOf(5);
  array.splice(index, 1);
  log('C', array);
}

function D(array) {
  var arr = array.filter(item => item !== 5)
  log('D', arr);
}

function E(array) {
  var index = array.indexOf(5);
  var arr = array.filter((item, i) => i !== index)
  log('E', arr);
}

function F(array) {
  var index = array.indexOf(5);
  var arr = array.slice(0, index).concat(array.slice(index + 1))
  log('F', arr);
}

function G(array) {
  var index = array.indexOf(5);
  var arr = [...array.slice(0, index), ...array.slice(index + 1)]
  log('G', arr);
}

function H(array) {
  var index = array.indexOf(5);
  var arr = array.slice(0);
  arr.splice(index, 1);
  log('H', arr);
}

A([...a]);
B([...a]);
C([...a]);
D([...a]);
E([...a]);
F([...a]);
G([...a]);
H([...a]);

This snippet only presents code used in performance tests - it does not perform tests itself.

Tarayıcılar için karşılaştırma: Chrome v78.0.0, Safari v13.0.4 ve Firefox v71.0.0

Dizinizi asla değiştirmemelisiniz. Bu fonksiyonel programlama modeline aykırıdır. ECMAScript 6 yöntemini kullanarak verilerini değiştirmek istediğiniz diziye başvurmadan yeni bir dizi oluşturabilirsiniz filter;

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

Diziden kaldırmak istediğinizi varsayalım 5, bunu şu şekilde yapabilirsiniz:

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

Bu, kaldırmak istediğiniz değer olmadan yeni bir dizi verecektir. Sonuç şu olacaktır:

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

Daha fazla bilgi için Array.filter'daki MDN belgelerini okuyabilirsiniz .

Daha modern, ECMAScript 2015 (eski adıyla Harmony veya ES 6) yaklaşımı. Verilen:

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

Sonra:

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

Verim:

[1, 2, 4]

Sen kullanabilirsiniz Babel ve polyfill hizmeti bu iyi tarayıcılarda desteklenir sağlamak için.

Dizide 1'den 9'a kadar var ve 5'i kaldırmak istiyorsunuz. Aşağıdaki kodu kullanın:

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

Birden çok değer istiyorsanız. Örnek: - 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, 1,7 and 8 removed", newNumberArray);

Bir dizideki dizi değerini kaldırmak istiyorsanız. Örnek: [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);

Desteklenen tarayıcı bağlantısı içerir .

Halihazırda birçok cevap olduğunu biliyorum, ancak birçoğu sorunu aşırı derecede karmaşıklaştırıyor gibi görünüyor. İşte bir anahtarın tüm örneklerini kaldırmanın basit, özyinelemeli bir yolu - dizin bulunana kadar kendini çağırır. Evet, yalnızca tarayıcılarda çalışır indexOf, ancak basittir ve kolayca çoklu doldurulabilir.

Bağımsız işlev

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

    if(index === -1) return;

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

Prototip yöntemi

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

    if(index === -1) return;

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

Öğenin birden çok örneği varsa, dizinleri vidalamamak için geriye doğru bir döngü yapabilirsiniz.

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

Canlı Demo