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

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

A.length = 0;

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

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

FYI карта определяет clear() так что было бы логично иметь clear() на массив тоже.

или подчеркивания.Яш подмешать:

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

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

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

TypeScript версия:

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 = [] это ответ " невежественен и абсолютно неверен. [] == [] и ложные.

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

---

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

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

опорожнение объекта массива это легче всего:

A.length = 0;

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

---

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

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

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

   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.prototype.clear = function() {
    this.length = 0;
};

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

существует много путаницы и дезинформации относительно while;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 уже назначена какой-либо другой переменной, то она также не будет очищать этот массив и, следовательно, сборщик мусора не будет собирать эту память.

например.

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

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

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

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

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

const numbers = [1, 2, 3]

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

numbers = []

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

numbers.length = 0

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

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

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

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

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 = []; //[]

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

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

чтобы очистить текущую ячейку памяти массива используйте:'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(): С помощью функции 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);
  

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

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