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

2197

Есть ли способ очистить массив и, если возможно, с .remove()?

Например,

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

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

akano1
источник
1
вот эталонный тест с различными возможностями: jsben.ch/#/7QyI1
EscapeNetscape,

Ответы:

4415

Способы очистки существующего массива 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 (как предложено от Мэтью Крамли )

A.length = 0

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

Способ 3 (как предложено от Anthony )

A.splice(0,A.length)

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

Способ 4 (как предложено путем tanguy_k )

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

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

Представление

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

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

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


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

Филипп Лейбер
источник
184
while (A.length) { A.pop(); }, не нужно> 0
Иван Блэк
327
> 0ИМХО более читабельно. И нет никакой разницы в производительности между ними.
Филипп Лейберт
10
@ Даган, не совсем понятно, что ты пытаешься сказать. bсодержит ссылку на старый массив даже после aназначения нового. cи dпродолжать ссылаться на тот же массив. Таким образом, ожидается разница в результатах.
Шовавник
9
@DiegoJancic Метод № 1 не считается, потому что он не очищает массив. Это создает новый. Это не должно быть включено в тест.
Филипп Лейберт
44
Вы не можете использовать while(A.pop())в случае, если элемент в массиве ложный. Взять, к примеру, A = [2, 1, 0, -1, -2], в результате чего A будет равно [2, 1]. Даже while(A.pop() !== undefined)не работает, потому что вы можете иметь массив с неопределенным в качестве одного из значений. Вероятно, почему компилятор не оптимизировал его.
Джонатан Гаврич
2461

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

A.length = 0;
Мэтью Крамли
источник
18
Что ECMAScript 5 Standard говорит об этом?
Pacerier
213
@Pacerier: это все еще работает в ES5. Из раздела 15.4: «... всякий раз, когда свойство длины изменяется, каждое свойство, имя которого является индексом массива, значение которого не меньше, чем новая длина, автоматически удаляется»
Мэтью Крамли
2
@einar: массивы JavaScript всегда расширяются, чтобы соответствовать тому, что вы в них вставили, поэтому при вызове myarray.push(whatever)он добавляет единицу к длине. Поэтому установка длины усекает массив, но он не является постоянным.
Мэтью Крамли
12
@LosManos Даже в строгом режиме lengthэто специальное свойство, но не только для чтения, поэтому оно все равно будет работать.
Мэтью Крамли
11
@MattewCrumley Я провел некоторый тест, и кажется, что a.length = 0 не для эффективной очистки всего массива. jsperf.com/length-equal-0-or-new-array Я думаю, что если у вас есть один референс (и вы не добавили дополнительные свойства, которые хотите сохранить), то лучше создать новый массив и оставить старый для сборщик мусора, который будет работать при необходимости.
Павел Бревчински
289

Здесь самая быстрая рабочая реализация , сохраняя тот же массив («изменяемый»):

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

К вашему сведению, это нельзя упростить while (array.pop()): тесты не пройдут.

FYI Map и Set определяют clear(), что было бы логично иметь clear()для Array тоже.

Версия TypeScript:

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

Соответствующие тесты:

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

Вот обновленный jsPerf: http://jsperf.com/array-destroy/32 http://jsperf.com/array-destroy/152

tanguy_k
источник
5
ТТ твой ответ - единственный, который правильный и быстрый (в то же время), но имеет намного меньше "голосов". Ну, похоже, что людям нравятся довольно медленные решения: /
obenjiro
@naomik Но это одна из основных функций, которая должна была быть там по умолчанию.
thefourtheye
7
@thefourtheye Хорошее решение для производительности, хотя я согласен с @naomik, вы не должны изменять нативные объекты. Сказать, что это должно быть не в этом, проблема в том, что вы модифицируете глобальные переменные , что плохо. Если вы предоставляете свой код для использования другими, то у него не должно быть непредвиденных побочных эффектов. Представьте, что другая библиотека также модифицировала Array.prototypeи делала что-то немного другое, тогда весь ваш код [].clear()был немного неправильным. Это не было бы весело для отладки. Итак, общее сообщение: не модифицируйте глобальные переменные.
jpillora
3
@thefourtheye Весь смысл в том, чтобы не изменять глобальную область видимости, потому что вы не будете знать, использует ли чужой код (или будет) использовать имя. Я предлагаю функцию внутри локальной области. Итак, внутри IIFE вашего приложения / библиотеки сделайте , а function clear(arr) { while(arr.length) arr.pop(); }затем очистите массивы clear(arr)вместо arr.clear().
jpillora
2
Оказывается, этот метод намного медленнее, чем .splice()и .length=0. Тесты были неверны. Смотрите мой обновленный ответ.
Филипп Лейберт
216

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

A.splice(0, A.length);

