Comment implémenter l'héritage en javascript ? Résumer plusieurs façons d'implémenter l'héritage dans js

En regardant les connaissances acquises auparavant, elles peuvent être grossièrement divisées en deux catégories :

　1. Modèle basé sur le travail du constructeur.

　2. Mode de travail basé sur objet .

　3. S'il faut utiliser le prototype

　4. S'il faut effectuer une copie de attribut .

5. Les deux (exécuter la copie des attributs du prototype)

Revoyons toutes les connaissances précédentes :

1. Méthode de la chaîne prototype (imitation de la tradition) :

child.prototype = new Parent();

Modèle : Basé sur le Constructeur, utilisant le modèle de chaîne prototype.

Note technique : Le mécanisme d'héritage par défaut nous permet de migrer les parties réutilisables des méthodes et propriétés vers la chaîne de prototypes, et de définir les propriétés et méthodes non réutilisables sur notre propre propriété.

2. Uniquement héritage du prototype :

Child.prototype = Parent.prototype

Mode : mode de travail basé sur le constructeur, mode copie du prototype (pas de chaîne de prototypes, tous les objets partagent un prototype) .

Note technique : Étant donné que ce mode ne nécessite pas de nouvelles instances d'objet pour construire des relations d'héritage, il aura de meilleures performances en termes d'efficacité.

La requête sur la chaîne prototype est également plus rapide car il n'y a pas de chaîne du tout.

L'inconvénient est que les modifications apportées à l'objet enfant affecteront l'objet parent, car l'objet enfant n'est qu'une référence de l'objet parent.

3. Méthode de constructeur temporaire :

function extend(Child, parent){    var F = fucntion(){};
    F.prototype = Parent.prtotype;
    Child.prototype = new F();
    Child.prototype.constructor = Child;
    Child.uber = Parent.prototype;  
}

Mode : mode de travail basé sur le constructeur, utilisant le mode chaîne de prototypes.

Note technique : ce mode est différent du mode 1. Il hérite uniquement des propriétés du prototype de l'objet parent, mais n'hérite pas des propres propriétés de l'objet parent (c'est-à-dire les propriétés de celui-ci ajoutées au constructeur parent ). être hérité.

De plus, ce mode fournit également un moyen d'accéder à l'objet parent. (c'est-à-dire via l'attribut usb).

4. Méthode de copie d'attribut de prototype :

function extend2(Child, Parent){    var p = Parent.prototype;    var c = Child.prototype;    for(var i  in p){
        c[i] = p[i];
    }
    c.uber = p;
}

Mode : basé sur le mode de travail du constructeur, le mode de copie d'attribut, utilisez le Mode prototype .

Note technique : Convertissez tout le contenu du prototype de l'objet parent en propriétés du prototype de l'objet enfant.

　 Il n'est pas nécessaire de créer des instances d'objet distinctes pour l'héritage.

La chaîne prototype elle-même est également plus courte.

5. Méthode de copie d'attributs complets :

function extendCopy(p){    var c = {};    for(var i in p){
        c[i] = p[i];
    }
    c.uber  = p;    return c;
}

Mode officiel : mode de travail basé sur les objets, mode de copie d'attributs.

Note technique : Très simple, aucun attribut de prototype n'est utilisé.

6. Méthode de copie profonde :

function deepCopy(Parent, Child){
    Child = Child || {};    for(var i in Parent){        if(Parent.hasOwnProprty(i)){             if(typeof Parent[i] === 'Object'){
                 Child[i] = Array.isArray(p[i]) ? [] : {};
                 deepcopy(Parent[i], Child[i]);  
             }else{
                 Child[i] = Parent[i]
             }
        }
    }    return Child;
}

Mode officiel : mode de travail basé sur les objets, mode de copie d'attribut.

Note technique : identique à 5, mais tous les objets sont transmis par valeur.

7. Méthode d'héritage prototypique :

function object(o){    function F(){};
    F.prototype = o;    return new F();
}

Mode officiel : basé sur le mode de fonctionnement de l'objet, basé sur le mode chaîne de prototypes.

Note technique : Abandonnez le mécanisme d'imitation de classe et construisez directement des relations d'héritage entre les objets.

Profitez des avantages inhérents aux prototypes.

8. Mode d'extension et d'amélioration :

function objectPlus(o, stuff){    var n;    function(){};
    F.prototype = o;
    n = new F();
    n.uber = o;    for(var i in stuff){
        n[i] = stuff[i]
    }    return n;
}

Mode : mode de travail basé sur les objets, utilisant le mode chaîne de prototypes, mode copie d'attribut.

Note technique : Cette méthode est en fait une application mixte d'héritage de prototype et de copie de prototype. Elle complète l'héritage et l'extension de l'objet à la fois via une fonction.

9. Méthode d'héritage multiple :

function multi(){    var n = {}, stuff, j = 0;
    len = arguments.length;    for(j=0;j<len;j++){
        stuff = argument[j];        for(var i in stuff){
            n[i] = stuff[i];
        }
    }    return n;
}

Mode officiel : mode de travail basé sur les objets, mode de copie d'attribut.

Note technique : une implémentation d'héritage de plug-in hybride.

　 Elle copiera tous les attributs des objets parents dans l'ordre selon leur ordre d'héritage.

10. Méthode d'héritage parasite :

function parasite(victim){    var that = object(victim);
    that.more = 1;    return that;
}

Mode officiel : basé sur le mode de fonctionnement de l'objet, en utilisant le mode chaîne de prototypes.

Note technique : Cette méthode crée un objet via une fonction de type constructeur.

Cette fonction effectuera une copie de l'objet correspondant, le développera, puis renverra la copie.

11. Méthode d'emprunt du constructeur :

function Child{
    Parent.apply(this, arguments);
}

Mode d'appartenance : mode de travail basé sur le constructeur.

Note technique : Cette méthode ne peut hériter que des propres propriétés de l'objet parent (c'est-à-dire this.properties et les méthodes du constructeur).

Peut être combiné avec la première méthode.

　　　　 她便于我们的子对象继承某个对象的具体属性时，该方式是最简单的方式。

12.构造器借用与属性拷贝法：

function Child(){
    Parent.apply(this, argument);
}
extend2(Child, Parent);

所属模式：基于构造器的工作模式,使用原型链模式,属性拷贝模式。

技术注解：她允许我们在不重复使用调用对象构造器的情况下同时继承自身属性和原型属性。

额，持续更新了这么多天，大概也就这么多了，能力有限，多多包涵！

【相关推荐】

1. 免费js在线视频教程

2. JavaScript中文参考手册

3. php.cn独孤九贱（3）－JavaScript视频教程

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!