JavaScript'te bir diziyi nasıl boşaltabilirim?

Bir diziyi boşaltmanın bir yolu var mı .remove()?

Örneğin,

A = [1,2,3,4];

Bunu nasıl boşaltabilirim?

Mevcut bir diziyi temizleme yolları A:

Yöntem 1

(bu soruya ilk cevabımdı)

A = [];

Bu kod, değişkeni Ayeni bir boş diziye ayarlar . Orijinal diziyeA başka hiçbir yerde referansınız yoksa, bu mükemmeldir, çünkü bu aslında yeni (boş) bir dizi oluşturur. Bu diziye başka bir değişken veya özellikten başvurduysanız, orijinal dizi değişmeden kalacağından bu yönteme dikkat etmelisiniz. Bunu yalnızca diziye yalnızca orijinal değişkeniyle başvuruyorsanız kullanın A.

Bu aynı zamanda en hızlı çözümdür.

Bu kod örneği, bu yöntemi kullanırken karşılaşabileceğiniz sorunu gösterir:

var arr1 = ['a','b','c','d','e','f'];
var arr2 = arr1;  // Reference arr1 by another variable 
arr1 = [];
console.log(arr2); // Output ['a','b','c','d','e','f']

Yöntem 2 ( Matthew Crumley tarafından önerildiği gibi )

A.length = 0

Bu, uzunluğunu 0 olarak ayarlayarak mevcut diziyi temizler. Bazıları bunun JavaScript'in tüm uygulamalarında çalışmayabileceğini iddia etti, ancak durum böyle değil. Ayrıca bir dizinin length özelliği bir read / write özelliği olduğundan ECMAScript 5'te "katı mod" kullanılırken de çalışır.

Yöntem 3 ( Anthony tarafından önerildiği gibi )

A.splice(0,A.length)

Kullanmak .splice()mükemmel bir şekilde çalışır, ancak .splice()işlev kaldırılan tüm öğelerin bulunduğu bir dizi döndüreceğinden, orijinal dizinin bir kopyasını döndürür. Deneyler bunun performans üzerinde hiçbir etkisi olmadığını göstermektedir.

Yöntem 4 (olarak önerilen göre tanguy_k )

while(A.length > 0) {
    A.pop();
}

Bu çözüm çok özlü değildir ve aynı zamanda orijinal cevapta atıfta bulunulan daha önceki kıyaslamaların aksine en yavaş çözümdür.

Verim

Bir temizleme bütün yöntemleri içinde varolan bir dizi , yöntem 2 ve 3 performans çok benzerdir ve bu bakınız 4. Bir çok daha hızlı bir yöntem daha vardır kriter .

Tarafından işaret edildiği gibi Diadistis kendi içinde cevap aşağıda, dört yöntemden performansını belirlemek için kullanılan özgün kriterler yukarıda kusurlu anlatılmış. Orijinal karşılaştırma ölçütü, temizlenen diziyi yeniden kullandı, böylece ikinci yineleme zaten boş olan bir diziyi temizliyordu.

Aşağıdaki kıyaslama bu kusuru giderir: http://jsben.ch/#/hyj65 . # 2 (length özelliği) ve # 3 (splice) yöntemlerinin en hızlı olduğunu açıkça gösterir (orijinal diziyi değiştirmeyen # 1 sayma yöntemi değil).

Bu sıcak bir konu ve birçok tartışmanın sebebi olmuştur. Aslında birçok doğru cevap var ve bu cevap çok uzun süredir kabul edilen cevap olarak işaretlendiğinden, tüm yöntemleri buraya ekleyeceğim. Bu cevaba oy verirseniz, lütfen referans verdiğim diğer cevapları da oylayın.

Orijinal diziyi de güncellemeniz gereken başka referanslarınız olduğu için tutmanız gerekiyorsa, uzunluğunu sıfır olarak ayarlayarak yeni bir dizi oluşturmadan diziyi temizleyebilirsiniz:

A.length = 0;

İşte en hızlı çalışan uygulama sırasında aynı diziyi tutarak ( "değişken"):

function clearArray(array) {
  while (array.length) {
    array.pop();
  }
}

FYI basitleştirilemez while (array.pop()): testler başarısız olur.

Bilginize Harita ve Set tanımlamak clear()o olması mantıklı görünüyor olurdu, clear()için Array de.

TypeScript sürümü:

function clearArray<T>(array: T[]) {
  while (array.length) {
    array.pop();
  }
}

İlgili testler:

