Une brève discussion sur le support Javascript et les connaissances approfondies de copy_Basic

En JavaScript, toutes les affectations entre variables d'objet transmettent des adresses. Certains étudiants peuvent demander quels objets sont des objets. Il vaudrait peut-être mieux donner un exemple :

Copier le code Le code est le suivant :

typeof(true) //"booléen"
typeof(1) //"numéro"
typeof("1") //"chaîne"
typeof({}) //"objet"
typeof([]) //"objet"
typeof(null) //"objet"
typeof(function(){}) //"fonction"

Donc, en fait, l'objet principal que nous devons traiter en copie profonde est l'objet objet. Les objets non-objets doivent uniquement être attribués directement et normalement. Mon idée d'implémenter la copie profonde js est :

Parcourir toutes les propriétés de l'objet,
Si l'attribut est "objet", un traitement particulier est requis,
Si cet objet est spécial et est un tableau, alors créez un nouveau tableau et copiez profondément les éléments du tableau
Si cet objet est un objet non-tableau, appelez simplement la méthode de copie complète de manière récursive sur celui-ci.
Si ce n'est pas un "objet", copiez-le simplement normalement.

Ce qui suit est ma mise en œuvre :

Copier le code Le code est le suivant :

Object.prototype.DeepCopy = fonction () {
var obj, je;
obj = {};

pour (attr dans ceci) {
Si (this.hasOwnProperty(attr)) {
Si (typeof(this[attr]) === "object") {
Si (this[attr] === null) {
            obj[attr] = null;
>
           else if (Object.prototype.toString.call(this[attr]) === '[object Array]') {
             obj[attr] = [];
pour (i=0; i               obj[attr].push(this[attr][i].DeepCopy());
          }
         } autre {
           obj[attr] = this[attr].DeepCopy();
>
} autre {
        obj[attr] = this[attr];
>
>
>
Retourner l'objet ;
};

Si le navigateur prend en charge ECMAScript 5, afin de copier en profondeur toutes les propriétés des propriétés de l'objet, vous pouvez utiliser

Copier le code Le code est le suivant :

Object.defineProperty(obj, attr, Object.getOwnPropertyDescriptor(this, attr));

pour remplacer

Copier le code Le code est le suivant :

obj[attr] = ceci[attr];

L'avantage d'implémenter cette méthode directement sur Object.prototype est que tous les objets hériteront de cette méthode. L'inconvénient est que certaines bibliothèques réécrivent également les objets Object, ce qui entraîne parfois des conflits. C'est quelque chose à noter. Les méthodes d'utilisation spécifiques sont les suivantes :

Copier le code Le code est le suivant :

Objet.prototype.DeepCopy = function () { ... }
var une = {x:1};
var b = une;
var c = a.DeepCopy();
a.x = 2;
b.x = 3;
console.log(a.x); //3
console.log(b.x); //3
console.log(c.x); //1

Ce qui précède est l'explication sur la copie profonde, mais puisque nous avons parlé de copie profonde aujourd'hui, nous voulons également correspondre à la copie superficielle. Résumons brièvement les similitudes et les différences entre elles.

Copie superficielle (clone fantôme) : seuls le type de base et le type d'objet de l'objet sont copiés, qui appartiennent toujours à la référence d'origine.
Copie profonde (clone profond) : copie non seulement la classe de base de l'objet, mais copie également les objets dans l'objet d'origine.

.