javascript - objetos - vaciar un arreglo en java




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

¿Hay una manera de vaciar una matriz y si es posible con .remove() ?

Por ejemplo,

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

¿Cómo puedo vaciar eso?

https://code.i-harness.com


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 la línea de tiempo de las herramientas de desarrollo de Chrome. Querrá usar el ícono de la papelera de basura 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 definida para el navegador de su elección. Muchas de las respuestas aquí son antiguas y no me gustaría confiar en ellas, sino probarlas como en la respuesta de @ tanguy_k anterior.

(Para una introducción a la pestaña mencionada anteriormente, puede consultar here )

me obliga a copiar el archivo 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 administra las cadenas de manera diferente a otros tipos primitivos, sin mencionar las matrices de objetos. El tipo puede afectar lo que sucede.


Existe mucha confusión e información errónea sobre el tiempo, el rendimiento de pop / shift tanto en las respuestas como en los comentarios. La solución while / pop tiene (como se esperaba) el peor desempeño . Lo que realmente está sucediendo es que la instalació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 se puede ver la diferencia real porque la clonación de la matriz ocupa la mayor parte del tiempo de prueba. Todavía muestra que el splice es la forma más rápida de borrar la matriz (sin tener en cuenta a [] porque mientras es la más rápida, en realidad no está eliminando la matriz existente).


Las respuestas que tienen nada menos que 2739 upvotes por ahora son engañosas e incorrectas.

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

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

    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 la papelera.

  • No traes uno nuevo como si hubieras hecho lo que te han pedido.
  • En su lugar, vaciar la papelera.
  • No reemplace la llenada con una lata nueva vacía, y no tome la etiqueta "A" de la lata llena y la pegue en la nueva como en A = [1,2,3,4]; A = []; A = [1,2,3,4]; A = [];

Vaciar un objeto de matriz es la cosa más fácil de todas:

A.length = 0;

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

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

    while(A.length > 0) {
        A.pop();
    }
    
  2. Tampoco, para poner tu mano izquierda en la parte inferior de la basura, sosteniéndola con tu derecha en la parte superior para poder extraer su contenido como en:

    A.splice(0, A.length);
    

No, te pidieron que lo vaciaras:

A.length = 0;

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


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 ha sido 'vaciada':

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 [,,,,] o Array(4)


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 estar seguro de no destruir algo:

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

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


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

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

Una forma fácil de vaciar una matriz ...

También se usa un bucle que no es necesario, pero es 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 difíciles en las que puedes pensar, por ejemplo, algo como esto:

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

Por lo tanto, si arr tiene 5 elementos, empalmará 5 elementos desde 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 Array, hay muchas otras formas de hacer esto, pero la más recomendada podría ser cambiar la longitud.

Como dije en primer lugar, también puede prototipo remove () ya que es la respuesta a su pregunta. simplemente puede elegir uno de los métodos anteriores y crear un prototipo para el objeto Array en JavaScript, algo 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(); //[]

Si necesita conservar la matriz original porque tiene otras referencias que también deben actualizarse, puede eliminarla sin crear una nueva matriz estableciendo su longitud en cero:

A.length = 0;

Si usas constantes, entonces no tienes otra opción:

const numbers = [1, 2, 3]

No se puede reasignar:

numbers = []

Solo se puede truncar:

numbers.length = 0

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

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

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

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

A.splice(0);

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


Aquí la implementación de trabajo más rápida manteniendo la misma matriz ("mutable"):

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

FYI Map define clear() por lo que parece lógico tener clear() para Array también.

O como una mezcla de Underscore.js :

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

O una función simple:

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

Versión de TypeScript :

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

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

Y las pruebas que la acompañan:

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

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





arrays