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

Nasıl davranacağını array.remove(int) bekliyoruz bilmiyorum. İstediğini düşünebildiğim üç olasılık var.

Dizideki bir öğeyi i dizininde kaldırmak için:

array.splice(i, 1);

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

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

Sadece öğeyi i dizininde yapmak istiyorsanız, artık mevcut değil, diğer öğelerin dizinlerinin değişmesini istemezsiniz:

delete array[i];

2016 ekim tarihinde düzenlendi

• Basit, sezgisel ve açık şekilde yapın ( https://en.wikipedia.org/wiki/Occam%27s_razor )
• Değişmez mi (orijinal dizi değişmeden kalır)
• Tarayıcınız desteklemiyorsa standart JS işlevleriyle yapın - use polyfill

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 önce IE veya sürüm 1.5'ten önceki Firefox), //Mozilla 'dan gelen filtre polyfillini kullanmayı düşünün.

Öğeyi kaldırma (ECMA-262 Edition 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 ]

IMPORTANT ES2015 "() => {}" ok işlevi sözdizimi IE 'de, 45 sürümden önceki Chrome, 22 sürümden önceki Firefox, 10 sürümden önceki Safari'de desteklenmez. ES2015 sözdizimini eski tarayıcılarda kullanmak için BabelJS

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 ]

IMPORTANT "array.includes (...)" işlevi IE 'de, 47 sürümünden önce Chrome, 43 sürümden önce Firefox, 9 sürümden önce Safari ve 14 sürümden önce Edge desteklenmez. here, Mozilla'dan

Birden fazla öğeyi kaldırma (Cutting-Edge deneysel JavaScript ES2018?)

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

• Dizi.prototype.includes
• Bu Bağlayıcı Sözdizimi Önerisi
• İşlevsel kompozisyon

Boş bir nokta 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, sadece döndürülen dizinin elemanını saklayabilirsiniz:

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

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

Maddenin indeksini bilmiyorsanız, onu almak için array.indexOf( item ) işlevini kullanabilirsiniz (bir öğeyi almak için if()'da veya hepsini almak için while()'da). array.indexOf( item ), bulunmazsa dizini veya -1 değerini döndürür.

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

Bir diziden TÜM örnekleri 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.

İki ana yaklaşım var:

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

2. delete: 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 uzunluk özelliğinin değerini güncellemez.

Ayrıca, silme işlemini kullandıktan sonra indeks numaralarında delikler bekleyebilirsiniz; silme işleminden önce olduğu gibi 1,3,4,8,9,11 endeks ve uzunluğa sahip olabilirsiniz. Bu durumda, indeksler artık sıralı olmadığından tüm indeksli for döngüleri çökecektir.

Herhangi bir nedenle delete kullanmaya zorlandıysanız, diziler arasında dolaşmanız gerektiğinde for each döngüler kullanmanız gerekir. Aslında, mümkünse her zaman döngüler için indekslenmiş 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)

indexOf veya splice kullanmaya gerek yoktur. Ancak, yalnızca bir elemanın bir oluşumunu kaldırmak istiyorsanız daha iyi sonuç verir. 

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 kullanın (indexof):

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

Yalnızca splice (ekleme) kullan:

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 koşu):

indexof, move öğesinden yaklaşık 10 kat daha yavaştır. Splice içindeki indexOf çağrısının kaldırılmasıyla iyileştirilse bile, move öğesinden ç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

Yanıt vermek 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;
    }
};

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ğıdaki gibi 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özüküyor, ama acı verici bir süreçte, bir dizideki ikinci-son elemanı çıkarmaya ç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.

Underscore.js , birden fazla 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.

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

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

filter method ile 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 daha sonra dilim ve indexOf bileşimlerinden daha hızlı çalışır

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

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] görüntülemeli

ES6'yı kullanabilirsiniz. 

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

Çıktı : 

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

Bu kodu kontrol et. Her ana tarayıcıda içinde ç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 fonksiyonu çağır 

remove_item(array,value);

