Sayılar dizisine sahibim ve ona eleman eklemek için .Push()
yöntemini kullanıyorum.
Bir diziden belirli bir öğeyi kaldırmanın basit bir yolu var mı? array.remove(number);
gibi bir şeyin karşılığı.
core JavaScript - no framework'leri kullanmam gerekiyor.
Kaldırmak istediğiniz dizi elemanının index
öğesini bulun, sonra splice
ile o dizini kaldırın.
Splice () yöntemi bir dizinin içeriğini değiştirerek mevcut öğeler ve/veya yeni öğeler ekleyerek.
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
öğesinin ikinci parametresi, kaldırılacak öğe sayısıdır. splice
öğesinin diziyi değiştirdiğini ve kaldırılan öğeleri içeren yeni bir dizi döndürdüğünü unutmayın.
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];
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.
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 ]
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
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
// 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 ]
Referans
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.
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:
splice (): anArray.splice(index, 1);
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
var removed = helper.removeOne(arr, row => row.id === 5 );
var removed = helper.remove(arr, row => row.name.startsWith('BMW'));
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.
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.
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.
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.
Tek bir öğe yerine birçok öğeyi kaldırmak istiyorsanız ne yapmalıyım?
En basit çözümü bulalım.
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)
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)
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);
}
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. .indexOf
IE*
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 Object
key => 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]
/**
* 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.
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 slice
splice
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.
Sadece son öğeyi silmek isterseniz, Array.pop () komutunu kullanabilirsiniz.
Sadece ilk elemanı silmek isterseniz, Array.shift () komutunu kullanabilirsiniz.
Öğ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);
}
}
Öğ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.
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];