Энтони
источник
49
Почему это более кросс-браузер дружественный? Какие браузеры имеют проблемы с A.length?
stricjux
4
@ jm2 то, что ты говоришь, не совсем верно. Это фактически изменяет рассматриваемый массив и впоследствии затрагивает все ссылки. Смотрите тест на моем jsFiddle: jsfiddle.net/shamasis/dG4PH
Шамасис Бхаттачарья
3
@alex нет, не spliceизменяет массив и возвращает удаленные записи. Сначала прочтите документы: developer.mozilla.org/en-US/docs/JavaScript/Reference/…
Дэвид Хеллсинг,
3
Мы могли бы предотвратить результирующий массив из возвращаются с помощью оператора запятой : A.splice(0, A.length),0;. Это оставило бы возвращаемое значение так 0же, как A.length = 0;и. Полученный массив все еще создается и должен заставить скрипт работать медленнее: ( jsperf ~ 56% медленнее). Реализация браузера повлияет на это, хотя я не вижу причин, почему это spliceбыло бы быстрее, чем настройка length.
Эван Кеннеди
8
Я также обнаружил, что это A.splice(0)также работает.
corwin.amber
97

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

Вопрос в следующем: «Как очистить существующий массив?» Например, для A = [1,2,3,4].

  1. Сказать « 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.

Беким Бакай
источник
11
Единственная проблема с вашим предложенным решением состоит в том, что мусор все еще существует, просто вы изменили доску объявлений, говоря, что мусора нет. Ссылка на старый массив все еще должна существовать. Можете ли вы быть уверены, что сборщик мусора при установке .length = 0 также удалит все ссылки на массив и его свойства? Я думаю, что это так, но для меня это волшебство. Метод .clear () желательно избегать путаницы, если не сказать больше.
ммм
8
Я никогда не заявлял, что это решение неверно. Проблема в том, что весь этот поток совершенно не нужен. Более 3000 голосов показывают, что попытка выяснить, каков наилучший способ, должна стать достаточным основанием для того, чтобы разработчики EMCA взломали этот метод. Никто не должен пройти через выяснение этого. Есть три - четыре разных способа сделать это. В некоторых тестах длина решения намного медленнее, чем в других. Кроме того, идея установки .length = 0 для любого разумного разработчика не будет удовлетворительной.
ммм
2
Потому что для достижения цели все ссылки должны быть удалены. .length = 0 даже не вызов метода, поэтому, если есть другие действия, выполняемые, когда он установлен в 0 (что происходит в большинстве браузеров с помощью define setter), я все равно считаю его слишком волшебным, чтобы на самом деле доверять тому, что он предполагал делать.
ммм
7
Поэтому я бы лучше сам это очистил. Чистый метод может быть прототипирован, но это просто уродливо. Моя точка зрения заключается в том, что эта реализация уже должна присутствовать, чтобы более 10 000 разработчиков не тратили часы на чтение только этой ветки, не считая всех остальных, кто потратил больше времени на сравнительный анализ.
ммм
1
есть только один способ очистить массив, заполнить его новыми входящими данными и снова отбросить. Все остальные либо не, либо смехотворно неэффективны и непростительно жадны до процессора. Единственная практическая альтернатива - A(n) = A.splice( 0, A.length );в случае, если вам нужно сделать резервную копию вашего предыдущего контента. ps Array.length- это свойство \ метод чтения-записи, если вы пропустили этот базовый факт. Это означает, что вы можете расширить его до новой длины, вы не можете урезать его до любой длины, которую хотите, и, среди прочего, вы можете отказаться от всех членов, сократив его длину до 0. Это швейцарский нож массива.
Беким Бачадж
63

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

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
kenshou.html
источник
9
Добавление процентных изменений не очень полезно, не говоря уже о вашей платформе. На моей машине всплывающее окно в Chrome 34 работает очень быстро, но на самом деле медленнее, чем [] в последнем Firefox.
Мэтт Стайлс
2
Тестирование в Firefox 39.0 32-bit на 64-битной Windows NT 6.3, a = [] является самым быстрым!
Реза-С4
5
В этом тесте под Chrome определенно есть что-то подозрительное. Как, черт возьми, петля всплывающих окон может быть намного быстрее, чем другие 3 решения?
Chqrlie
9
@chqrlie Это не так. Это самый медленный метод. Тест производительности ошибочен.
Филипп Лейберт
15
Пожалуйста, удалите этот ответ, поскольку он неправильный, и ссылки на бессмысленный ошибочный тест в качестве фальшивого доказательства.
Джеймс Уэйкфилд
35

Вы можете добавить это в свой файл 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), и я склонен согласиться. Пожалуйста, будьте осторожны при решении, как справиться с этим.

пиявка
источник
1
@naomik Можете ли вы объяснить свои рассуждения, почему такие вещи осуждаются?
определено
17
Это "осуждается" для изменения примитивных функций JavaScript, таких как Array и String. Возможно, вы перегружаете уже существующую функцию и уничтожаете класс объекта. Там может быть неясный движок JavaScript, который уже имеет clear () и ожидает, что он будет вести себя по-другому. Поступайте осторожно, это все, что я говорю.
Дизайн Адриана
Как насчет проблемы, когда выполнение foreach над членами массива внезапно начнет включать clearключ?
ErikE
19

Существует много путаницы и дезинформации в отношении времени, всплывающих / сдвиговых характеристик как в ответах, так и в комментариях. Решение 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это самый быстрый способ очистки массива (не принимая []во внимание, потому что, хотя он самый быстрый, он фактически не очищает существующий массив).

