79 Soru: Belirli bir öğeyi JavaScript'teki bir diziden nasıl kaldırırım?

tarafından oluşturulan soru Thu, Feb 14, 2019 12:00 AM

Bir dizi Numaram var ve ona öğeler eklemek için .push() yöntemini kullanıyorum.

Belirli bir öğeyi diziden kaldırmanın basit bir yolu var mı? array.remove(number); gibi bir şeyin eşdeğeri.

Çekirdek JavaScript kullanmalıyım - hayır çerçevelere izin verilir.

    
7214
  1. < IE9 ( sigh ) desteklemeniz gerekirse, bu SO sorusu .
    2013-09-13 07: 48: 49Z
  2. (lodash) array = ['a', 'b', 'c']; _.pull (array, 'a') //array = > ['milattan önce']; Ayrıca bkz. stackoverflow.com/questions/5767325/…
    2015-08-25 20: 28: 43Z
  3. filtre yöntemi istediğiniz şeyi yapabilir.
    2015-09-05 23: 43: 21Z
  4. Sil komutunu kullanabilirsiniz, ancak dizini yeniden düzenlemez, bu alanı 'undefined × 1' olarak ayarlar. Örneğin: var list = [1,2,3,4,5,6] - > listeyi sil [1] - > [1, tanımsız × 1, 3, 4, 5, 6].
    2016-05-24 23: 26: 45Z
  5. İşte iki ana olasılığın performans karşılaştırması: jsben .ch /# /b4Ume
    2017-03-03 16: 46: 45Z
30 Yanıtlar                              30                         

Kaldırmak istediğiniz dizi öğesinin index’unu bulun, sonra bu dizini splice .

  

splice () yöntemi, bir dizinin içeriğini kaldırarak değiştirir.   mevcut öğeler ve /veya yeni öğeler ekleme.

 
var array = [2, 5, 9];
console.log(array)
var index = array.indexOf(5);
if (index > -1) {
  array.splice(index, 1);
}
// array = [2, 9]
console.log(array);

splice’un ikinci parametresi, kaldırılacak öğe sayısıdır. splice'un diziyi yerinde değiştirdiğini ve kaldırılan öğeleri içeren yeni bir dizi döndürdüğünü unutmayın.

    
10357
2019-02-17 00: 02: 23Z
  1. @ Peter, evet haklı olabilirsin. Bu makalede daha fazla açıklama ve uyumsuz tarayıcılar için bir geçici çözüm vardır: developer.mozilla. org /tr /JavaScript /Referans /Global_Objects /...
    2011-04-23 22: 28: 10Z
  2. Tehlikeli! Dinamik değerlerle çalışıyorsanız (diziye dinamik değerler ekleyip kaldırın) ve değer dizide mevcut değilse (dizin -1 olur) yukarıdaki kod dizinin son öğesini kaldırır.
    2013-09-06 16: 44: 17Z
  3. @ AlexandreWiechersVaz Elbette emri koruyor, eğer yapmasaydı kesinlikle değersiz olurdu
    2013-12-11 19: 18: 02Z
  4. IE tarayıcı desteği sorununu burada verilmiştir
    2014-06-08 10: 42: 27Z
  5. @ AdrianP. Boş dizideki array.indexOf(testValue) -1 olur ve bunun için test yapıyorsanız ekleme yoktur. Belki de cevap o zamandan beri değişmiştir.
    2015-01-19 15: 47: 21Z

array.remove(int)'un nasıl davranmasını beklediğinizi bilmiyorum. İstediğini düşünebildiğim üç olasılık var.

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

 
array.splice(i, 1);

number değerine sahip her öğeyi diziden kaldırmak istiyorsanız:

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

Öğeyi i dizininde artık yapmak istemiyorsanız, ancak diğer öğelerin dizinlerinin değişmesini istemiyorsanız:

 
delete array[i];
    
