Analyse du constructeur emprunté javascript (avec exemples)

Le contenu de cet article concerne l'analyse des constructeurs d'emprunt JavaScript (avec des exemples). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Vol de constructeur

Afin de résoudre le problème de la teneur en valeurs de type de référence dans les prototypes, les développeurs ont commencé à utiliser une technique appelée vol de constructeur .

Parfois, on l'appelle aussi faux objet ou héritage classique.

L'idée de base de cette technique est très simple, qui consiste à appeler le constructeur de supertype à l'intérieur du constructeur de sous-type.

Une fonction n'est rien d'autre qu'un objet qui exécute du code dans un environnement spécifique, les constructeurs peuvent donc également être exécutés sur des objets nouvellement créés en utilisant les méthodes apply() et call().

function SuperType() {
    this.colors = ["red","blue","green"];
}

function SubType() {
    //继承了SuperType
    SuperType.call(this);
}

var instance1 = new SubType();

instance1.colors.push("black");
console.log(instance1.colors); //["red","blue","green","black"]

var instance2 = new SubType();
console.log(instance2.colors); //["red","blue","green"]

Notez que ce code "seconde" le constructeur de supertype.

function SubType() {
    //继承了SuperType
    SuperType.call(this);
}

En utilisant la méthode call() (ou également la méthode apply()), le constructeur SuperType est en fait appelé dans le contexte de l'objet instance SubType à créer.

De cette façon, tout le code d'initialisation d'objet défini dans la fonction SuperType() sera exécuté sur le nouvel objet SubType.

Ainsi, chaque objet instance de SubType a sa propre copie de la propriété colours

Passage des paramètres

relatifs au prototype En termes du chaînage, un gros avantage de l'emprunt de constructeurs est que vous pouvez transmettre des paramètres au constructeur de supertype dans le constructeur de sous-type.

function SuperType(name) {
    this.name = name;
}

function SubType(){
    //继承了SuperType，同时还传递了参数
    SuperType.call(this, "Shaw");

    //实例属性
    this.age = 18;
}

var instance = new SubType();

console.log(instance.name); // "Shaw"
console.log(instance.age); // 18

SuperType dans le code ci-dessus n'accepte qu'un seul nom de paramètre, qui sera directement affecté à un attribut.

Lorsque le constructeur SuperType est appelé à l'intérieur du constructeur SubType, l'attribut name est en fait défini pour l'objet instance SubType (le pointeur de ceci est lié au contexte d'exécution).

Afin de garantir que le constructeur SuperType ne remplace pas les propriétés du sous-type, vous pouvez ajouter des propriétés qui doivent être définies dans le sous-type après avoir appelé le constructeur du supertype.

Le problème de l'emprunt de constructeurs

Si vous empruntez simplement le constructeur, vous ne pourrez pas éviter les problèmes du modèle de constructeur.

Les méthodes sont toutes définies dans le constructeur, et il n'y a aucun moyen de réutiliser les fonctions. Chaque fois qu'un objet est instancié, la méthode est essentiellement recréée sur chaque objet instance, ce qui entraîne une perte de mémoire et de ressources. . déchets.

De plus, les méthodes définies dans le prototype du super type sont également invisibles au sous-type (car il n'y a pas d'objet prototype ici, en fait la chaîne prototype du sous-type pointe vers Object), le résultat est que tous les types Vous ne pouvez utiliser que le modèle constructeur.

Compte tenu de ces problématiques, la technique de l'emprunt de constructeurs est rarement utilisée seule.

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!