describe('clearArray()', () => {
  test('clear regular array', () => {
    const array = [1, 2, 3, 4, 5];
    clearArray(array);
    expect(array.length).toEqual(0);
    expect(array[0]).toEqual(undefined);
    expect(array[4]).toEqual(undefined);
  });

  test('clear array that contains undefined and null', () => {
    const array = [1, undefined, 3, null, 5];
    clearArray(array);
    expect(array.length).toEqual(0);
    expect(array[0]).toEqual(undefined);
    expect(array[4]).toEqual(undefined);
  });
});

Burada güncellenen jsPerf: http://jsperf.com/array-destroy/32 http://jsperf.com/array-destroy/152

Daha çapraz tarayıcı dostu ve daha uygun bir çözüm, spliceA dizisinin içeriğini aşağıdaki gibi boşaltmak için yöntemi kullanmak olacaktır :

A.splice(0, A.length);

Şimdiye kadar 2739 upvottan daha az olmayan cevaplar yanıltıcı ve yanlıştır.

Soru şudur: "Mevcut dizinizi nasıl boşaltırsınız?" Örneğin A = [1,2,3,4].

1. " A = []Cevaptır" demek cahil ve kesinlikle yanlıştır. [] == []olduğu yanlış .

   Bunun nedeni, bu iki dizinin, her biri kendi başına, dijital dünyada kendi alanlarını kaplayan, kendi iki kimliğine sahip iki ayrı, ayrı nesne olmasıdır.

Diyelim ki anneniz sizden çöp kutusunu boşaltmanızı istiyor.

• Sizden isteneni yapmış gibi yeni bir tane getiremezsiniz.
• Bunun yerine çöp kutusunu boşaltırsınız.
• Doldurulmuş olanı yeni bir boş kutu ile değiştirmezsiniz ve "A" etiketini dolu kutudan almaz ve yeni kutuya yapıştıramazsınız. A = [1,2,3,4]; A = [];

Bir dizi nesnesini boşaltmak şimdiye kadarki en kolay şeydir:

A.length = 0;

Bu şekilde, "A" altındaki kutu sadece boş değil, aynı zamanda yeni kadar temiz!

2. Ayrıca, çöp kutusu boşalana kadar çöpleri elinizle çıkarmanız gerekmez! Mevcut olanı, bir seferde, kutu boşalıncaya kadar çöpü almamanız için tamamen boşaltmanız istendi:

   while(A.length > 0) {
       A.pop();
   }

3. Ayrıca, sol elinizi çöp kutusunun altına koymak için, içeriğini olduğu gibi dışarı çekebilmek için yukarıdan sağa doğru tutarak:

   A.splice(0, A.length);

Hayır, boşaltmanız istendi:

A.length = 0;

Bu, belirli bir JavaScript dizisinin içeriğini doğru şekilde boşaltan tek koddur.

Performans testi:

http://jsperf.com/array-clear-methods/3

a = []; // 37% slower
a.length = 0; // 89% slower
a.splice(0, a.length)  // 97% slower
while (a.length > 0) {
    a.pop();
} // Fastest

Dizilerinizin "temizlenmesine" izin vermek için bunu JavaScript dosyanıza ekleyebilirsiniz:

Array.prototype.clear = function() {
    this.splice(0, this.length);
};

O zaman bu şekilde kullanabilirsiniz:

var list = [1, 2, 3];
list.clear();

Veya bir şeyi yok etmediğinizden emin olmak istiyorsanız:

if (!Array.prototype.clear) {
    Array.prototype.clear = function() {
       this.splice(0, this.length);
    };
}

Birçok kişi yerel nesneleri (Array gibi) değiştirmemeniz gerektiğini düşünüyor ve ben de aynı fikirdeyim. Lütfen bununla nasıl başa çıkacağınıza karar verirken dikkatli olun.

Süre ile ilgili çok fazla karışıklık ve yanlış bilgi var; hem cevaplarda hem de yorumlarda pop / shift performansı. While / pop çözümü (beklendiği gibi) kötü performansa sahiptir . Gerçekte olan şey, kurulumun snippet'i bir döngüde çalıştıran her örnek için yalnızca bir kez çalışmasıdır. Örneğin:

var arr = [];

for (var i = 0; i < 100; i++) { 
    arr.push(Math.random()); 
}

for (var j = 0; j < 1000; j++) {
    while (arr.length > 0) {
        arr.pop(); // this executes 100 times, not 100000
    }
}

Doğru çalışan yeni bir test oluşturdum:

http://jsperf.com/empty-javascript-array-redux

Uyarı: testin bu sürümünde bile gerçek farkı göremezsiniz çünkü dizi klonlamak test süresinin çoğunu alır. Hala splicediziyi temizlemenin en hızlı yolu olduğunu gösterir ( []en hızlı olmasına rağmen aslında mevcut diziyi temizlemediğinden).