1077
2018-12-18 17: 42: 12Z
  1. delete, bir öğeyi diziden kaldırmanın doğru yolu değil!
    2013-01-27 15: 30: 48Z
  2. @ FelixKling array.hasOwnProperty(i)'un false döndürmesini ve bu konumdaki öğenin undefined döndürmesini sağlamak için çalışır. Ancak, bunun yapmak istediğiniz çok yaygın bir şey olmadığını itiraf edeceğim.
    2013-01-27 15: 36: 52Z
  3. delete, dizinin uzunluğunu güncellemeyecek, öğeyi gerçekten silmeyecek, yalnızca undefined özel değeriyle değiştirecektir.
    2013-02-17 03: 44: 59Z
  4. @ diosney Öğeyi gerçekten silmediğini söylediğinizde ne demek istediğinizi bilmiyorum. Ayrıca, bu dizindeki değerin undefined ile değiştirilmesinden daha fazlasını yapar: hem dizini hem de değeri diziden kaldırır, yani delete array[0], "0" in array'dan sonra false döndürür.
    2013-04-15 19: 13: 42Z
  5. delete, adlandırılmış özelliklerle ilgileniyorsanız iyi bir mekanizmadır var array=[];array['red']=1;array['green']=2;array['blue']=3;delete array['green'];
    2014-10-21 23: 00: 59Z

2016 ekim ayında düzenlenmiştir

Bu kod örneğinde, istenmeyen öğeleri diziden kaldırmak için "array.filter (...)" işlevini kullanıyorum, bu işlev orijinal diziyi değiştirmiyor ve yenisini oluşturuyor. Tarayıcınız bu işlevi desteklemiyorsa (örneğin, sürüm 9'dan önceki IE veya sürüm 1.5'ten önceki Firefox), Mozilla'dan gelen filtre polyfilli .

Öğeyi kaldırma (ECMA-262 Sürüm 5 kodu aka 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 ]

Öğeyi kaldırma (ES2015 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İ ES2015 "() = > {}" ok işlevi sözdizimi IE’de, 45 sürümden önce Chrome’dan, 22 sürümden önce Firefox’tan, 10 sürümden önce Safari’den desteklenmez. ES2015 sözdizimini eski tarayıcılarda kullanmak için BabelJS

'i kullanabilirsiniz.

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

Bu yöntemin ek bir avantajı, birden fazla öğ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 IE’de, 47 sürümden önce Chrome’da, 43 sürümden önce Firefox’da, 9 sürümden önce Safari ve 14 sürümden önce Edge’de desteklenmez. burada Mozilla’dan gelen polyfill

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

"Bu Bağlayıcı Sözdizimi" teklifi kabul edilirse Bunu yapabilmek için:

 
// 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'te kendin dene :)

Referans

906
2019-06-23 08: 16: 58Z
  1. ancak bazen öğeyi orijinal diziden (değiştirilemez) kaldırmak istiyoruz, örneğin Açısal 2 * ngFor yönergesinde kullanılan dizi
    2017-02-08 14: 06: 04Z
  2. Kabul edilen çözümden daha iyi çünkü bir eşleşmenin yalnızca bir kez meydana geldiğini varsaymıyor ve değişmezlik tercih ediliyor
    2017-03-06 16: 46: 21Z
  3. filter, büyük bir dizi için daha yavaş olmalı?
    2017-07-17 01: 02: 59Z
  4. Örneklerinizde aynı değişkenin atamasını kullandıysanız, belirtilen değişmezliğin amacı nedir? :)
    2017-08-19 11: 36: 51Z
  5. Bu harika bir cevap. Ekleme, filtreleme değil mutasyon için özel bir işlevdir. filter daha yavaş performansa sahip olabilir, ancak daha güvenli ve daha iyi koddur. Ayrıca, lambda'da ikinci bir argüman belirleyerek dizine göre filtreleyebilirsiniz: arr.filter((x,i)=>i!==2)
    2018-08-15 12: 50: 44Z

