No JavaScript, todas as atribuições entre variáveis de objeto são passadas através de endereços. Alguns alunos podem perguntar quais objetos objetos são. Pode ser melhor dar um exemplo:
A cópia do código é a seguinte:
typeof (true) // "booleano"
typeof (1) // "número"
typeof ("1") // "string"
typeof ({}) // "objeto"
typeof ([]) // "objeto"
typeof (nulo) // "objeto"
typeof (function () {}) // "função"
Portanto, o objeto que precisamos lidar com cópia aprofundada é o objeto, e objetos não objeto são atribuídos direta e normalmente. Minha ideia de implementar a replicação profunda de JS é:
Itera através de todas as propriedades deste objeto,
Se a propriedade for "objeto", o processamento especial será necessário.
Se esse objeto for especial e for uma matriz, crie uma nova matriz e copie profundamente os elementos da matriz.
Se esse objeto for um objeto que não é de marca, basta chamar o método de cópia profunda recursivamente nele.
Se não for "objeto", apenas copie -o normalmente.
Aqui está minha implementação:
A cópia do código é a seguinte:
Object.prototype.DeepCopy = function () {
var obj, i;
obj = {};
para (attr neste) {
if (this.hasownProperty (att)) {
if (typeof (this [att]) === "objeto") {
if (este [att] === null) {
obj [attr] = null;
}
caso contrário, if (object.prototype.tostring.call (this [att]) === '[objeto Array]') {
obj [att] = [];
for (i = 0; i <this [att] .Length; i ++) {
obj [att] .push (este [att] [i] .deepCopy ());
}
} outro {
obj [att] = this [att] .deepCopy ();
}
} outro {
obj [att] = este [att];
}
}
}
retornar obj;
};
Se o navegador suportar o ECMAScript 5, você poderá usá -lo para copiar profundamente todos os recursos das propriedades do objeto
A cópia do código é a seguinte:
Object.DefineProperty (obj, att, object.GetownPropertyDescriptor (this, att));
Para substituir
A cópia do código é a seguinte:
obj [att] = este [att];
A vantagem de implementar esse método diretamente no Object.Prototype é que todos os objetos herdam o método. A desvantagem é que algumas bibliotecas também reescrevem objetos de objetos; portanto, às vezes ocorrem conflitos. Isso precisa receber atenção. O método de uso específico é o seguinte:
A cópia do código é a seguinte:
Object.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
O exposto acima é uma explicação sobre a replicação profunda. No entanto, como conversamos sobre replicação profunda hoje, queremos ter replicação superficial correspondentemente. Vamos resumir brevemente as semelhanças e diferenças entre elas.
Cópia rasa (clonagem de sombra): copie apenas o tipo básico do objeto e o tipo de objeto ainda pertencem à referência original.
Cópia profunda (clonagem profunda): ele não copia a classe básica do objeto, mas também copia os objetos no objeto original. Ou seja, é completamente gerado pelo novo objeto.