Как очистить массив в JavaScript?

есть ли способ очистить массив, и если да, то с помощью .remove()?

например,

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

Как я могу очистить?

18 ответов


способы очистки существующего массива A:

Способ 1

(это был мой первоначальный ответ на вопрос)

A = [];

этот код установит переменную A к новому пустому массиву. Это идеально, если у вас нет ссылки на исходный массив A в любом другом месте, потому что это фактически создает новый (пустой) массив. Вы должны быть осторожны с этим методом, потому что если вы ссылаетесь на это массив из другой переменной или свойства, исходный массив останется неизменным. Используйте это, только если вы ссылаетесь только на массив по его исходной переменной A.

это также самое быстрое решение.

в этом примере кода показана проблема, с которой вы можете столкнуться при использовании этого метода:

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

Способ 2 (as предложил by Мэтью Крамль)

A.length = 0

это очистит существующий массив, установив его длину до 0. Некоторые утверждают, что это может не работать во всех реализациях JavaScript, но оказывается, что это не так. Он также работает при использовании "строгого режима" в ECMAScript 5, потому что свойство length массива является свойством чтения/записи.

Способ 3 (as предложил by Энтони)

A.splice(0,A.length)

используя .splice() будет работать отлично, но так как .splice() функция возвращает массив со всеми удаленными элементами, он фактически вернет копию исходного массива. Контрольные показатели свидетельствуют о том, что это никак не влияет на результаты работы.

метод 4 (as предложил by tanguy_k)

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

это решение не очень лаконично, и это также самое медленное решение, в отличие от более ранних критериев, упомянутых в оригинале ответ.

производительность

из всех методов очистки существующий массив, методы 2 и 3 очень похожи по производительности и намного быстрее, чем метод 4. Смотрите это benchmark.

как указал Diadistis в своем ответ ниже приведены исходные контрольные показатели, которые использовались для определения эффективности четырех описанных выше методов: недостатки. Исходный тест повторно использовал очищенный массив, поэтому вторая итерация очищала массив, который уже был пуст.

следующий тест исправляет этот недостаток:http://jsben.ch/#/hyj65. Он ясно показывает, что методы #2 (свойство length) и #3 (splice) являются самыми быстрыми (не считая метода #1, который не изменяет исходный массив).


это была горячая тема и причина многих споров. На самом деле их много правильные ответы и потому, что этот ответ был отмечен как принятый ответ в течение очень долгого времени, я включу все методы здесь. Если вы голосуете за этот ответ, Пожалуйста, повторите другие ответы, на которые я ссылался.


Если вам нужно сохранить исходный массив, потому что у вас есть другие ссылки на него, которые также должны быть обновлены, вы можете очистить его без создания нового массива, установив его длину на ноль:

A.length = 0;

здесь самая быстрая рабочая реализация пока сохраняя тот же массив ("mutable"):

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

к твоему сведению!--15-->карта определяет clear() поэтому казалось бы логичным иметь clear() на массив тоже.

или подчеркивания.js mixin:

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

или простая функция:

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

машинопись версия:

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

FYI это не может упрощается до while (array.pop()): тесты не удастся.

и тесты, которые идут с ним:

describe('Array', () => {
  it('should clear the array', () => {
    let array = [1, 2, 3, 4, 5];
    array.clear();
    expect(array.length).toEqual(0);
    expect(array[0]).toEqual(undefined);
    expect(array[4]).toEqual(undefined);

    // Even with undefined or null inside
    array = [1, undefined, 3, null, 5];
    array.clear();
    expect(array.length).toEqual(0);
    expect(array[0]).toEqual(undefined);
    expect(array[4]).toEqual(undefined);
  });
});

здесь обновленный jsPerf: http://jsperf.com/array-destroy/32 http://jsperf.com/array-destroy/152


более кросс-браузер дружественным и более оптимальным решением будет использовать splice метод для очистки содержимого массива A, как показано ниже:

A.splice(0, A.length);


ответы, которые имеют не менее 2739 upvotes к настоящему времени вводят в заблуждение и неверны.

вопрос: "Как вы очищаете существующий массив?"Е. Г. для A = [1,2,3,4].

  1. говоря:"A = [] это ответ " является невежественным и абсолютно неправильным. [] == [] is false.

    это потому, что эти два массива являются двумя отдельными, отдельными объектами, со своими двумя идентичностями, занимающими свое собственное пространство в цифровом мире, каждый сам по себе.


Предположим, ваша мать просит вас очистить мусорное ведро.

  • вы не приносите Новый, как будто вы сделали то, что вас просили.
  • вместо этого, вы пустое мусорное ведро.
  • вы не заменяете заполненный на новую пустую банку, и вы не берете ярлык " а " из заполненной банки и не прикрепляете его к новому, как в A = [1,2,3,4]; A = [];

опорожнение объекта массива это самая простая вещь:

A.length = 0;

таким образом, банка под "A" не только пуста, но и чиста, как новая!


  1. кроме того, вы не обязаны удалять мусор вручную, пока банка не будет пуста! Вас попросили опустошить существующий, полностью, за один ход, не убирать мусор, пока не опустеет банка, как в:

    while(A.length > 0) {
        A.pop();
    }
    
  2. Nor, чтобы положить левую руку на дно мусора, держа его с правой стороны вверху, чтобы иметь возможность вытащить его содержимое, как в:

    A.splice(0, A.length);
    