Boş bir yer tutmak isteyip istemediğinize bağlı olarak değişir.

Boş bir yuva istiyorsanız, silme işlemi tamamdır:

 
delete array[ index ];

Yapmazsanız, splice yöntemini kullanmalısınız:

 
array.splice( index, 1 );

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

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

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

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

    
401
2014-07-10 22: 43: 25Z
  1. var value'un kaldırılan değeri değil, kaldırılan değeri içeren bir diziyi saklayacağına dikkat etmek önemlidir.
    2013-07-10 09: 55: 45Z
  2. delete, bir öğeyi diziden kaldırmanın doğru yolu değil !!
    2014-07-04 14: 20: 43Z
  3. Eğer"bir slotu boşaltmak" istiyorsanız array[index] = undefined;'u kullanın. delete kullanılması optimizasyonu imha edecektir.
    2014-08-11 16: 40: 29Z
  4. @ Jakub çok iyi bir yorum çünkü çok zaman kaybettim ve uygulama kodumun bir şekilde kırıldığını düşündüm ...
    2014-12-14 19: 14: 58Z
  5. indexOf'tan neler aldığınızı açıklayan son paragraf gerçekten yardımcı oldu
    2019-02-05 16: 31: 34Z

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

TÜM örnekleri bir diziden kaldırın

 
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 endeksler ve uzunluk değişeceğinden) ve bulunursa öğeyi kaldırır. Tüm tarayıcılarda çalışır.

    
255
2018-06-08 08: 26: 59Z
  1. @, döngünün i = arr.length -1 veya i--'dan başlaması ile maksimum dizinin aynı olması nedeniyle olmamasını sağlar. arr.length, i için yalnızca bir başlangıç ​​değeridir. i--, 0 (sahte bir değer) olana kadar her zaman truthy olur (ve her döngü işleminde 1 azalır) ve döngü durur.
    2014-01-29 20: 06: 34Z
  2. İkinci işlev oldukça yetersiz. Her yinelemede "indexOf", dizinin başından itibaren aramaya başlayacaktır.
    2015-02-25 13: 32: 12Z
  3. @ AmberdeBlack, 1'den fazla öğesinin olduğu bir koleksiyonda, filtresini çağırmak çok daha iyidir yöntem yerine arr.filter(function (el) { return el !== item }), diziyi birden çok kez değiştirmek zorunda kalmamak için kullanılır. Bu biraz daha fazla bellek tüketir, ancak yapılması gereken daha az iş olduğundan, daha verimli çalışır.
    2015-03-30 09: 37: 04Z
  4. @ AlJey, yalnızca IE9 + adresinden kullanılabilir. İşe yaramayacak hala bir şans var.
    2015-03-30 16: 23: 56Z
  5. Bu cevap benim için çalıştı, çünkü birkaç öğenin kaldırılması gerekiyordu, ancak belirli bir sırada değil. Burada for döngüsünün geriye doğru ilerlemesi, dizideki öğelerin mükemmel bir şekilde kaldırılmasını sağlar.
    2015-07-14 23: 39: 58Z

İki ana yaklaşım vardır:

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

  2. sil : delete anArray[index];

Bir dizi için delete kullanırken dikkatli olun. Nesnelerin özniteliklerini silmek için iyidir ancak diziler için bu kadar iyi değildir. Diziler için splice kullanmak daha iyidir.

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

Ayrıca, sil kullandıktan sonra indeks numaralarında delikler olmasını bekleyebilirsiniz; silme işleminden önce olduğu gibi 1,3,4,8,9,11 endeks ve uzunluğa sahip olabilirsiniz. Bu durumda, dizinlenmiş artık for döngü, dizinler artık sıralı olmadığından çökebilir.

Bazı nedenlerden dolayı delete kullanmaya zorlandıysanız, for each , diziler arasında dolaşmanız gerektiğinde döngüler. Aslına bakarsanız, mümkünse her zaman döngüler için indekslenmiş kullanmaktan kaçının. Bu şekilde kod daha sağlam ve p'ye daha az eğilimli olacaktır.indeksli roketler.

    
150
2017-10-03 12: 04: 03Z
 
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)
    