Lodash _.pull (mutate dizisi), _.pullAt (mutate dizisi) veya _.ww (dizini mutasyon yapmaz) kullanabilirsiniz, 

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

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

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

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

Ancak, Dizi içindeki birkaç [5] tuşla bunun yerine aşağıdaki diziyi kullanıyorsanız?

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

Hepsini kontrol etmek için bir döngüye ihtiyacımız var, ancak daha kolay ve daha verimli bir şekilde yerleşik JavaScript işlevlerini kullanıyor, bu nedenle aşağıdaki gibi bir süzgeç 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 var.

JavaScript konusunda 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 . ["İtem1", "item1"]

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

ES6 ve 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]

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üzenli uygulamalar sunar.

Buradaki Bu Gist probleminizi çözecek ve ayrıca sadece 1 (veya belirli bir değer) yerine argümanın 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]

Dizide karmaşık nesneler varsa, filtreleri kullanabilirsiniz? $ .İnArray veya array.splice'in kullanımı kolay olmadığı durumlarda. Özellikle nesnelerin dizide sığ olması durumunda.

Örneğin. 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;
});

Bir öğeyi JavaScript kullanarak bir diziden kaldırmak için işte birkaç yol var.

Tüm tanımlanmış orijinal diziyi değiştirmez, ve bunun yerine yenisini yaratın.

Bir öğenin indeksini biliyorsanız

Diyelim ki bir diziniz var 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-1).concat(items.slice(i, 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.

Eğer değeri biliyorsan

Bu durumda, iyi bir seçenek daha fazla bildirimsel yaklaşım sunan filter() işlevini 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 fonksiyonlarını 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)

ya da Babel'i kullanabilir ve ES6 kodunu eski tarayıcılara daha sindirilebilir hale getirmek için ES5'e geri döndürebilirsiniz, ancak kodunuza modern JavaScript yazabilirsiniz.

Birden çok öğeyi kaldırma

Tek bir öğe yerine birçok öğeyi kaldırmak istiyorsanız ne yapmalıyım?

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ğere 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ılmamalıdır) orijinal diziyi değiştirir ve bundan kaçınılmalıdır.

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

Dizinizi asla diziniz değiştirmemelisiniz. Bunun nedeni işlevsel programlama şablonuna karşı olmasıdır. Yapabileceğiniz şey, es6 yöntemini kullanarak verilerini değiştirmek istediğiniz diziye referans vermeden yeni bir dizi oluşturmak filter;

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

Dizideki 5 öğesini kaldırmak istediğinizi varsayalım.

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

Bu size kaldırmak istediğiniz değeri olmayan 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

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

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

Sonra:

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

Verim: 

[1, 2, 4]

Tarayıcılarda iyi desteklendiğinden emin olmak için Babel ve a polyfill hizmet kullanabilirsiniz.

Biliyorum zaten çok fazla cevap var ama birçoğu problemi zorlaştırıyor gibi görünüyor. Anahtarın tüm örneklerini kaldırmanın basit, özyinelemeli yolu - dizin bulunana kadar kendini çağırır. Evet, yalnızca indexOf olan tarayıcılarda çalışır, ancak basittir ve kolayca polyfilled edilebilir.

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

Bir diziden kaldırmak için başka iyi bir çözü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/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

Öğenin birden fazla örneği varsa, dizinleri bozmamaya dikkat etmek için geri 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

