javascript - length - jquery remove data attribute

(Profundo) copiando una matriz usando jQuery

Question

Posible duplicado:
¿Cuál es la forma más eficiente de clonar un objeto JavaScript?

Necesito copiar una matriz de objetos (ordenada, no asociativa). Estoy usando jQuery. Inicialmente lo intenté

jquery.extend({}, myArray)

pero, naturalmente, esto me devuelve un objeto, donde necesito una matriz (por cierto, me encanta jquery.extend).

Entonces, ¿cuál es la mejor manera de copiar una matriz?

Answer 1

¿Qué tal los tipos complejos? cuando la matriz contiene objetos ... o cualquier otra cosa

Mi variante:

Object.prototype.copy = function(){
var v_newObj = {};
for(v_i in this)
v_newObj[v_i] = (typeof this[v_i]).contains(/^(array|object)$/) ? this[v_i].copy() : this[v_i];
return v_newObj;
}
Array.prototype.copy = function(){
var v_newArr = [];
this.each(function(v_i){
v_newArr.push((typeof v_i).contains(/^(array|object)$/) ? v_i.copy() : v_i);
});
return v_newArr;
}

No es la versión final, solo una idea.

PS: cada método y contiene prototipos también.

Answer 2

Dado que Array.slice () no realiza una copia profunda, no es adecuado para matrices multidimensionales:

var a =[[1], [2], [3]];
var b = a.slice();
b.shift().shift();
// a is now [[], [2], [3]]

Tenga en cuenta que aunque he usado shift().shift() arriba, el punto es solo que b[0][0] contiene un puntero a a[0][0] lugar de un valor.

Del mismo modo, delete(b[0][0]) también hace que se elimine b[0][0]=99 también cambia el valor de a[0][0] a 99.

El método de extend de jQuery realiza una copia profunda cuando se pasa un valor verdadero como argumento inicial:

var a =[[1], [2], [3]];
var b = $.extend(true, [], a);
b.shift().shift();
// a is still [[1], [2], [3]]

Answer 3

Me he encontrado con esta función de "copia profunda de objetos" que me ha resultado útil para duplicar objetos por valor. No usa jQuery, pero ciertamente es profundo.

http://www.overset.com/2007/07/11/javascript-recursive-object-copy-deep-object-copy-pass-by-value/

Answer 4

Planeo lanzar este código en la próxima versión de jPaq , pero hasta entonces, puede usar esto si su objetivo es hacer una copia profunda de los arreglos:

Array.prototype.clone = function(doDeepCopy) {
if(doDeepCopy) {
var encountered = [{
a : this,
b : []
}];
var item,
levels = [{a:this, b:encountered[0].b, i:0}],
level = 0,
i = 0,
len = this.length;
while(i < len) {
item = levels[level].a[i];
if(Object.prototype.toString.call(item) === "[object Array]") {
for(var j = encountered.length - 1; j >= 0; j--) {
if(encountered[j].a === item) {
levels[level].b.push(encountered[j].b);
break;
}
}
if(j < 0) {
encountered.push(j = {
a : item,
b : []
});
levels[level].b.push(j.b);
levels[level].i = i + 1;
levels[++level] = {a:item, b:j.b, i:0};
i = -1;
len = item.length;
}
}
else {
levels[level].b.push(item);
}
if(++i == len && level > 0) {
levels.pop();
i = levels[--level].i;
len = levels[level].a.length;
}
}
return encountered[0].b;
}
else {
return this.slice(0);
}
};

El siguiente es un ejemplo de cómo llamar a esta función para hacer una copia profunda de una matriz recursiva:

// Create a recursive array to prove that the cloning function can handle it.
var arrOriginal = [1,2,3];
arrOriginal.push(arrOriginal);
// Make a shallow copy of the recursive array.
var arrShallowCopy = arrOriginal.clone();
// Prove that the shallow copy isn''t the same as a deep copy by showing that
// arrShallowCopy contains arrOriginal.
alert("It is " + (arrShallowCopy[3] === arrOriginal)
+ " that arrShallowCopy contains arrOriginal.");
// Make a deep copy of the recursive array.
var arrDeepCopy = arrOriginal.clone(true);
// Prove that the deep copy really works by showing that the original array is
// not the fourth item in arrDeepCopy but that this new array is.
alert("It is "
+ (arrDeepCopy[3] !== arrOriginal && arrDeepCopy === arrDeepCopy[3])
+ " that arrDeepCopy contains itself and not arrOriginal.");

Puedes jugar con este código aquí en JS Bin .

Answer 5

Si quieres usar JavaScript puro, prueba esto:

 var arr=["apple","ball","cat","dog"];
var narr=[];
for(var i=0;i<arr.length;i++){
narr.push(arr[i]);
}
alert(narr); //output: apple,ball,vat,dog
narr.push("elephant");
alert(arr); // output: apple,ball,vat,dog
alert(narr); // apple,ball,vat,dog,elephant

Answer 6

Todo en JavaScript se pasa por referencia, por lo que si desea una copia profunda y profunda de los objetos en la matriz, el mejor método que se me ocurre es serializar toda la matriz a JSON y luego volver a serializarla.

Answer 7

$.extend(true, [], [[''a'', [''c'']], ''b''])

Eso debería hacerlo por ti.

Answer 8

Me doy cuenta de que está buscando una copia "profunda" de una matriz, pero si solo tiene una matriz de un solo nivel, puede usar esto:

Copiar un JS Array nativo es fácil. Use el método Array.slice() que crea una copia de parte / todo de la matriz.

var foo = [''a'',''b'',''c'',''d'',''e''];
var bar = foo.slice();

ahora foo y bar son matrices de 5 miembros de ''a'', ''b'', ''c'', ''d'', ''e''

Por supuesto, la barra es una copia, no una referencia ... así que si hiciste esto a continuación ...

bar.push(''f'');
alert(''foo:'' + foo.join('', ''));
alert(''bar:'' + bar.join('', ''));

ahora obtendrías:

foo:a, b, c, d, e
bar:a, b, c, d, e, f