125
2017-09-25 04: 56: 18Z
  1. Bu yaklaşımın büyük bir hayranı değilim. Farklı kitaplıklar veya çerçeveler kullanırsanız, birbirleriyle çakışabilirler.
    2011-04-23 22: 30: 15Z
  2. Bu da işe yaradı, sonunda indexOf işlevine gitmeyi seçtim. Yardımın için teşekkürler!
    2011-04-23 22: 35: 58Z
  3. 2012-07-09 22: 10: 08Z
  4. Bir dizide for in yapıyorsanız, zaten bir sorununuz var.
    2014-05-14 13: 01: 58Z
  5. dizilerde for in yaparsanız, zaten daha büyük sorunlarınız vardır.
    2018-08-01 06: 20: 21Z

indexOf veya splice'u kullanmaya gerek yoktur. Ancak, yalnızca bir elemanın bir oluşumunu 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;
}

indexOf ve splice'u kullanın (indeks):

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

Yalnızca splice (ekleme) kullanın:

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

1000 öğeli dizi için düğümlerde çalışma zamanları (ortalama 10000 çalıştırma):

dizininin taşınmasından yaklaşık 10 kat daha yavaştır. Aramayı ekleme 'de indexOf’a kaldırarak iyileştirilse bile, hareket et ' den çok daha kötü performans gösterir.

 
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
    
92
2015-09-11 12: 47: 59Z
  1. Burada sunulan 'move' yöntemi tüm tarayıcılarda çalışmalı ve fazladan bir dizi oluşturmaktan kaçınıyor gibi görünüyor; Buradaki diğer çözümlerin çoğu bu sorunlardan birine veya ikisine sahiptir. Sanırım bu, "hoş" görünmese bile, daha fazla oyu hakediyor.
    2015-07-29 11: 50: 21Z

Yanıtlamak için çok yaşlı, ancak bir değer yerine bir yordama sağlayarak birine yardımcı olabilir.

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;
    }
};
    
62
2016-12-26 10: 57: 02Z
  1. -1 onayına ihtiyacınız olduğunu bilmiyorum (i > -1). Ayrıca, bu işlevlerin kaldırmadan ziyade filtreye benzer davrandığını düşünüyorum Row.id === 5 değerini geçerseniz, yalnızca id 5 içeren bir diziyle sonuçlanır, bu nedenle kaldırmanın tersini yapar. ES2015’te iyi görünür: var result = ArrayHelper.remove (myArray, row = > row.id === 5);
    2015-09-20 19: 42: 45Z
  2. @ WhatWouldBeCool bu işlev orijinal diziyi değiştirir ve sonucu yeni bir diziye kopyalamak yerine kaldırılan öğeyi döndürür
    2015-09-21 07: 21: 13Z

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öndermemdeki asıl sebep, 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çte 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ırmayı denerseniz:

 
myArray.remove(8);

8 elementli bir dizi ile bitirdiniz. Nedenini bilmiyorum ama John'un orijinal uygulamasının bu sorunu olmadığını onayladım.

    
58
2015-02-16 12: 51: 30Z
  1. Sadece neden Object.prototype.hasOwnProperty kullanmanın iyi bir fikir olduğu zor yoldan öğrendim ¬¬
    2015-04-11 04: 58: 05Z
Birden çok tarayıcıyla ilgili sorunları çözmek için

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

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

 
_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]
    
56
2017-05-21 11: 29: 54Z

