En JavaScript, todas las tareas entre las variables de objeto se pasan a través de direcciones. Algunos estudiantes pueden preguntar qué objetos son objetos. Puede ser mejor dar un ejemplo:
La copia del código es la siguiente:
typeof (true) // "booleano"
typeof (1) // "número"
TypeOf ("1") // "cadena"
typeof ({}) // "objeto"
typeof ([]) // "objeto"
typeof (null) // "objeto"
typeof (function () {}) // "función"
De hecho, el objeto que necesitamos lidiar con la copia en profundidad es el objeto del objeto, y los objetos no objeto se asignan directa y normalmente. Mi idea de implementar una replicación profunda de JS es:
Iterar a través de todas las propiedades de este objeto,
Si la propiedad es "objeto", se requiere procesamiento especial.
Si este objeto objeto es especial y es una matriz, cree una nueva matriz y copie profundamente los elementos en la matriz.
Si este objeto de objeto es un objeto que no es de matriz, simplemente llame al método de copia profunda de manera recursiva.
Si no es "objeto", simplemente cópielo normalmente.
Aquí está mi implementación:
La copia del código es la siguiente:
Objeto.prototype.deepcopy = function () {
var obj, i;
obj = {};
para (attr en esto) {
if (this.hasownproperty (attr)) {
if (typeof (this [attr]) === "objeto") {
if (this [attr] === null) {
obj [attr] = null;
}
else if (object.prototype.tostring.call (this [attr]) === '[Array de objetos]') {
obj [attr] = [];
para (i = 0; i <this [attr] .length; i ++) {
obj [attr] .push (este [attr] [i] .deepcopy ());
}
} demás {
obj [attr] = this [attr] .deepcopy ();
}
} demás {
obj [attr] = this [attr];
}
}
}
regresar obj;
};
Si el navegador admite Ecmascript 5, puede usarlo para copiar profundamente todas las características de las propiedades del objeto
La copia del código es la siguiente:
Object.defineProperty (obj, attr, object.getownpropertyDescriptor (this, attr));
Reemplazar
La copia del código es la siguiente:
obj [attr] = this [attr];
La ventaja de implementar este método directamente en Object.Prototype es que todos los objetos heredan el método. La desventaja es que algunas bibliotecas también reescribirán objetos de objetos, por lo que a veces ocurren conflictos. Esto debe prestarse atención. El método de uso específico es el siguiente:
La copia del código es la siguiente:
Objeto.prototype.deepcopy = function () {...}
var a = {x: 1};
var b = a;
var c = a.deepcopy ();
ax = 2;
bx = 3;
console.log (ax); // 3
console.log (bx); // 3
console.log (cx); // 1
Lo anterior es una explicación sobre la replicación profunda. Sin embargo, desde que hablamos sobre la replicación profunda hoy, queremos tener una replicación superficial correspondientemente. Resumamos brevemente las similitudes y diferencias entre ellos.
Copia superficial (clonación de sombras): solo copie el tipo básico del objeto y el tipo de objeto todavía pertenece a la referencia original.
Copia profunda (clonación profunda): no copia la clase básica del objeto, sino que también copia los objetos en el objeto original. Es decir, es completamente generado por el nuevo objeto.