¿Cómo vacío una matriz en JavaScript?

¿Hay alguna manera de vaciar una matriz y, si es así, posiblemente con .remove()?

Por ejemplo,

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

¿Cómo puedo vaciar eso?

Formas de borrar una matriz existente A:

Método 1

(esta fue mi respuesta original a la pregunta)

A = [];

Este código establecerá la variable Aen una nueva matriz vacía. Esto es perfecto si no tiene referencias a la matriz original enA ningún otro lugar porque esto realmente crea una nueva matriz (vacía). Debe tener cuidado con este método porque si ha hecho referencia a esta matriz desde otra variable o propiedad, la matriz original permanecerá sin cambios. Solo use esto si solo hace referencia a la matriz por su variable original A.

Esta es también la solución más rápida.

Este ejemplo de código muestra el problema que puede encontrar al usar este método:

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

Método 2 (como sugerido por Mateo Crumley )

A.length = 0

Esto borrará la matriz existente al establecer su longitud en 0. Algunos han argumentado que esto puede no funcionar en todas las implementaciones de JavaScript, pero resulta que este no es el caso. También funciona cuando se usa el "modo estricto" en ECMAScript 5 porque la propiedad de longitud de una matriz es una propiedad de lectura / escritura.

Método 3 (como sugerido por Anthony )

A.splice(0,A.length)

El uso .splice()funcionará perfectamente, pero dado que la .splice()función devolverá una matriz con todos los elementos eliminados, en realidad devolverá una copia de la matriz original. Los puntos de referencia sugieren que esto no tiene ningún efecto sobre el rendimiento.

Método 4 (como sugerido por tanguy_k )

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

Esta solución no es muy sucinta, y también es la solución más lenta, al contrario de los puntos de referencia anteriores mencionados en la respuesta original.

Actuación

De todos los métodos para borrar una matriz existente , los métodos 2 y 3 son muy similares en rendimiento y son mucho más rápidos que el método 4. Vea este punto de referencia .

Como señaló Diadistis en su respuesta a continuación, los puntos de referencia originales que se utilizaron para determinar el rendimiento de los cuatro métodos descritos anteriormente eran defectuosos. El punto de referencia original reutilizó la matriz borrada, por lo que la segunda iteración borró una matriz que ya estaba vacía.

El siguiente punto de referencia corrige este defecto: http://jsben.ch/#/hyj65 . Muestra claramente que los métodos # 2 (propiedad de longitud) y # 3 (empalme) son los más rápidos (sin contar el método # 1 que no cambia la matriz original).

Este ha sido un tema candente y la causa de mucha controversia. En realidad, hay muchas respuestas correctas y debido a que esta respuesta ha sido marcada como la respuesta aceptada durante mucho tiempo, incluiré todos los métodos aquí. Si vota por esta respuesta, vote también las otras respuestas a las que me he referido.

Si necesita mantener la matriz original porque tiene otras referencias a ella que también deben actualizarse, puede borrarla sin crear una nueva matriz configurando su longitud en cero:

A.length = 0;

Aquí la ejecución más rápida de trabajo , mientras que manteniendo el mismo array ( "mutable"):

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

Para su información, no se puede simplificar while (array.pop()): las pruebas fallarán.

FYI Map and Set define clear(), habría parecido lógico tener clear()para Array .

Versión de TypeScript:

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

Las pruebas correspondientes:

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

Aquí el jsPerf actualizado: http://jsperf.com/array-destroy/32 http://jsperf.com/array-destroy/152

Una solución más optimizada y optimizada para varios navegadores será utilizar el splicemétodo para vaciar el contenido de la matriz A como se muestra a continuación:

A.splice(0, A.length);

Las respuestas que no tienen menos de 2739 votos positivos hasta ahora son engañosas e incorrectas.

La pregunta es: "¿Cómo vaciar su matriz existente?" Por ejemplo para A = [1,2,3,4].

1. Decir " A = []es la respuesta" es ignorante y absolutamente incorrecto. [] == []es falsa .

   Esto se debe a que estas dos matrices son dos objetos separados e individuales, con sus propias dos identidades, que ocupan su propio espacio en el mundo digital, cada uno por su cuenta.

Digamos que tu madre te pide que vacíes el bote de basura.

• No traes uno nuevo como si hubieras hecho lo que te pidieron.
• En cambio, vacias el bote de basura.
• No reemplaza la llena con una nueva lata vacía, y no toma la etiqueta "A" de la lata llena y la pega a la nueva como en A = [1,2,3,4]; A = [];

Vaciar un objeto de matriz es lo más fácil:

A.length = 0;

De esta manera, la lata debajo de "A" no solo está vacía, ¡sino también tan limpia como nueva!

2. ¡Además, no es necesario que retire la basura a mano hasta que la lata esté vacía! Se le pidió que vaciara la existente, completamente, en un turno, que no recogiera la basura hasta que la lata se vacíe, como en:

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

3. Tampoco, para poner su mano izquierda en el fondo de la basura, sosteniéndola con la derecha en la parte superior para poder extraer su contenido como en:

   A.splice(0, A.length);

No, te pidieron que lo vaciases:

A.length = 0;

Este es el único código que vacía correctamente el contenido de una matriz de JavaScript dada.

Prueba de rendimiento:

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

Puede agregar esto a su archivo JavaScript para permitir que sus matrices se "borren":

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

Entonces puedes usarlo así:

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