filter 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, dizideki tüm öğeleri kaldırır ve ayrıca dilim ve indexOf birleşiminin ardından daha hızlı çalışır

    
55
2014-02-10 22: 06: 01Z
  1. Bunun daha hızlı olduğu konusunda bir kaynağınız var mı?
    2017-07-28 18: 21: 57Z
  2. Güzel bir çözüm. Ancak, işaret ettiğiniz gibi, ancak kel yapmak için önemliyse, 1'in tüm oluşumlarını kaldıracağından dilim ve indexOf ile aynı sonucu vermiyor.
    2017-07-28 18: 28: 36Z
  3. @ user3711421, çünkü sadece dilim ve indexOf "belirli bir öğeyi kaldırmak" istediğini yapmıyor. Öğeyi yalnızca bir kez kaldırır, bu, kaç taneniz olursa olsun belirli bir öğeyi kaldırır
    2017-07-28 20: 05: 09Z

Silinen konumların kaldırıldığı yeni bir dizi istiyorsanız, belirli bir öğeyi her zaman silebilir ve diziyi filtreleyebilirsiniz. Filtre yöntemini uygulamayan ancak uzun vadede tarayıcılar için dizi nesnesinin bir uzantısına ihtiyacı olabilir Yapmanız gereken tek şey bu kadar kolay:

 
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]'u göstermeli

    
46
2014-09-05 07: 59: 57Z

ES6'yı kullanabilirsiniz.

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

Çıktı:

 
["1", "2", "4", "5", "6"]
    
39
2016-11-19 08: 59: 00Z
  1. Bu cevap, orijinali doğrudan değiştirmek yerine orijinal dizinin bir kopyasını oluşturduğu için güzeldir.
    2017-03-16 15: 27: 40Z
  2. Not: Array.prototype.filter ECMAScript 5.1'dir (IE8 yok). daha özel çözümler için: stackoverflow.com/a/54390552/8958729
    2019-01-27 19: 45: 05Z

Bu kodu kontrol edin. Her ana 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 çağırın

 
remove_item(array,value);
    
36
2014-05-24 07: 02: 53Z
  1. @ RolandIllig for in-döngüsünün kullanımı ve betiğin daha önce durduğundan, sonucun doğrudan döngüden döndürülmesi dışında. Olumlu olanları makul;)
    2014-12-30 16: 13: 41Z
  2. Bu, küçük diziler için mükemmel bir yaklaşımdır. Her tarayıcıda çalışır, minimal ve sezgisel bir kod kullanır ve ekstra karmaşık çerçeveler, şimler veya polyfills olmadan.
    2016-08-21 23: 12: 41Z
  3. yckart’ın for( i = 0; i < arr.length; i++ )’un daha iyi bir yaklaşım olacağını yinelemeliyim, çünkü tarayıcının öğeleri depolamaya karar verirse (for in ile) kesin endeksleri korur. Bunu yapmak, ayrıca gerekirse bir değerin dizi dizinini almanızı sağlar.
    2016-08-21 23: 20: 39Z

Lodash'ı kullanabilirsiniz _.pull (mutate dizisi), _. pullAt (mutasyon dizisi) 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']
    
34
2015-08-25 21: 19: 16Z
  1. OP'nin istediği çekirdek JS değil, değil mi?
    2015-09-24 21: 01: 50Z
  2. @ some-descript olmayan kullanıcı Sen haklısın. Ancak benim gibi birçok kullanıcı buraya yalnızca OP için genel bir cevap aramaya gelmiyor.
    2015-10-01 03: 38: 30Z
  3. @ ChunYang Kesinlikle haklısınız. Zaten lodash kullanıyorum, neden sadece zaman kazandırıyorsa onu kullanmıyorsunuz.
    2018-06-08 21: 48: 30Z

Tamam, örneğin, aşağıdaki diziyi kullanıyorsunuz:

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

4 sayısını silmek istiyoruz, aşağıdaki kodu kolayca yapabilirsiniz:

 
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, Dizi içinde birkaç [5] ile birleştirmek yerine aşağıdaki diziyi görmeye ne dersiniz?

 
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 kullanmaktan daha kolay ve daha verimli bir yol var, bu nedenle aşağıdakine benzer bir süzgeç kullanan bir işlev yazdık:

 
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 Underscore gibi, bunu yapmanıza yardımcı olan üçüncü taraf kütüphaneleri de vardır; daha fazla bilgi için lodash _.pull, _.pullAt veya _.without.

