Kullanarak arasındaki fark ne operatörü kullanmanın aksine dizi elemanı ile bir yöntem ?deleteArray.splice

Örneğin:

myArray = ['a', 'b', 'c', 'd'];

delete myArray[1];
//  or
myArray.splice (1, 1);

Nesnelerle yapabildiğim gibi dizi öğelerini silebilirsem neden splice yöntemi var?

deleteobject özelliğini siler, ancak diziyi yeniden endekslemez veya uzunluğunu güncellemez. Bu, tanımlanmamış gibi görünmesini sağlar:

> myArray = ['a', 'b', 'c', 'd']
  ["a", "b", "c", "d"]
> delete myArray[0]
  true
> myArray[0]
  undefined

Aslında değere ayarlanmadığını undefined, bunun yerine özellik diziden kaldırıldığını ve tanımsız görünmesini sağladığını unutmayın . Chrome geliştirme araçları empty, diziyi kaydederken yazdırarak bu ayrımı netleştirir .

> myArray[0]
  undefined
> myArray
  [empty, "b", "c", "d"]

myArray.splice(start, deleteCount) aslında öğeyi kaldırır, diziyi yeniden endeksler ve uzunluğunu değiştirir.

> myArray = ['a', 'b', 'c', 'd']
  ["a", "b", "c", "d"]
> myArray.splice(0, 2)
  ["a", "b"]
> myArray
  ["c", "d"]

Array.remove () Yöntemi

JQuery'nin yaratıcısı John Resig , Array.removebunu projelerimde her zaman kullandığım çok kullanışlı bir yöntem yarattı .

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

ve nasıl kullanılabileceğine dair bazı örnekler:

// Remove the second item from the array
array.remove(1);
// Remove the second-to-last item from the array
array.remove(-2);
// Remove the second and third items from the array
array.remove(1,2);
// Remove the last and second-to-last items from the array
array.remove(-2,-1);

John'un web sitesi

Sil yalnızca nesneyi dizideki öğeden kaldırdığından, dizinin uzunluğu değişmez. Ekleme nesneyi kaldırır ve diziyi kısaltır.

Aşağıdaki kod "a", "b", "tanımsız", "d"

myArray = ['a', 'b', 'c', 'd']; delete myArray[2];

for (var count = 0; count < myArray.length; count++) {
    alert(myArray[count]);
}

Oysa bu "a", "b", "d"

myArray = ['a', 'b', 'c', 'd']; myArray.splice(2,1);

for (var count = 0; count < myArray.length; count++) {
    alert(myArray[count]);
}

Bir diziden bir öğenin her oluşumunu nasıl kaldıracağımı anlamaya çalışırken bu soruya rastladım. İşte bir karşılaştırma var içinde spliceve deleteher kaldırılması için 'c'gelen itemsArray.

var items = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'];

while (items.indexOf('c') !== -1) {
  items.splice(items.indexOf('c'), 1);
}

console.log(items); // ["a", "b", "d", "a", "b", "d"]

items = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'];

while (items.indexOf('c') !== -1) {
  delete items[items.indexOf('c')];
}

console.log(items); // ["a", "b", undefined, "d", "a", "b", undefined, "d"]
​

Gönderen Çekirdek JavaScript 1.5 Referans> Operatörler> Özel Operatörleri> silme Operatör :

Bir dizi öğesini sildiğinizde, dizi uzunluğu etkilenmez. Örneğin, bir [3] 'ü silerseniz, [4] hala [4] ve [3] tanımsızdır. Bu, dizinin son öğesini silseniz bile tutar (bir [a. Uzunluk-1] silin).

splice sayısal indekslerle çalışacaktır.

oysa deletediğer tür endekslere karşı kullanılabilir.

misal:

delete myArray['text1'];

Ayrıca, eklemenin sadece dizilerde çalıştığını da belirtmek gerekir. (Nesne özelliklerine tutarlı bir sırayı takip etmek için güvenilemez.)

Anahtar / değer çiftini bir nesneden kaldırmak için silmek istediğiniz şeydir:

delete myObj.propName;     // , or:
delete myObj["propName"];  // Equivalent.

Vs ekini sil

bir diziden bir öğe sildiğinizde

var arr = [1,2,3,4]; delete arr[2]; //result [1, 2, 3:, 4]
console.log(arr)

eklediğinizde

var arr = [1,2,3,4]; arr.splice(1,1); //result [1, 3, 4]
console.log(arr);

durumunda silme eleman silinir ancak endeks boş kalır

arasında durumda ise bağlantı elemanının silinir ve geri kalan elemanlar dizini buna göre azalır

Yukarıda birçok kez belirtildiği gibi, kullanmak splice()mükemmel bir uyum gibi görünüyor. Mozilla'daki belgeler:

splice()Yöntem, mevcut elemanları çıkarılması ve / veya yeni elemanları eklenerek bir dizi içeriğini değiştirir.

var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];

myFish.splice(2, 0, 'drum'); 
// myFish is ["angel", "clown", "drum", "mandarin", "sturgeon"]

myFish.splice(2, 1); 
// myFish is ["angel", "clown", "mandarin", "sturgeon"]

Sözdizimi

array.splice(start)
array.splice(start, deleteCount)
array.splice(start, deleteCount, item1, item2, ...)

Parametreler

Başlat

Diziyi değiştirmeye başladığınız dizin. Dizinin uzunluğundan büyükse, gerçek başlangıç ​​dizini dizinin uzunluğuna ayarlanır. Olumsuz ise, o kadar çok öğeyi baştan başlatacak.

deleteCount

Kaldırılacak eski dizi öğelerinin sayısını gösteren bir tam sayı. DeleteCount 0 ise, hiçbir öğe kaldırılmaz. Bu durumda, en az bir yeni öğe belirtmelisiniz. DeleteCount, başlangıçta dizide kalan öğe sayısından büyükse, dizinin sonundaki tüm öğeler silinir.

DeleteCount atlanırsa, deleteCount eşittir (arr.length - start).

madde1, madde2, ...

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

Geri dönüş değeri

Silinmiş öğeleri içeren bir dizi. Yalnızca bir öğe kaldırılırsa, bir öğenin dizisi döndürülür. Hiçbir öğe kaldırılmazsa, boş bir dizi döndürülür.

[...]

delete , gerçek olmayan bir dünya durumu gibi davranır, yalnızca öğeyi kaldırır , ancak dizi uzunluğu aynı kalır:

düğüm terminalinden örnek:

> var arr = ["a","b","c","d"];
> delete arr[2]
true
> arr
[ 'a', 'b', , 'd', 'e' ]

Burada, bir dizinin bir öğesini dilim () kullanarak dizine göre kaldırmak için kullanılan bir işlevdir ; ilk argüman olarak arr ve ikinci argüman olarak silmek istediğiniz üyenin dizinini alır. Gördüğünüz gibi, aslında dizinin üyesini siler ve dizi uzunluğunu azaltır 1

function(arr,arrIndex){
    return arr.slice(0,arrIndex).concat(arr.slice(arrIndex + 1));
}

Yukarıdaki işlev, tüm üyeleri dizine ve dizinden sonraki tüm üyeleri bir araya getirerek bunları birleştirir ve sonucu döndürür.

Yukarıdaki işlevi düğüm modülü olarak kullanan bir örnek, terminalin yararlı olacağını görmek için:

> var arr = ["a","b","c","d"]
> arr
[ 'a', 'b', 'c', 'd' ]
> arr.length
4 
> var arrayRemoveIndex = require("./lib/array_remove_index");
> var newArray = arrayRemoveIndex(arr,arr.indexOf('c'))
> newArray
[ 'a', 'b', 'd' ] // c ya later
> newArray.length
3

indexOf ("c") sadece ilk gerçekleşmeyi alacağından ve bulduğu ilk "c" yi ekleyip kaldıracağından, bunun içinde çiftler bulunan bir dizi çalışmayacağını lütfen unutmayın.

Büyük bir diziyi yinelemek ve öğeleri seçici olarak silmek isterseniz, her silme işlemi için splice () öğesini çağırmak pahalı olacaktır çünkü splice () her seferinde sonraki öğeleri yeniden endekslemek zorunda kalacaktır. Diziler Javascript'te ilişkilendirilebilir olduğundan, öğeleri tek tek silmek ve daha sonra diziyi yeniden dizine eklemek daha verimli olur.

Yeni bir dizi oluşturarak bunu yapabilirsiniz. Örneğin

function reindexArray( array )
{
       var result = [];
        for( var key in array )
                result.push( array[key] );
        return result;
};

Ama orijinal dizideki anahtar değerleri değiştirebileceğini düşünmüyorum, ki bu daha verimli olurdu - yeni bir dizi oluşturmanız gerekebilir.

"Tanımsız" girişleri kontrol etmenize gerek olmadığını unutmayın, çünkü bunlar gerçekte mevcut değildir ve for döngüsü onları döndürmez. Onları tanımsız olarak gösteren dizi baskısının bir eseridir. Hafızada görünmüyorlar.

Daha hızlı olan slice () gibi bir şey kullanabilseniz iyi olurdu, ancak yeniden endekslemez. Daha iyi bir yol bilen var mı?

Aslında, muhtemelen daha verimli, performans açısından aşağıdaki gibi yerinde yapabilirsiniz:

reindexArray : function( array )
{
    var index = 0;                          // The index where the element should be
    for( var key in array )                 // Iterate the array
    {
        if( parseInt( key ) !== index )     // If the element is out of sequence
        {
            array[index] = array[key];      // Move it to the correct, earlier position in the array
            ++index;                        // Update the index
        }
    }

    array.splice( index );  // Remove any remaining elements (These will be duplicates of earlier items)
},

böyle bir şey kullanabilirsin

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]

Neden sadece filtrelemiyoruz? Sanırım dizileri js olarak düşünmenin en açık yolu bu.

myArray = myArray.filter(function(item){
    return item.anProperty != whoShouldBeDeleted
});

Fark, deleteişleç ve splice()yöntem uygulandıktan sonra her dizinin uzunluğunun günlüğe kaydedilmesiyle görülebilir . Örneğin:

operatörü sil

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
delete trees[3];

console.log(trees); // ["redwood", "bay", "cedar", empty, "maple"]
console.log(trees.length); // 5

deleteOperatör diziden elemanı kaldırır, fakat elemanın "tutucu" hala var. oakkaldırıldı ancak dizide yer kaplıyor. Bu nedenle, dizinin uzunluğu 5 kalır.

splice () yöntemi

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
trees.splice(3,1);

console.log(trees); // ["redwood", "bay", "cedar", "maple"]
console.log(trees.length); // 4

splice()Yöntem tam olarak, hedef değer kaldırır ve hem de "tutucu". oak, dizide işgal etmek için kullandığı alanın yanı sıra kaldırıldı. Dizinin uzunluğu şimdi 4'tür.

function remove_array_value(array, value) {
    var index = array.indexOf(value);
    if (index >= 0) {
        array.splice(index, 1);
        reindex_array(array);
    }
}
function reindex_array(array) {
   var result = [];
    for (var key in array) {
        result.push(array[key]);
    }
    return result;
}

misal:

var example_arr = ['apple', 'banana', 'lemon'];   // length = 3
remove_array_value(example_arr, 'banana');

muz silinir ve dizi uzunluğu = 2

Farklı amaçları olan farklı şeyler bunlar.

splicesilme işlemi için kullanılan bir dizi-spesifik ve olduğu, bir dizi girişleri kaldırır ve boşluğu doldurmak için hareket önceki girdileri. (Aynı zamanda giriş eklemek veya her ikisini birden kullanmak için de kullanılabilir.) Dizinin (no-op çağrısı olmadığı varsayılarak ) splicedeğişmesine neden olur length. theArray.splice(x, 0)).

deletediziye özgü değildir; nesnelerde kullanılmak üzere tasarlanmıştır: Bir özelliği (anahtar / değer çifti) üzerinde kullandığınız nesneden kaldırır. Yalnızca diziler için geçerlidir, çünkü JavaScript'teki standart (ör. Türlenmemiş) diziler gerçekten diziler değildir *, adları "dizi dizini" olan ( "... sayısal değeri aralıkta olan dize adları" olarak tanımlanır ) ve . Bir dizi girişini kaldırmak için kullandığınızda , tek yapmanız gereken girişi kaldırmaktır; boşluğu doldurmak için onu takip eden diğer girişleri taşımaz ve böylece dizi "seyrek" olur (bazı girişlerin tamamen eksik olması gerekir). Üzerinde hiçbir etkisi yoktur .i+0 ≤ i < 2^32-1lengthdeletelength

Bu soruya verilen cevaplardan birkaçı yanlış bir deleteşekilde undefined" girdiyi" olarak ayarladığını "belirtir . Bu doğru değil. Bu kaldırır bir boşluk bırakarak tamamen girişi (özelliği).

Farkları göstermek için bazı kodlar kullanalım:

console.log("Using `splice`:");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
a.splice(0, 1);
console.log(a.length);            // 4
console.log(a[0]);                // "b"

console.log("Using `delete`");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
delete a[0];
console.log(a.length);            // still 5
console.log(a[0]);                // undefined
console.log("0" in a);            // false
console.log(a.hasOwnProperty(0)); // false

console.log("Setting to `undefined`");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
a[0] = undefined;
console.log(a.length);            // still 5
console.log(a[0]);                // undefined
console.log("0" in a);            // true
console.log(a.hasOwnProperty(0)); // true

* (bu benim anemik küçük bloguma bir yazı)

Şu anda bunu yapmanın iki yolu var

1. splice () kullanarak

   arrayObject.splice(index, 1);

2. sil kullanarak

   delete arrayObject[index];

Ancak her zaman dizi nesneleri için splice kullanmanızı ve nesne öznitelikleri için delete kullanmanızı öneririm, çünkü delete dizi uzunluğunu güncellemez.

Tamam, aşağıda bu diziye sahip olduğumuzu düşünün:

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

