javascript - objetos - vaciar un array php
¿Cómo vacío una matriz en JavaScript? (18)
¿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?
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).
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 A en una nueva matriz vacía. Esto es perfecto si no tiene referencias a la matriz original A ningún otro lugar porque realmente crea una matriz nueva (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 (según lo suggested por Matthew 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 (según lo suggested por Anthony )
A.splice(0,A.length)
El uso de .splice() funcionará perfectamente, pero como la función .splice() 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 en el rendimiento en absoluto.
Método 4 (como lo suggested 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 benchmark .
Como lo señaló Diadistis en su answer continuación, los puntos de referencia originales que se utilizaron para determinar el rendimiento de los cuatro métodos descritos anteriormente fueron defectuosos. El punto de referencia original reutilizó la matriz borrada, de modo que la segunda iteración estaba borrando una matriz que ya estaba vacía.
El siguiente punto de referencia corrige este defecto: benchmark . 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, por favor, vote las otras respuestas a las que también he hecho referencia.
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] .
Decir "
A = []es la respuesta" es ignorante y absolutamente incorrecto.[] == []es falsoEsto 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.
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(); }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)
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 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 estas usando
a = [];
Entonces está asignando una nueva referencia de matriz 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 el 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.
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
Una solución más amigable y más óptima para todos los navegadores será utilizar el método de splice para vaciar el contenido de la matriz A como se muestra a continuación:
A.splice(0, A.length);
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();
}
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 length para truncar una matriz en cualquier momento. Cuando extiende una matriz cambiando su propiedad de longitud, el número de elementos reales aumenta. -
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 cambia 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());
}
};
Array Array Crea una matriz con una nueva ubicación de memoria utilizando el
Array constructorarray literalo elarray 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 slice, obtenemos una copia superficial de los 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);
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
Array.prototype.clear = function() {
this.length = 0;
};
Y llámalo: array.clear();