'e bakın.     
32
2018-03-26 00: 23: 30Z
  1. Küçük bir yazım hatası var. Lütfen düzeltin. this.splice(num.indexOf(x), 1); = > this.splice(this.indexOf(x), 1);
    2017-05-11 12: 28: 30Z
  2. Lütfen JavaScript'teki yerleşik bileşenleri (Array.prototype işlevlerine ekleyin) eklemeyin. Bu yaygın olarak kötü bir uygulama olarak kabul edilir.
    2017-05-24 03: 29: 54Z
  3. Dünyada yapılacak en iyi şey olmadığını kabul ediyorum, ancak bu durumda onu fonksiyona nasıl bırakabilirsiniz?
    2017-05-25 08: 45: 07Z
  4. Dizini kontrol etmelisiniz. Eğer index = -1 ise, splice (-1,1) son elemanı silecektir
    2018-01-26 09: 38: 10Z

Burada, bir öğeyi JavaScript kullanarak bir diziden kaldırmak için birkaç yol vardır.

Açıklanan tüm yöntemler orijinal diziyi değiştirmez ve yeni bir tane oluşturun.

Bir öğenin indeksini biliyorsanız

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

Bir yöntem slice() kullanmaktır:

 
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. Basitçe baştan kaldırmak istediğimiz dizine yeni bir dizi yaratırız ve dizinin sonuna kadar çıkardığımız diziyi izleyen ilk konumdan başka bir diziyi birleştiririz.

Değeri biliyorsanız

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

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

console.log(filteredItems)

Bu, 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 ES6 kodunu eski tarayıcılara daha sindirilebilir hale getirmek için ES5'e geri döndürebilirsiniz, ancak kodunuzu modern JavaScript ile yazabilirsiniz.

Birden çok öğeyi kaldırma

Ya tek bir öğe yerine, çok sayıda öğeyi kaldırmak istiyorsanız?

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

Dizine Göre

Yalnızca 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ğerine göre

Geri arama işlevinin içine dahil etmek için arama yapabilirsiniz:

 
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() (slice() ile karıştırılmaması gereken) orijinal diziyi değiştirir ve kaçınılması gerekir.

(başlangıçta https://flaviocopes.com/how-to adresinde yayınlanmıştır. -remove-et-den-dizi /)

    
29
2019-04-14 16: 39: 51Z
  1. Örneğinizde, (0, i-1) dizisi yerine items.slice(0, i).concat(items.slice(i+1, items.length)), (0, i) yerine (0, i-1) istediğinizi düşünüyorum çünkü 'end' öğesi dizi içinde bulunmuyor sonuç. Ayrıca, ikinci bölüm için i + 1 tamam ise, sınırları aşarsa boş bir dizi döndürür.
    2019-03-17 17: 02: 30Z
  2. Haklısın. Bunu bir süre önce blogumda düzelttim, ancak yanıtta hiçbir zaman değiştirmedim! Bana anlattığın için teşekkür ederim
    2019-04-14 16: 40: 33Z

JavaScript’te oldukça yeniyim ve bu işlevselliğe ihtiyacım vardı. Sadece şunu yazdım:

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

Sonra kullanmak istediğimde:

 
//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ı gereksinimleriniz olabilir, bu nedenle bunları kendi gereksinimlerine göre kolayca değiştirebilirsiniz. Umarım bu birine yardımcı olur.

    
27
2014-12-30 16: 17: 43Z
  1. Diziniz gerçekten uzunsa ve öğenin içinde birkaç örneği varsa, bu korkunç bir davranış sergileyecektir. Dizinin indexOf yöntemi her seferinde baştan başlar, bu nedenle maliyetiniz O (n ^ 2) olur.
    2019-05-24 18: 22: 30Z

ES6 ve amp; mutasyon olmadan: (Ekim 2016)

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

Sonra:

 
removeByIndex([33,22,11,44],1) //=> [33,11,44]
    
25
2016-10-07 19: 42: 51Z
  1. yukarı yukarı yukarı yukarı yukarı uuuuuuuuuuuuuup! bu daha güncel, bu N ° 1 cevap vermeli, N ° 20 cevap vermemelidir !!!
    2018-09-14 09: 28: 18Z

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


Buradaki bu boşluk sorununuzu çözecek ve ayrıca argümanın yerine tüm oluşumlarını silecek sadece 1 (veya belirli bir değer).

 
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]
    