нет, вы спросили его:

A.length = 0;

это единственный код, который правильно очищает содержимое заданного массива JavaScript.


производительность тест:

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

вы можете добавить это в свой файл JavaScript, чтобы ваши массивы были "очищены":

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

тогда вы можете использовать его следующим образом:

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

или если вы хотите быть уверены, что вы не уничтожить что-то:

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

многие люди думают, что вы не должны изменять собственные объекты (например, Array), и я склонен согласиться. Пожалуйста, будьте осторожны, решая, как с этим справиться.


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

и называть это: array.clear();


существует много путаницы и дезинформации относительно того, в то время как;производительность pop/shift как в ответах, так и в комментариях. Решение while/pop имеет (как и ожидалось)худшие показатели. На самом деле установка выполняется только один раз для каждого образца, который запускает фрагмент в цикле. например:

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

Я создала новый тест, который работает правильно :

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

предупреждение: даже в этой версии теста вы не можете увидеть реальную разницу, потому что клонирование массива занимает большую часть времени теста. Это все еще показывает, что splice Это самый быстрый способ очистить массив (не принимая [] в рассмотрение, потому что, хотя это самый быстрый, он фактически не очищает существующий массив).


если вас интересует распределение памяти, вы можете сравнить каждый подход, используя что-то вроде этот jsfiddle в сочетании с вкладкой временной шкалы chrome dev tools. Вы захотите использовать значок корзины внизу, чтобы принудительно собрать мусор после "очистки" массива. Это должно дать вам более определенный ответ для браузера по вашему выбору. Многие ответы здесь старые, и я бы не полагался на них, а скорее тест, как в ответе @tanguy_k выше.

(для вступления в вышеупомянутую вкладку вы можете проверить здесь)

Stackoverflow заставляет меня копировать jsfiddle, поэтому вот он:

<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 управляет строками иначе, чем другие примитивные типы, не говоря уже о массивах объектов. Типа может повлиять на то, что происходит.


A.splice(0);

Я просто сделал это на некотором коде, над которым я работаю. Он очистил массив.


если вы используете

a = []; 

тогда вы назначаете новую ссылку на массив a, если ссылка в a уже назначена любой другой переменной, то она не будет опустошать этот массив тоже и, следовательно, сборщик мусора не будет собирать эту память.

для ex.

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

или

a.length = 0;

когда мы указываем a.length, мы просто сбрасываем границы массива, и память для элементов массива rest будет подключена сборщиком мусора.

вместо этих двух решений лучше.

a.splice(0,a.length)

и

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

согласно предыдущему ответу kenshou.html, второй метод быстрее.


используйте измененную версию январяС:

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

Если вы используете константы, то у вас нет выбора:

const numbers = [1, 2, 3]

вы не можете распределить:

numbers = []

вы можете только обрезать:

numbers.length = 0

вы можете легко создать функцию, чтобы сделать это для вас, изменить длина или даже добавить его в собственный массив as remove() функция для повторного использования.

представьте, что у вас этот массив:

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

OK, просто запустите это:

arr.length = 0; //change the length

в результате:

[] //result

простой способ очистить массив...

также используя цикл, который не является необходимым, но просто еще один способ сделать что:

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

есть также сложный способ, о котором вы можете думать, например, что-то вроде этого:

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

поэтому, если arr имеет 5 элементов, он соединит 5 элементов из 0, что означает, что ничего не останется в массиве.

также другие способы, такие как просто переназначить массив, например:

arr = []; //[]

если вы посмотрите на функции массива, есть много других способов сделать это, но наиболее рекомендуемым может быть изменение длина.

как я уже сказал в первую очередь, вы также можете prototype remove (), поскольку это ответ на ваш вопрос. вы можете просто выбрать один из методов выше и прототип его для массива объекта в JavaScript, что-то вроде:

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

и вы можете просто назвать это так, чтобы очистить любой массив в вашем приложении javascript:

arr.remove(); //[]

Я удивлен, что никто еще не предложил этого:

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

это дает массив в совершенно другом состоянии от других решений. В некотором смысле массив был "опустошен":

xs
=> Array [ <4 empty slots> ]

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

xs.length
=> 4

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

вы можете создать эквивалентный массив с помощью [,,,,] или Array(4)


enter image description here

чтобы очистить текущее местоположение памяти массива, используйте:'myArray.length = 0' или 'myArray.pop() UN-till its length is 0'

  • length: свойство length можно задать для усечения массива в любое время. При расширении массива путем изменения его свойства length количество фактических элементов увеличивается.
  • pop(): метод pop удаляет последние элемент из массива и возвращает то, что возвращает удаленное значение.
  • shift(): метод shift удаляет элемент в индекс zeroeth и сдвигает значения последовательных индексов вниз, а затем возвращает удаленное значение.

пример:

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 constructor или 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(): используя функцию среза, мы получаем неглубокую копию элементов из исходного массива с новым адресом памяти, так что любая модификация на cloneArr не повлияет на фактический|исходный массив.

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

используйте ниже, Если вам нужно очистить Angular 2 + FormArray.

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