Esas olarak doğru olan ve önerilen en iyi uygulamaları göz önünde bulunduran (özellikle Array.prototype'yi doğrudan kullanmamak üzere) 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 gözden geçirerek, 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. Bu yazıyı bitirdikten sonra bu cevabı bağlantı ile güncelleyeceğim. Sadece size bildirmek için, yukarıdakileri lodash'lar olmadan karşılaştırdım ve tarayıcının Map özelliğini desteklemesi durumunda, lodash! ExlcudeValues ​​öğelerini Map veya Object içine kaydırırken Array.prototype.indexOf veya Array.prototype.includes kullanmıyorum, sorgulamayı daha hızlı yapar!

1'den 9'a kadar diziniz var ve aşağıdaki 5 kullanımı 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çerir link

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

Dizine Göre Kaldır

Dizinin bir elemanı olmadan dizinin bir kopyasını döndüren işlev.

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

Değerine Göre Kaldır

Değer olmadan bir dizinin kopyasını döndüren işlev.

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

ES6'ye dayanarak 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 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 çağırma için bir ok işlevi kullanın.

Yeni dizi oluştur:

var my_array = new Array();

Bu diziye eleman ekle:

my_array.Push("element1");

indexOf işlevi (bulunamadığında index veya -1 değerini döndürür):

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

Bu elementin indeksini kontrol et (firefox ve IE8 + ile test edildi):

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

Dizinde bulunan 1 elemanı diziden kaldır

my_array.splice(index, 1);

Ayrıca, Array öğesinden bir öğeyi çıkarmak zorunda kaldığım durumda da koştum. .indexOfIE* içinde çalışmıyordu, bu yüzden benim jQuery.inArray() çözümüm çalışıyor.

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

2017-05-08

Verilen cevapların çoğu kesin karşılaştırma için çalışır, yani her iki nesne de bellekteki aynı nesneye başvurur (veya ilkel türlerdir); Örneğin, bir sunucuya çağrı yaparsanız ve alınan bir nesneyi yerel bir nesneye karşı kontrol etmek istiyorsanız.

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

ValueAreEqual için alternatif/daha hızlı uygulamalar var, ancak bu işi yapıyor. Kontrol etmek için belirli bir alanınız varsa (örneğin, bazı UUID'leri yerel UUID'ye karşı alınmışsa) özel bir karşılaştırıcı kullanabilirsiniz.

Ayrıca bunun işlevsel bir işlem olduğunu unutmayın, yani orijinal diziyi değiştirmez.

JavaScript talimatlarının çoğunun işlevsel programlama için iyi düşünülmediğini düşünüyorum. Ekleme, silinen öğeyi, azaltılmış diziye ihtiyaç duyduğunuz çoğu zaman döndürür. Bu kötü.

Özyinelemeli bir çağrı yaptığınızı ve muhtemelen mevcut dizine alınmış öğenin olmadığı bir diziden daha az öğeyle geçmek zorunda olduğunuzu düşünün. Ya da başka bir özyinelemeli arama yaptığınızı ve bir öğe itti ile bir dizi geçmek zorunda olduğunu hayal edin.

Bu iki durumda da myRecursiveFunction(myArr.Push(c)) veya myRecursiveFunction(myArr.splice(i,1)) işlevini yapamazsınız. İlk salak aslında dizinin uzunluğunu geçecek ve ikinci salak parametre olarak silinen elemanı geçecek.

Peki gerçekte ne yapıyorum ... Bir dizi öğesini silmek ve elde edilen sonucu bir işleve aynı anda parametre olarak iletmek için aşağıdaki gibi yapıyorum.

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

Push'a gelince bu çok saçma ... Sevdiğim,

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

Uygun bir işlevsel dilde, üzerine çağrılan nesneyi mutasyona uğratan bir yöntemin sonuç olarak nesneye bir referans vermesi gerektiğine inanıyorum.

CoffeeScript : içinde

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

JQuery's InArray öğesini kullanın:

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

Not: eleman bulunmazsa, inArray -1 döndürür.

Vanilya JavaScript (ES5.1) - yerinde baskı

Tarayıcı desteği: Internet Explorer 9 veya üstü ( ayrıntılı tarayıcı desteği )

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

Vanilya JavaScript (ES5.1) - değiştirilemez baskı

Tarayıcı desteği: yerinde Vanilya JavaScript ile aynı

/**
 * 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 - değiştirilemez baskı

Tarayıcı desteği: Chrome 46, Edge 12, Firefox 16, Opera 37, Safari 8 ( ayrıntılı tarayıcı desteği )

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

Orijinal diziyi değiştirmeden, i indeksindeki öğeyi kaldırın:

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

Eklentinin bu sürümünü seviyorum, bir öğeyi $.inArray kullanarak değerini kaldırarak

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

array'nizde varsa splice- item ve array öğelerinin her ikisini de yineleyebilirsiniz.

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

Dizideki istenen bir öğeyi daha sonra Array.prototype üzerinde yineleme yaparken hatalara yol açmadan kaldırmak için Object.defineProperty aracılığıyla for .. in .. üzerinde bir polyfill oluşturdum.

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

Bir tamsayı değerinin kaldırılması

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

Bir dize değerinin kaldırılması

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

Bir boole değerini kaldırma

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

Dizinin içindeki bir nesneyi bu Array.prototype.remove yöntemi ile kaldırmak da mümkündür. Sadece kaldırmak istediğiniz Objectkey => value belirtmeniz gerekir.

Bir nesne değerinin kaldırılması

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

Temel JavaScript dizisine oldukça verimli bir uzantı yaptım:

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

Benim çözümüme göre, saf JavaScript sayesinde bir dizideki bir veya daha fazla öğeyi kaldırabilirsiniz. Başka bir JavaScript kütüphanesine gerek yok.

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]

Orijinal diziyi değiştirmeden ES6'yı gevşek karşılaştırma kullanarak bir değeri kaldırın, 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;
}

Yine bir başka cevap, benim için daha basit ve 2018’de olduğumuz gibi (2019’a yakın), orijinal soruyu cevaplamak için size bunu (yakın) bir liner veriyorum:

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

Yararlı olan şey, köri ifadesinde kullanabilmenizdir:

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

Yukarıdaki cevapların çoğu soruyu cevaplarken, slice() yönteminin neden kullanılmadığı yeterince açık değildir. Evet, filter(), değişmezlik kriterlerini karşılar, ancak aşağıdaki daha kısa eşdeğerini yapmaya ne dersiniz:

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

Ve şimdi ikinci elemanı diziden kaldırmamız gerektiğini söyleyelim, basitçe yapabiliriz: const newArray = myArray.slice(0,1).concat(myArray.slice(2,4));// [1,3,4]

Bir diziden bir öğeyi silmenin bu yolu, basit ve değişmez doğası nedeniyle bugün toplulukta şiddetle teşvik edilmektedir. Genel olarak, mutasyona neden olan yöntemlerden kaçınılmalıdır. Örneğin, Push() ile concat() ve splice() ile slice() değiştirmeniz istenir 

Kullanım 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>

Bir diziden belirli bir elemanın/dizginin çıkarılması tek bir linerda yapılabilir: Hala bu tür bir problem için elde edebileceğiniz en zarif liner olduğunu düşünüyorum: 

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

'ArArray', belirli bir şeyi kaldırmak istediğiniz dizidir.

Bir dizi öğesini kaldıran kodumu yayınla ve dizi uzunluğunu da azalt.

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

Burada birçok fantastik cevap var, ama benim için en çok işe yarayan şey, elemanımı diziden tamamen çıkarmak değil, değerini null olarak ayarlamaktı. Bu, sahip olduğum çoğu durumda işe yarıyor ve iyi bir çözüm çünkü değişken daha sonra kullanacağım ve istemeyeceğim, şimdilik boş. Ayrıca, bu yaklaşım tamamen tarayıcılar arası uyumludur.

array.key = null;

Son olay veya tüm oluşumları mı yoksa ilk oluşumunu kaldır 

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

veya

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

Yinelenen sayıları veya dizeleri kaldırılmış yeni bir dizi döndürecek bir yöntemi çoğaltmak isteyen herkes için, bu mevcut cevaplardan bir araya getirilmiştir:

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

Bir işlev yaptım 

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

Ve böyle kullanılır.

pop(valuetoremove,myarray);

Şerefe!

Çok saf uygulama şu şekilde olacaktır:

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

İşlevden, Array.prototype.Push() gibi diğer yöntemlere uymak için dizinin uzunluğunu döndürüyorum.

Bu sorunu kendim yaşadım (diziyi değiştirmenin kabul edilebilir olduğu bir durumda) ve basit bir şekilde çözdüm:

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

Yukarıdaki snippet'e bir miktar bağlam vermek için:

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

            this.items = filteredItems;
        }
    };

Bu çözüm hem referans hem de değer kalemleriyle birlikte çalışmalıdır. Hepsi, bu çözümün uygulanabilir olup olmadığı konusunda orijinal diziye bir referans tutmanız gerekip gerekmediğine bağlıdır. 

Genellikle, filtre işleviyle yeni bir dizi oluşturmak daha iyidir.

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

Bu aynı zamanda okunabilirliği de arttırır. Ben bir dilim hayranı değilim, ancak bazen bunun için gitmeniz gerektiğini bilmesine rağmen.

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

Array.findindex kullanarak, kod satırı sayısını azaltabiliriz.

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;

Bu çözüm bir girdi dizisi alır ve kaldırılacak değer için girdiyi arar. Bu, giriş dizisinin tamamı boyunca dönecek ve sonuç, belirli bir dizini kaldıran ikinci bir dizi tamsayıları olacaktır. Tamsayı dizisi daha sonra tekrar girdi dizisine kopyalanır. 

Sorunuz, emrin mi yoksa farklı değerlerin bir gereklilik mi olduğunu göstermedi.

Siparişiniz umrunda değilse ve aynı değerin konteynerde bir defadan fazla olmaması durumunda, bir Set kullanın. Daha hızlı ve daha özlü olacak. 

var aSet = new Set();

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

aSet.delete(2);

İndeks ve ekleme ile değerin kaldırılması!

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

öğeyi sondan sil 

arrName.pop();

öğeyi ilk sil 

arrName.shift();

ortadan sil

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

Ex: arrName.splice(1,1);

sondan bir öğe sil

arrName.splice(-1);

Dizi indeks numarası kullanarak sil

 delete arrName[1];

Ne ayıp, bir tamsayı dizisi var, anahtarların bu tamsayıların dize denkliği olduğu bir nesne değil.

Bu cevapların çoğuna baktım ve hepsinin görebildiğim kadarıyla "kaba kuvvet" kullandıkları görülüyor. Her birini incelemedim, bu olmadıysa özür dilerim. Ufacık bir dizi için bu iyi, ama içinde binlerce tam sayı varsa?

Hatalıysam beni düzeltin, ancak bir key => value haritasında, bir JS nesnesinin olduğu gibi, anahtar alma mekanizmasının yüksek mühendislikle tasarlanmış ve optimize edilmiş olduğunu varsayabileceğini varsayamaz mıyız? (Bazı süper uzmanlar bana bunun böyle olmadığını söylerse NB, ES6'nın Harita sınıfını bunun yerine kesinlikle olacağını kullanmanızı önerebilirim).

Sadece, bazı durumlarda, en iyi çözümün dizinizi bir nesneye dönüştürmek olabileceğini, bunun da sorunun tabii ki tekrarlanan tamsayı değerlerine sahip olabileceğini öne sürüyorum. Bunları kovalara key => value girişlerinin "değer" kısmı olarak koymanızı öneririm. (Eğer yinelenen herhangi bir dizi öğeniz olmadığından eminseniz, bu çok daha basit olabilir: "anahtarlarla aynı" değerler ve sadece değiştirilen dizinizi geri almak için Object.values(...) işlevine gidin).

Yani yapabilirsin:

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

çıktı:

Nesne [<1 boş yuva>, Dizi 1 , Dizi [2], Dizi 1 , Dizi 1 , <5 boş yuvalar>, 46 daha fazla…]

o zaman tüm sayıları silmek kolaydır.

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

Hepsini silmeniz gerekmez: dizin değerleri görünüm sırasına göre kovalarına itilir, bu nedenle (örneğin):

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

sırasıyla ilk ve son oluşumu silecektir. Oluşma sıklığını kolayca sayabilir, bir kovanın içeriğini diğerine aktararak 55'lerin hepsini 3s ile değiştirebilirsiniz.

... değiştirilmiş int dizinizi geri almak biraz etkilenir: ancak her bir kova, (dize) tuşuyla gösterilen değerin dizinini (orijinal dizide) içerir. Bu kepçe değerlerinin her biri aynı zamanda benzersizdir: bu nedenle onları, "integer string key" den gelen (real) tamsayı ile değer olarak yeni bir nesnede anahtarlara dönüştürürsünüz ... sonra anahtarları sıralayın ve Object.values( ... ) işlevine gidin.

Bu kulağa çok ilgili geliyor ve zaman alıyor ... ama açıkçası her şey şartlara ve istenen kullanıma bağlı. Anladığım kadarıyla, JS'nin tüm sürümleri ve bağlamları yalnızca bir iş parçacığında çalışıyor ve iş parçacığı "bırakmıyor", bu nedenle "kaba kuvvet" yöntemiyle bazı korkunç tıkanıklıklar olabilir: indexOf ops , ancak çoklu tekrarlanan slicesplice ops.

_/Ek
Emin iseniz, kullanım durumunuz için bu çok fazla bir mühendisliktir, kesinlikle en basit "kaba kuvvet" yaklaşımıdır.

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

(evet, diğer cevaplar Array.prototype.filter... gördü)

Aşağıdaki yöntem, belirli bir değerin tüm girişlerini, yeni bir dizi oluşturmadan ve superfast olan yalnızca bir yinelemeyle diziden kaldırır. Ve eski Internet Explorer 5.5 tarayıcısında çalışıyor:

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>

Belirli bir öğeyi veya daha sonraki öğeleri kaldırmak için, Array.splice () method düzgün çalışır ..__ splice () yöntemi, mevcut öğeleri kaldırarak veya değiştirerek ve/veya yeni öğeler ekleyerek bir dizinin içeriğini değiştirir ve geri döner. kaldırılan öğeler.

Sözdizimi: _ ​​array.splice (index, deleteCount, item1, ....., itemX)

Burada index zorunludur ve dinlenme argümanları isteğe bağlıdır.

Örneğin:

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

Not:Array.splice () yöntemi, silmek istediğiniz öğenin dizinini biliyorsanız kullanılabilir. Ancak aşağıda belirtildiği gibi birkaç vaka daha olabilir.

1. Sadece son öğeyi silmek isterseniz, Array.pop () komutunu kullanabilirsiniz.

2. Sadece ilk elemanı silmek isterseniz, Array.shift () komutunu kullanabilirsiniz.

3. Öğeyi tek başına biliyor ancak öğenin konumunu (veya dizinini) bilmiyorsanız ve Array.filter () method'u kullanarak eşleşen tüm öğeleri silmek istiyorsanız:

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

VEYA splice () yöntemini kullanarak

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]

OR Diyelim ki del dizisini Arr dizisinden silmek istiyoruz:

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. Öğeyi tek başınıza biliyorsanız, ancak öğenin konumunu (veya dizinini) bilmiyorsanız ve splice () yöntemini kullanarak yalnızca ilk eşleşen öğeyi silmek istiyorsanız:

   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]
   

Internet Explorer'ın eski sürümlerini desteklemeniz gerekiyorsa, aşağıdaki çoklu dolguyu kullanmanızı öneririm (not: bu değil bir çerçevedir). Internet Explorer 6+, Firefox 1.5+, Chrome, Safari ve Opera için çalışan tüm modern dizi yöntemlerinin (JavaScript 1.8.5/ECMAScript 5 Array Extras)% 100 geriye dönük olarak değiştirilmesi.

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

JavaScript'in prototipleme özelliğini kullanarak dizi nesnelerinde remove () adlı bir yöntem tanımlayın.

Gereksinimlerinizi yerine getirmek için splice () yöntemini kullanın.

Lütfen aşağıdaki koda bakınız.

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 ]

Not: Aşağıda, Node.js REPL üzerinde yürütülen tam örnek kod verilmiştir. yöntemleri.

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

Teşekkürler.

Öğeyi diziden çıkarmak için ekleme, filtreleme ve silme

Her dizinin dizini vardır ve dizini ile belirli bir öğeyi silmek için yardımcı olur.

splice () yöntemi 

array.splice (index, 1 ); 1.

bu dizinden silmek istiyorum.

Yani tek eleman için 1 kullanırız. 

Silme yöntemi

dizi sil [index]

/ () yöntemi

Dizide tekrarlanan öğeyi silmek istiyorsanız diziyi filtreleyin.

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

elem, diziden kaldırmak istediğiniz öğe ve dizi, dizi adınızdır.

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

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

başla

Diziyi değiştirmeye başlayacağınız dizin (Origin 0 ile). Dizinin uzunluğundan büyükse, gerçek başlangıç ​​dizini dizinin uzunluğuna ayarlanır. Negatif ise, dizinin sonundan itibaren (Origin -1 ile) birçok öğe başlar ve mutlak değer dizinin uzunluğundan büyükse, 0 olarak ayarlanır.

deleteCount İsteğe Bağlı

Kaldırılacak eski dizi elemanlarının sayısını belirten bir tamsayı ... __ deleteCount ihmal edilirse veya değeri array.length değerinden büyükse - start (dizide kalan öğe sayısından büyükse) başlangıçtan başlayarak), daha sonra dizilimin başından sonuna kadar olan tüm öğeler silinecek .Sil silme 0 veya negatifse, öğe kaldırılmaz. Bu durumda, en az bir yeni eleman belirtmelisiniz (aşağıya bakınız).

item1, item2, ... İsteğe bağlı

Dizine eklenecek öğeler, başlangıç ​​dizininden başlayarak. Herhangi bir öğe belirtmezseniz, splice () yalnızca dizideki öğeleri kaldıracaktır.

Daha fazla hakem için lütfen geçelim:

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

Çok fazla cevap var, ancak henüz kimse bir tek gömlek ile yapmadığı için yöntemimi göstereceğimi düşündüm. Bir dizi oluştururken string.split () işlevinin belirtilen tüm karakterleri kaldıracağı gerçeğinden faydalanır. İşte bir örnek: 

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

Bu örnekte, 4'lerin tümü ary dizisinden kaldırılıyor. Ancak, "-" karakterini içeren dizilerin bu örnekte sorunlara yol açacağını not etmek önemlidir. Kısacası, birleştirme ("-") işlevinin dizginizi yanlış bir şekilde birleştirmesine neden olur. Böyle bir durumda, yukarıdaki snipet'teki "-" dizelerinin tümü, orijinal dizide kullanılmayacak herhangi bir dizeyle değiştirilebilir. İşte başka bir örnek: 

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

Yerinde olmayan çözüm

arr.slice(0,i).concat(arr.slice(i+1));

let arr = [10, 20, 30, 40, 50]

let i = 2 ; // position to remove (starting from 0)
let r = arr.slice(0,i).concat(arr.slice(i+1));

console.log(r);

dizi nesnesini, aşağıdaki gibi bir özel silme işlevi tanımlamak üzere genişletebilirsiniz.

let numbers = [1,2,4,4,5,3,45,9];

numbers.delete = function(value){
    var indexOfTarget = this.indexOf(value)

    if(indexOfTarget !== -1)
    {
        console.log("array before delete " + this)
        this.splice(indexOfTarget, 1)
        console.log("array after delete " + this)
    }else{
        console.error("element " + value + " not found")
    }
}
numbers.delete(888)
//expected output:
//element 888 not found
numbers.delete(1)

//expected output;
//array before delete 1,2,4,4,5,3,45,9
//array after delete 2,4,4,5,3,45,9

Umarım bu yardımcı olur

Aşağıdaki şekilde azaltma yönteminin karını alarak:

case a) Elemanı indeks ile çıkarmanız gerekirse:

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

durum b) eğer elemanın (int) değerinden elemanın çıkarılması gerekiyorsa:

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

Böylece, bu şekilde, eleman kaldırılmış olarak yeni bir dizi döndürebiliriz (serin, işlevsel bir yol - Push veya splice kullanmaktan çok daha iyi).

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)

Çıktı [2, 3, 4, 5];