23
2017-09-01 22: 41: 13Z

Dizide karmaşık nesneler varsa, filtreleri kullanabilirsiniz? $.İnArray veya array.splice'in kullanımı kolay değildir. Özellikle nesneler dizide belki sığsa.

Örn. Kimlik alanı olan 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;
});
    
22
2015-11-10 04: 20: 21Z
  1. Bu şekilde yapmayı seviyorum. Bir ok işlevini kullanarak tek astar olabilir. Performansı merak ediyorum. Ayrıca, bu dizinin değiştirildiği hiçbir şeye değmez. eski dizi 'ye referansta olan herhangi bir kod değişikliği farketmeyecektir.
    2016-07-29 08: 50: 36Z

ES6 'a göre cevap vermek istiyorum. Diyelim ki, aşağıdakine benzer bir diziniz var:

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

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

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

Ancak, 3 gibi özel bir öğeyi silmek istiyorsanız ve dizininin aşağıdakini de bilmiyorsanız:

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

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

    
21
2019-02-24 12: 06: 30Z
  1. son seçenek boş bir dizi döndürecektir
    2018-12-18 09: 24: 36Z
  2. @ Dejan.S, şaşırdım, dizininiz nedir ve dizininizden çıkarmak istemediğiniz şey nedir?
    2018-12-18 09: 35: 11Z
  3. Benim kötüydü, düzenli işlev kullandım ve açıkça bir ret yapmak zorunda kaldımurn bildirimi. Bunun için üzgünüm :)
    2018-12-18 09: 39: 43Z
  4. @ Dejan.S, hata gibi bazı hataların cevabını düzenledim ve bir ipucu ekledim, eğer beni reddederseniz, şimdi oy verebilirsiniz.
    2018-12-18 11: 50: 51Z

Dizininizi asla dizininizde değiştirmemelisiniz. Bunun nedeni işlevsel programlama şablonuna karşı olmasıdır. Yapabileceğiniz şey, es6 yöntem filter kullanarak verilerini değiştirmek istediğiniz diziye gönderme yapmadan yeni bir dizi oluşturmak;

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

5'u diziden kaldırmak istediğinizi varsayalım, bunu basitçe yapabilirsiniz.

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

Bu, kaldırmak istediğiniz değer olmadan size yeni bir dizi verecektir. Yani sonuç

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

Daha fazla anlamak için MDN belgelerini Array.filter https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

    
19
2017-12-26 19: 32: 06Z

Daha modern, ECMAScript 2015 (eskiden Harmony veya ES 6 olarak bilinir) yaklaşımı. Verilen:

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

Ardından:

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

Verim:

 
[1, 2, 4]

