国产av日韩一区二区三区精品,成人性爱视频在线观看,国产,欧美,日韩,一区,www.成色av久久成人,2222eeee成人天堂

Quelle est la différence entre écrire la définition (emplacement) du prototype à l'intérieur ou à l'extérieur du constructeur ?

La deuxième fa?on d'écrire effectuera l'opération sur le prototype à chaque fois qu'une instance est créée ! Le fait est que cette opération n’a aucun sens et que cette méthode est la même pour chaque instance.
Dans la première méthode, lorsque le prototype est écrit en dehors du constructeur, le problème de définition répétée ou d'allocation de mémoire peut être résolu à la fois formellement et via l'allocation de mémoire.
Correspond à la première fa?on d'écrire en mémoire. Peu importe le nombre d'instances que vous créez, chaque instance n'occupe que le nom, l'age, le métier et les le?ons. Il n'y a qu'une seule copie de getName en mémoire, partagée par toutes les instances?; la deuxième fa?on d'écrire, Chaque instance nouvellement créée allouera un espace supplémentaire (pile) pour exécuter la définition du prototype.

Quelle est la différence entre la fa?on dont les valeurs sont attribuées au prototype dans la première méthode et dans la deuxième méthode ?

La différence est très grande. Une fois qu'une classe de fonction est définie, sa propriété constructeur par défaut est elle-même, et son instance renverra cette valeur lors de l'accès à la propriété constructeur.

function Person() {};
console.log(Person.prototype.constructor);  // Person

var p = new Person();
console.log(p.constructor);   // Person    表示p的構(gòu)造函數(shù)是Person類

Pourquoi devez-vous définir le constructeur dans la méthode 1?? Parce qu'il réaffecte le prototype si vous ne définissez pas le constructeur (Person.prototype = {getName: function() {}}) , alors ce qui précède Dans l'exemple, la valeur de retour de p.constructor sera Object, c'est-à-dire que le constructeur de p est Object, ce qui est évidemment incompatible avec les faits . Person.prototype = {getName: function() {}}），那么上例中p.constructor返回值將是 Object, 即p的構(gòu)造函數(shù)是Object，顯然與事實不符。

方法1更明智的做法是不要重新給prototype賦值，只為prototype添加我們需要的屬性getName, 改為 Person.prototype.getName = function() {return this.name;}

首先，你應(yīng)該搞清楚js中的原型，在js中，原型指的是構(gòu)造函數(shù)的prototype屬性的值，由構(gòu)造函數(shù)創(chuàng)建出來的實例會自動鏈接到原型對象也就是其構(gòu)造函數(shù)的prototype屬性上。
    function Person(name,age,job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.lessons = ['Math','Physics'];
}
Person.prototype = {
    constructor: Person,
    getName: function(){
        return this.name;
    }
}
這個寫法中，Person為構(gòu)造函數(shù),可以創(chuàng)建出一個實例對象，
var p=new Person();
然后p可以繼承原型中的屬性，在原型中constructor指向的是當(dāng)前的構(gòu)造函數(shù)
你的寫法可以理解為在構(gòu)造函數(shù)中給原型的getname屬性賦值了一個函數(shù)

L'ancienne fa?on d'écrire réécrit le prototype, et votre fa?on d'écrire ajoute simplement une méthode au prototype. Les deux sont des manières différentes

Selon la fa?on dont vous l'écrivez, l'espace de stockage sera réaffecté à l'instance lors de chaque processus d'instanciation. L'une des significations du modèle de prototype est que toutes les instances peuvent partager les attributs et les méthodes du prototype, même si cela seul présente des défauts. . Le deuxième point est que je préfère toujours écrire le prototype objet objet littéral. Je pense personnellement que l'un est plus intuitif, et le second est propice à la maintenance. Comme suit?:

    Person.prototype = {
        constructor: Person,
        getName: function(){
            return this.name;
        }
    }

Assurez-vous d'écrire l'attribut constructeur, sinon une erreur de pointage se produira. A ce moment, l'objet prototype est réécrit si cet attribut n'est pas spécifié, la cha?ne prototype ne pourra pas jouer son r?le.

Il existe de nombreuses différences entre l'héritage prototypique et les constructeurs. L'héritage prototypique est un héritage de cha?ne de prototypes.

La cha?ne prototype n'est pas parfaite, elle contient les deux problèmes suivants.

Question 1?: Lorsque la cha?ne de prototypes contient un prototype d'une valeur de type référence, la valeur de type référence sera partagée par toutes les instances?;

Problème 2?: lors de la création d'un sous-type (comme la création d'une instance de Son), les paramètres ne peuvent pas être transmis au constructeur du supertype (comme Father).

Compte tenu de cela, en pratique la cha?ne prototype est rarement utilisée seule.

à cette fin, quelques tentatives seront présentées ci-dessous pour combler les lacunes de la cha?ne de prototypes.

Emprunteur constructeur

Afin de résoudre les deux problèmes ci-dessus dans la cha?ne de prototypes, nous avons commencé à utiliser une technologie appelée emprunt de constructeur (vol de constructeur) (également appelé héritage classique).

Idée de base?: appeler le constructeur de supertype à l'intérieur du constructeur de sous-type.

function Father(){
    this.colors = ["red","blue","green"];
}
function Son(){
    Father.call(this);//繼承了Father,且向父類型傳遞參數(shù)
}
var instance1 = new Son();
instance1.colors.push("black");
console.log(instance1.colors);//"red,blue,green,black"

var instance2 = new Son();
console.log(instance2.colors);//"red,blue,green" 可見引用類型值是獨立的

Evidemment, emprunter aux constructeurs résout d'un seul coup les deux problèmes majeurs de la cha?ne de prototypes :

Premièrement, il assure l'indépendance des valeurs de type référence dans la cha?ne de prototypes et n'est plus partagé par toutes les instances ;

Deuxièmement, lors de la création d'un sous-type, vous pouvez également transmettre des paramètres au type parent.

Suite à cela, si vous empruntez uniquement 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, donc la réutilisation des fonctions n'est pas disponible et le super type Méthodes est défini. in (comme Father) sont également invisibles pour les sous-types. Compte tenu de cela, la technique d'emprunt de constructeurs est rarement utilisée seule.
Pour plus d'informations, veuillez vous référer à la cha?ne de prototypes JS et à l'héritage. vous l'aimez, n'hésitez pas à mettre un pouce bleu et à le soutenir, merci?!