O si quieres asegurarte de no destruir algo:

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

Mucha gente piensa que no debería modificar objetos nativos (como Array), y estoy dispuesto a aceptar. Tenga cuidado al decidir cómo manejar esto.

Hay mucha confusión y desinformación con respecto al tiempo; rendimiento de pop / shift tanto en respuestas como en comentarios. La solución while / pop tiene (como se esperaba) el peor rendimiento . Lo que realmente sucede es que la configuración se ejecuta solo una vez para cada muestra que ejecuta el fragmento en un bucle. p.ej:

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

He creado una nueva prueba que funciona correctamente:

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

Advertencia: incluso en esta versión de la prueba, no puede ver la diferencia real porque la clonación de la matriz ocupa la mayor parte del tiempo de prueba. Todavía muestra que splicees la forma más rápida de borrar la matriz (sin tomar[] en cuenta porque, aunque es la más rápida, en realidad no está borrando la matriz existente).

En caso de que esté interesado en la asignación de memoria, puede comparar cada enfoque utilizando algo como este jsfiddle junto con la pestaña de línea de tiempo de las herramientas de desarrollo de Chrome. Deberá utilizar el icono de la papelera en la parte inferior para forzar una recolección de basura después de 'limpiar' la matriz. Esto debería darle una respuesta más definitiva para el navegador de su elección. Muchas de las respuestas aquí son viejas y no confiaría en ellas, sino que probaría como en la respuesta de @ tanguy_k anterior.

(para una introducción a la pestaña mencionada anteriormente, puede consultar aquí )

Stackoverflow me obliga a copiar el jsfiddle, así que aquí está:

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

Y debe tener en cuenta que puede depender del tipo de elementos de la matriz, ya que JavaScript gestiona las cadenas de manera diferente a otros tipos primitivos, sin mencionar las matrices de objetos. El tipo puede afectar lo que sucede.

Puede crear fácilmente una función para hacer eso por usted, cambiar la longitud o incluso agregarla a la matriz nativa comoremove() función para su reutilización.

Imagina que tienes esta matriz:

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

OK, simplemente ejecuta esto:

arr.length = 0; //change the length

y el resultado es:

[] //result

manera fácil de vaciar una matriz ...

También se usa el bucle que no es necesario, pero solo otra forma de hacerlo:

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

También hay formas complicadas en las que puede pensar, por ejemplo, algo como esto:

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

Entonces, si arr tiene 5 elementos, empalmará 5 elementos de 0, lo que significa que no quedará nada en la matriz.

También otras formas como simplemente reasignar la matriz, por ejemplo:

arr = []; //[]

Si observa las funciones de matriz, hay muchas otras formas de hacerlo, pero la más recomendada podría ser cambiar la longitud.

Como dije en primer lugar, también puedes crear un prototipo de remove (), ya que es la respuesta a tu pregunta. simplemente puede elegir uno de los métodos anteriores y crear un prototipo para el objeto Array en JavaScript, algo así como:

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

y simplemente puede llamarlo así para vaciar cualquier matriz en su aplicación javascript:

arr.remove(); //[]

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

Y llámalo: array.clear();

A.splice(0);

Acabo de hacer esto en algún código en el que estoy trabajando. Se borró la matriz.

Si estas usando

a = []; 

Luego está asignando una nueva referencia de matriz a a, si la referencia en a ya está asignada a cualquier otra variable, entonces no vaciará esa matriz también y, por lo tanto, el recolector de basura no recopilará esa memoria.

Por ej.

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

o

a.length = 0;

Cuando especificamos a.length , solo estamos restableciendo los límites de la matriz y la memoria para los elementos de la matriz de descanso se conectará mediante un recolector de basura.

En lugar de estas dos soluciones son mejores.

a.splice(0,a.length)

y

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

Según la respuesta anterior de kenshou.html, el segundo método es más rápido.

Use una versión modificada de la sugerencia inicial de Jan :

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

Si usa constantes, entonces no tiene otra opción:

const numbers = [1, 2, 3]

No puede reasignar:

numbers = []

Solo puedes truncar:

numbers.length = 0

Para vaciar una ubicación de memoria actual de una matriz, use: 'myArray.length = 0'o'myArray.pop() UN-till its length is 0'

• length: Puede establecer la propiedad de longitud para truncar una matriz en cualquier momento. Cuando extiende una matriz cambiando su propiedad de longitud, aumenta el número de elementos reales.
• pop() : El método pop elimina el último elemento de una matriz y devuelve el valor eliminado.
• shift(): El método shift elimina el elemento en el índice cero y desplaza los valores en índices consecutivos hacia abajo, luego devuelve el valor eliminado.

Ejemplo:

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() | [] Cree una matriz con una nueva ubicación de memoria utilizando Array constructoro 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() : Al utilizar la función de división, obtenemos una copia superficial de elementos de la matriz original, con una nueva dirección de memoria, de modo que cualquier modificación en cloneArr no afectará a una matriz original real.

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

Me sorprende que nadie haya sugerido esto todavía:

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

Esto produce una matriz en un estado bastante diferente de las otras soluciones. En cierto sentido, la matriz se ha 'vaciado':

xs
=> Array [ <4 empty slots> ]

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

xs.length
=> 4

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

Puede producir una matriz equivalente con [,,,,] oArray(4)

Use a continuación si necesita vaciar Angular 2+ FormArray.

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