Bellek ayırma ile ilgileniyorsanız, krom dev araçlarının zaman çizelgesi sekmesi ile birlikte bu jsfiddle gibi bir yaklaşımı kullanarak her yaklaşımı karşılaştırabilirsiniz . Diziyi 'temizledikten' sonra bir çöp toplama işlemini zorlamak için alttaki çöp kutusu simgesini kullanmak isteyeceksiniz. Bu, seçtiğiniz tarayıcı için size daha kesin bir cevap vermelidir. Burada birçok cevap eski ve ben onlara güvenmek değil, yukarıdaki @ tanguy_k cevabı gibi test.

(Yukarıda belirtilen sekmede bir intro Çıkış yapabilmek burada )

Stackoverflow beni jsfiddle kopyalamak için zorlar bu yüzden işte burada:

<html>
<script>
var size = 1000*100
window.onload = function() {
  document.getElementById("quantifier").value = size
}

function scaffold()
{
  console.log("processing Scaffold...");
  a = new Array
}
function start()
{
  size = document.getElementById("quantifier").value
  console.log("Starting... quantifier is " + size);
  console.log("starting test")
  for (i=0; i<size; i++){
    a[i]="something"
  }
  console.log("done...")
}

function tearDown()
{
  console.log("processing teardown");
  a.length=0
}

</script>
<body>
    <span style="color:green;">Quantifier:</span>
    <input id="quantifier" style="color:green;" type="text"></input>
    <button onclick="scaffold()">Scaffold</button>
    <button onclick="start()">Start</button>
    <button onclick="tearDown()">Clean</button>
    <br/>
</body>
</html>

JavaScript dizeleri diğer ilkel türlerden farklı bir şekilde yönettiğinden, nesne dizilerinden bahsetmediğinden, bunun dizi öğelerinin türüne bağlı olabileceğini unutmayın. Bu tür olanları etkileyebilir.

Bunu sizin için yapacak bir işlevi kolayca oluşturabilir, uzunluğunu değiştirebilir ve hatta yerel Diziye şu şekilde ekleyebilirsiniz:remove() yeniden kullanım için işlevi.

Bu diziye sahip olduğunuzu düşünün:

var arr = [1, 2, 3, 4, 5]; //the array

Tamam, sadece şunu çalıştırın:

arr.length = 0; //change the length

ve sonuç:

[] //result

bir diziyi boşaltmanın kolay yolu ...

Ayrıca gerekli olmayan ancak bunu yapmanın başka bir yolu olan döngü kullanmak:

/* could be arr.pop() or arr.splice(0)
don't need to return as main array get changed */

function remove(arr) {
  while(arr.length) {
    arr.shift(); 
  }
}

Düşünebileceğiniz zor bir yol da var, örneğin böyle bir şey:

arr.splice(0, arr.length); //[]

Yani arr 5 öğe varsa, 0'dan 5 öğe ekler, yani dizide hiçbir şey kalmaz.

Ayrıca diziyi yeniden atamak gibi diğer yollar da örneğin:

arr = []; //[]

Dizi işlevlerine bakarsanız, bunu yapmanın başka birçok yolu vardır, ancak en çok önerilen yöntem uzunluğu değiştirmek olabilir.

İlk başta söylediğim gibi, sorunuzun yanıtı olarak remove () öğesini de prototipleyebilirsiniz. yukarıdaki yöntemlerden birini seçip JavaScript'teki Array nesnesine prototip oluşturabilirsiniz:

Array.prototype.remove = Array.prototype.remove || function() {
  this.splice(0, this.length);
};

javascript uygulamanızdaki herhangi bir diziyi boşaltmak için bunu şöyle çağırabilirsiniz:

arr.remove(); //[]

Array.prototype.clear = function() {
    this.length = 0;
};

Ve ara: array.clear();

A.splice(0);

Ben sadece üzerinde çalıştığım bazı kod üzerinde yaptım. Diziyi temizledi.

Kullanıyorsanız

a = []; 

Daha sonra a'ya yeni dizi başvurusu atarsınız, eğer a'daki referans başka bir değişkene zaten atanmışsa, o diziyi de boşaltmaz ve bu nedenle çöp toplayıcı bu belleği toplamaz.

Örn.

var a=[1,2,3];
var b=a;
a=[];
console.log(b);// It will print [1,2,3];

veya

a.length = 0;

Belirttiğimizde a.length , sadece dizinin sınırlarını sıfırlıyoruz ve dinlenme dizi öğeleri için bellek çöp toplayıcı tarafından bağlanacak.