Babel ve bir polyfill kullanabilirsiniz Bunun tarayıcılar arasında iyi desteklendiğinden emin olmak için hizmet .

    
18
2016-06-25 13: 01: 46Z
  1. .filter öğesinin, öğeyi aynı diziden kaldırmakla tamamen aynı olmayan yeni bir dizi döndürdüğünü unutmayın. Bu yaklaşımın yararı, dizi yöntemlerini birlikte zincirleyebilmenizdir. örneğin: [1,2,3].filter(n => n%2).map(n => n*n) === [ 1, 9 ]
    2016-05-06 18: 58: 02Z
  2. Harika, dizide 600k öğelerim varsa ve ilk 50k'yi kaldırmak istiyorsanız, bu yavaşlığı hayal edebiliyor musunuz? Bu bir çözüm değildir, sadece elemanları kaldıran ve hiçbir şey döndürmeyen bir işleve ihtiyaç vardır.
    2016-05-30 15: 11: 17Z
  3. @ Seraph Bunun için, muhtemelen splice veya slice kullanmak isteyebilirsiniz.
    2016-05-31 22: 04: 28Z
  4. @ bjfletcher Daha da iyisi, kaldırma işlemi sırasında, sadece 50K öğelerini ayırın ve bir yere atın. (dilim 550K öğelerinde, ancak bunları pencereden atmadan).
    2016-05-31 23: 06: 07Z
  5. bjfletcher'ın cevabını tercih ederim, items= items.filter(x=>x!=3) kadar kısa olabilir. Ayrıca, OP büyük veri seti için herhangi bir gereklilik belirtmedi.
    2016-08-27 01: 55: 25Z

Bildiğim kadarıyla çok fazla cevap olduğunu biliyorum, ancak birçoğu sorunu çok karmaşık hale getiriyor. Anahtarın tüm örneklerini kaldırmanın basit, özyinelemeli yolu - dizin bulunana kadar kendini çağırır. Evet, yalnızca indexOf’lu tarayıcılarda çalışır, ancak çok basittir ve kolayca polyfilled edilebilir.

Tek başına işlevi

 
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);
}
    
16
2014-02-19 22: 20: 53Z
  1. Sadece bir not, bu yöntemle 1 uyarı yığılma taşması potansiyelidir. Ubüyük dizilerle çalışıyorsanız, bir sorun yaşamamalısınız.
    2015-09-08 05: 57: 20Z

Öğenin birden fazla örneği varsa, dizinleri bozmadığınızdan emin olmak için bir geri 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);
}

Live Demo

    
15
2013-08-12 17: 56: 39Z

Bir diziden kaldırmak için başka iyi bir çözümüm var:

 
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 /tr-tR /docs /Web /JavaScript /Referans /Global_Objects /Dizi /filtre

    
15
2018-06-05 15: 51: 34Z

1 - 9 diziniz var ve aşağıdaki kodu 5 kullanımdan kaldırmak istiyorsunuz.

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

Örneğin, birden fazla değer elde etmek istiyorsanız: - 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);

Dizideki dizi değerini kaldırmak istiyorsanız: - [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ıyı içeriyor bağlantı

    
15
2018-08-21 04: 21: 54Z

Genel olarak doğru olan ve önerilen en iyi uygulamaları göz önünde bulunduran (özellikle Array.prototype'yi doğrudan kullanmadan) dikkate alan tüm cevaplara dayanarak, aşağıdaki kodu buldum:

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

Yukarıdaki işlevi inceleyerek, iyi çalışmasına rağmen, performansta bir iyileşme olabileceğini fark ettim. Ayrıca ES5 yerine ES6 kullanımı çok daha iyi bir yaklaşımdır. Bu amaçla, bu geliştirilmiş koddur:

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

Nasıl kullanılır:

 
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)

Şu anda Array için birkaç çözümü kıyasladığım ve çalıştırma süresini karşılaştırdığım bir blog yazısı yazıyorum. Gönderiyi bitirdikten sonra bu cevabı bağlantı ile güncelleyeceğim. Sadece size bildirmek için yukarıdakileri hiçbir şey yapmadan, web tarayıcısı Map'u destekliyorsa, bu bir çözümleme yapmaz. Array.prototype.indexOf veya Array.prototype.includes'daki exlcudeValues ​​öğelerini kaydırırken Map veya Object kullanmıyorum, sorgulamayı daha hızlı yapar!

    
15
2018-11-19 23: 02: 58Z
kaynak yerleştirildi İşte