Önce silelim:

delete arr[1];

Ve sonuç bu:

[1, empty, 3, 4, 5];

boş! ve hadi alalım:

arr[1]; //undefined

Yani sadece silinen değer anlamına gelir ve şimdi tanımsızdır , bu yüzden uzunluk aynıdır, ayrıca doğru dönecektir ...

Dizimizi sıfırlayalım ve bu sefer splice ile yapalım:

arr.splice(1, 1);

ve bu seferki sonuç:

[1, 3, 4, 5];

Gördüğünüz gibi dizi uzunluğu değiştirildi ve arr[1]bir 3 şimdi ...

Ayrıca bu, silinen öğeyi [3]bu durumda olan bir Dizide döndürür ...

Diğerleri zaten düzgün karşılaştırdık deleteile splice.

Bir başka ilginç karşılaştırma deletekarşı undefinedsilinmiş bir dizi öğe sadece ayarlandığında olandan daha az bellek kullanır: undefined;

Örneğin, bu kod bitmez:

let y = 1;
let ary = [];
console.log("Fatal Error Coming Soon");
while (y < 4294967295)
{
    ary.push(y);
    ary[y] = undefined;
    y += 1;
}
console(ary.length);

Bu hatayı üretir:

FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed - JavaScript heap out of memory.

Gördüğünüz gibi undefinedaslında yığın belleği kaplıyor.

Ancak, deleteary öğesini de (yalnızca ayarlamak yerine) yaparsanız undefined, kod yavaşça biter:

let x = 1;
let ary = [];
console.log("This will take a while, but it will eventually finish successfully.");
while (x < 4294967295)
{
    ary.push(x);
    ary[x] = undefined;
    delete ary[x];
    x += 1;
}
console.log(`Success, array-length: ${ary.length}.`);

Bunlar aşırı örnekler, ama deletekimsenin hiçbir yerde bahsetmediğini bir noktaya işaret ediyorlar .

Küçük bir diziniz varsa şunları kullanabilirsiniz filter:

myArray = ['a', 'b', 'c', 'd'];
myArray = myArray.filter(x => x !== 'b');

En kolay yol muhtemelen

var myArray = ['a', 'b', 'c', 'd'];
delete myArray[1]; // ['a', undefined, 'c', 'd']. Then use lodash compact method to remove false, null, 0, "", undefined and NaN
myArray = _.compact(myArray); ['a', 'c', 'd'];

Bu yardımcı olur umarım. Referans: https://lodash.com/docs#compact

Lodash'ı kullanmak isteyenler için şunları kullanabilirsiniz: myArray = _.without(myArray, itemToRemove)

Veya Angular2'de kullandığım gibi

import { without } from 'lodash';
...
myArray = without(myArray, itemToRemove);
...

delete : delete, nesne özelliğini siler, ancak diziyi yeniden endekslemez veya uzunluğunu güncellemez. Bu, tanımlanmamış gibi görünmesini sağlar:

splice : öğeyi aslında kaldırır, diziyi yeniden endeksler ve uzunluğunu değiştirir.

Öğeyi sondan sil

arrName.pop();

Öğeyi ilkinden sil

arrName.shift();

Ortadan sil

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

Ex: arrName.splice(1,1);

Bir öğeyi sondan sil

arrName.splice(-1);

Dizi indeks numarasını kullanarak sil

 delete arrName[1];

Silmek istediğiniz öğe ortadaysa (dizininin 1 olduğu 'c' yi silmek istiyoruz), şunları kullanabilirsiniz:

var arr = ['a','b','c'];
var indexToDelete = 1;
var newArray = arr.slice(0,indexToDelete).combine(arr.slice(indexToDelete+1, arr.length))

IndexOfbir başvuru türünü de kabul eder. Aşağıdaki senaryoyu varsayalım:

var arr = [{item: 1}, {item: 2}, {item: 3}];
var found = find(2, 3); //pseudo code: will return [{item: 2}, {item:3}]
var l = found.length;

while(l--) {
   var index = arr.indexOf(found[l])
      arr.splice(index, 1);
   }
   
console.log(arr.length); //1

farklı:

var item2 = findUnique(2); //will return {item: 2}
var l = arr.length;
var found = false;
  while(!found && l--) {
  found = arr[l] === item2;
}

console.log(l, arr[l]);// l is index, arr[l] is the item you look for

function deleteFromArray(array, indexToDelete){
  var remain = new Array();
  for(var i in array){
    if(array[i] == indexToDelete){
      continue;
    }
    remain.push(array[i]);
  }
  return remain;
}

myArray = ['a', 'b', 'c', 'd'];
deleteFromArray(myArray , 0);

// sonuç: myArray = ['b', 'c', 'd'];