Bu iki çözüm yerine daha iyidir.

a.splice(0,a.length)

ve

while(a.length > 0) {
    a.pop();
}

Önceki kenshou.html cevabına göre, ikinci yöntem daha hızlıdır.

Jan'ın ilk önerisinin değiştirilmiş bir sürümünü kullanın :

var originalLength = A.length;
for (var i = originalLength; i > 0; i--) {
     A.pop();
}

Sabitleri kullanırsanız, başka seçeneğiniz yoktur:

const numbers = [1, 2, 3]

Yeniden atayamazsınız:

numbers = []

Yalnızca kısaltabilirsiniz:

numbers.length = 0

Bir dizinin Geçerli bellek konumunu boşaltmak için şunu kullanın: 'myArray.length = 0'veya'myArray.pop() UN-till its length is 0'

• length: Bir diziyi istediğiniz zaman kısaltmak için length özelliğini ayarlayabilirsiniz. Bir diziyi length özelliğini değiştirerek genişlettiğinizde, gerçek öğelerin sayısı artar.
• pop() : Pop yöntemi bir dizideki son öğeyi kaldırır ve kaldırılan değeri döndüren döndürür.
• shift(): Shift yöntemi, öğeyi sıfırıncı dizinden kaldırır ve ardışık dizinlerdeki değerleri aşağı kaydırır, ardından kaldırılan değeri döndürür.

Misal:

var arr = ['77'];
arr.length = 20;
console.log("Increasing : ", arr); // (20) ["77", empty × 19]
arr.length = 12;
console.log("Truncating : ", arr); // (12) ["77", empty × 11]

var mainArr = new Array();
mainArr = ['1', '2', '3', '4'];

var refArr = mainArr;
console.log('Current', mainArr, 'Refered', refArr);

refArr.length = 3;
console.log('Length: ~ Current', mainArr, 'Refered', refArr);

mainArr.push('0');
console.log('Push to the End of Current Array Memory Location \n~ Current', mainArr, 'Refered', refArr);

mainArr.poptill_length(0);
console.log('Empty Array \n~ Current', mainArr, 'Refered', refArr);

Array.prototype.poptill_length = function (e) {
  while (this.length) {
    if( this.length == e ) break;

    console.log('removed last element:', this.pop());
  }
};

• new Array() | [] Array constructorVeya öğesini kullanarak yeni bellek konumuyla bir Dizi oluşturun array literal.

  mainArr = []; // a new empty array is addressed to mainArr.
  
  var arr = new Array('10'); // Array constructor
  arr.unshift('1'); // add to the front
  arr.push('15'); // add to the end
  console.log("After Adding : ", arr); // ["1", "10", "15"]
  
  arr.pop(); // remove from the end
  arr.shift(); // remove from the front
  console.log("After Removing : ", arr); // ["10"]
  
  var arrLit = ['14', '17'];
  console.log("array literal « ", indexedItem( arrLit ) ); // {0,14}{1,17}
  
  function indexedItem( arr ) {
      var indexedStr = "";
      arr.forEach(function(item, index, array) {
          indexedStr += "{"+index+","+item+"}";
          console.log(item, index);
      });
      return indexedStr;
  }

• slice() : Dilim işlevini kullanarak, orijinal diziden, yeni bellek adresiyle öğelerin sığ bir kopyasını alırız, böylece cloneArr üzerinde yapılan herhangi bir değişiklik gerçek | orijinal diziyi etkilemez.

  var shallowCopy = mainArr.slice(); // this is how to make a copy
  
  var cloneArr = mainArr.slice(0, 3); 
  console.log('Main', mainArr, '\tCloned', cloneArr);
  
  cloneArr.length = 0; // Clears current memory location of an array.
  console.log('Main', mainArr, '\tCloned', cloneArr);

Henüz kimse bunu önermedi şaşırdım:

let xs = [1,2,3,4];
for (let i in xs)
    delete xs[i];

Bu, diğer çözümlerden oldukça farklı bir durumda bir dizi verir. Bir bakıma dizi 'boşaltılmış':

xs
=> Array [ <4 empty slots> ]

[...xs]
=> Array [ undefined, undefined, undefined, undefined ]

xs.length
=> 4

xs[0]
=> ReferenceError: reference to undefined property xs[0]

Sen ile eşdeğer dizi üretebilir [,,,,]veyaArray(4)

Angular 2+ FormArray'ı boşaltmanız gerekiyorsa aşağıyı kullanın.

public emptyFormArray(formArray:FormArray) {
    for (let i = formArray.controls.length - 1; i >= 0; i--) {
        formArray.removeAt(i);
    }
}