Diadistis
источник
Очень хороший момент! Я обновлю исходный ответ с правильными результатами теста.
Филипп Лейберт
Я не могу поверить, что никто не заметил эту ошибку. С более чем полумиллионом просмотров вы ожидаете, что кто-то заметит это. Отличная работа Diadistis
Philippe Leybaert
15

Если вы заинтересованы в распределении памяти, вы можете сравнить каждый подход, используя что-то вроде этого jsfiddle в сочетании с вкладкой временной шкалы инструментов Chrome Dev. Вы захотите использовать значок корзины для мусора внизу, чтобы вызвать сборку мусора после «очистки» массива. Это должно дать вам более определенный ответ для браузера по вашему выбору. Многие ответы здесь старые, и я бы не стал на них полагаться, а скорее проверил, как в ответе @ 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 управляет строками иначе, чем другие примитивные типы, не говоря уже о массивах объектов. Тип может влиять на то, что происходит.

matanster
источник
15

Вы можете легко создать функцию, которая сделает это за вас, изменить длину или даже добавить ее в собственный массив как 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 = []; //[]

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

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

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

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

arr.remove(); //[]
Алиреза
источник
длина волны = 0; // изменить длину
Аджай Малхотра
14
Array.prototype.clear = function() {
    this.length = 0;
};

И назовите это: array.clear();

Bendegúz
источник
77
Пожалуйста, не поощряйте модификацию нативных объектов.
Спасибо
21
почему люди склонны брать принятый ответ и помещать его в функцию прототипа? Вы действительно делаете это в своих проектах? У вас есть огромная библиотека дополнений к прототипам, которые вы включаете в каждый проект?
Нуреттин
4
Почему бы просто не указать тип array.length = 0?
Дизайн Адриана
10
@naomik "Пожалуйста, не поощряйте модификацию нативных объектов." - Я полностью согласен с этим, но просто повторение предложения само по себе кажется высокомерным. Кто-то, предлагающий такое решение, скорее всего, не знает о последствиях, и добавление этой строки вместо краткого объяснения или ссылки не дает значения, отличного от «мы, люди умнее вас, говорим вам не делать этого, потому что мы знаем лучше " .
Джон Вайс
12

A.splice(0);

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

Дэвид Кэмпбелл
источник
Нет, вы просто поменяли именованный контейнер массива на вновь созданный анонимный. `var A = [1,2,3,4]; вар Б; B = A. splice (0); console.log (А); console.log (В); '
Беким Бакай
12

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

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

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

a.splice(0,a.length)

а также

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

Как и в предыдущем ответе от kenshou.html, второй метод быстрее.

Лаксмикант Данге
источник
10
Кроме того a.length, я не вижу, что этот новый ответ добавляет в ветку?
Берги
@Bergi Я просто хочу сосредоточиться на фактическом представлении памяти в массиве
Laxmikant Dange
Есть ли у вас источник, чтобы подтвердить, какие движки JS будут создавать новый массив при a.length=0;выполнении? Как эти двигатели будут действовать для a.length=500;и a.length=4;?
joeytwiddle
Я пробовал это на большинстве браузеров, таких как IE, Firefox, Chrome, он создает новый массив. Если вы установите длину больше 0, то он создаст массив с неопределенными элементами, то есть он просто будет содержать некоторые области памяти.
Лаксмикант Данге
1
var a = [1]; var b = a; a.length = 0; console.log(b)печатает Array [ ], так что не похоже, что он создает новый массив для меня.
Джон Монтгомери,
9

Используйте измененную версию первоначального предложения Яна :

var originalLength = A.length;
for (var i = originalLength; i > 0; i--) {
     A.pop();
}
cssimsek
источник
12
Почему вы хотите сделать такую ​​вещь? Зачем добавлять еще две переменные и кучу кода, чтобы сделать то же самое?
Killah
6

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

const numbers = [1, 2, 3]

Вы не можете переназначить:

numbers = []

Вы можете только усечь:

numbers.length = 0
Дамжан Павлица
источник
5

введите описание изображения здесь

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

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

Пример:

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);
Яши
источник
msgstr "длина: появляется до длины массива указанного размера." Кто сказал тебе эту глупость?
Беким Бакай
@BekimBacaj По сути, это делает тот же эффект. Наверное, следовало бы сказать, length = ?а не просто length.
Туупертунут
@BekimBacaj Я обновил свой ответ, я просто предполагал, что длина увеличивается до длины, но теперь я исправил, что длина просто усекает или увеличивает размер массива.
Яша
3

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

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)

Cauterite
источник
7
Это может быть хорошим ответом на другой вопрос: «Как преобразовать все элементы в массиве в неопределенные элементы».
Рубен
Хотя внутри есть разница между неопределенными элементами и пустыми слотами («дырами»)
Cauterite
-9

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

public emptyFormArray(formArray:FormArray) {
    for (let i = formArray.controls.length - 1; i >= 0; i--) {
        formArray.removeAt(i);
    }
}
Маниш джайн
источник
10
Это не имеет значения и даже не JavaScript.
Эмиль Бержерон,