Pourquoi est-il nécessaire de définir le prototype du constructeur?

Il n'est pas toujours nécessaire, mais il a ses utilise. Supposons que nous souhaitions faire une copie de la méthode sur la base Person classe. Comme ceci:

//define the Person Class  
function Person(name) {
    this.name = name;
}  

Person.prototype.copy = function() {  
    //return new Person(this.name); //just as bad
    return new this.constructor(this.name);
};  

//define the Student class  
function Student(name) {  
    Person.call(this, name);
}  

//inherit Person  
Student.prototype = Object.create(Person.prototype);

Maintenant ce qui se passe lorsque nous créons un nouveau Student et les copier?

var student1 = new Student("trinth");  
console.log(student1.copy() instanceof Student); //=> false

La copie n'est pas une instance de Student. C'est parce que (sans explicite les vérifications), nous n'aurions aucun moyen pour revenir un Student copie à partir de la "base" de la classe. Nous ne pouvons que renvoyer une Person. Cependant, si nous avions réinitialiser le constructeur:

//correct the constructor pointer because it points to Person  
Student.prototype.constructor = Student;

...alors tout fonctionne comme prévu:

var student1 = new Student("trinth");  
console.log(student1.copy() instanceof Student); //=> true

TLDR; Pas super nécessaire, mais sera probablement aider dans le long terme, et il est plus précis de le faire.

NOTE: édité comme ma réponse précédente était de prêter à confusion, écrit et avait quelques erreurs que j'ai raté dans mon désir de répondre. Merci à ceux qui ont relevé certaines erreurs flagrantes.

Fondamentalement, c'est au fil de sous-classer correctement en Javascript. Quand nous partirons, nous avons à faire certaines choses funky pour vous assurer que les prototypes délégation fonctionne correctement, y compris le remplacement d'un prototype objet. L'écrasement d'un prototype objet comprend les constructor, donc, nous avons alors besoin de fixer la référence.

Nous allons rapidement passer en revue la façon dont des "classes" dans ES5 travail.

Disons que vous avez une fonction de constructeur et de son prototype:

//Constructor Function
var Person = function(name, age) {
  this.name = name;
  this.age = age;
}

//Prototype Object - shared between all instances of Person
Person.prototype = {
  species: 'human',
}

Lorsque vous appelez le constructeur à instancier, dire Adam:

//instantiate using the 'new' keyword
var adam = new Person('Adam', 19);

La new mot-clé appelée avec la "Personne" de coeur va exécuter le constructeur Personne avec quelques lignes de code supplémentaires:

function Person (name, age) {
  //This additional line is automatically added by the keyword 'new'
  //it sets up the relationship between the instance and the prototype object
  //So that the instance will delegate to the Prototype object
  this = Object.create(Person.prototype);

  this.name = name;
  this.age = age;

  return this;
}

/* So 'adam' will be an object that looks like this:
 * {
 *   name: 'Adam',
 *   age: 19
 * }
 */

Si nous console.log(adam.species), la recherche échouera à la adam exemple, et regarder les prototypes de la chaîne à ses .prototype, qui est Person.prototype - et Person.prototype a un .species de la propriété, de sorte que la recherche va réussir à Person.prototype. Il va alors se connecter 'human'.

Ici, le Person.prototype.constructor correctement le point de Person.

Alors maintenant, la partie la plus intéressante, la soi-disant "sous-classement'. Si nous voulons créer un Student classe, qui est une sous-classe de la Person classe avec quelques modifications supplémentaires, nous allons avoir besoin pour s'assurer que le Student.prototype.constructor points à l'Étudiant pour la précision.

Il ne fait pas cela par lui-même. Lorsque vous sous-classe, le code ressemble à ceci:

var Student = function(name, age, school) {
 //Calls the 'super' class, as every student is an instance of a Person
 Person.call(this, name, age);
 //This is what makes the Student instances different
 this.school = school
}

var eve = new Student('Eve', 20, 'UCSF');

console.log(Student.prototype); //this will be an empty object: {}

Appel new Student() ici serait de retour d'un objet avec toutes les propriétés que nous voulons. Ici, si nous vérifions les eve instanceof Person, il serait de retour false. Si l'on essaie d'accéder à eve.species, il serait de retour undefined.

En d'autres termes, nous avons besoin de câbler la délégation de sorte que eve instanceof Person renvoie true, et donc que les instances de Student délégué correctement à Student.prototype, puis Person.prototype.

MAIS depuis que nous l'appelons avec le new mot-clé, n'oubliez pas ce que l'invocation ajoute? Il ferait appel Object.create(Student.prototype), qui est la façon dont nous avons mis en place que delegational relation entre Student et Student.prototype. Notez que pour l'instant, Student.prototype est vide. Donc à la recherche .species une instance de Student serait un échec qu'il délègue à seulement Student.prototype, et la .species propriété n'existe pas sur Student.prototype.

Quand nous faisons attribuer Student.prototype à Object.create(Person.prototype), Student.prototype lui-même, puis les délégués à Person.prototype, et la recherche d' eve.species sera de retour human que nous attendons. Sans doute, nous voulons qu'elle hérite de l'Étudiant.prototype ET par Personne.le prototype. Donc nous avons besoin pour corriger tout cela.

/* This sets up the prototypal delegation correctly 
 *so that if a lookup fails on Student.prototype, it would delegate to Person's .prototype
 *This also allows us to add more things to Student.prototype 
 *that Person.prototype may not have
 *So now a failed lookup on an instance of Student 
 *will first look at Student.prototype, 
 *and failing that, go to Person.prototype (and failing /that/, where do we think it'll go?)
*/
Student.prototype = Object.create(Person.prototype);

Maintenant, la délégation travaille, mais nous sommes d'écraser Student.prototype avec un de Person.prototype. Donc, si nous appelons Student.prototype.constructor, il ne serait point à Person au lieu de Student. Ce est pourquoi nous avons besoin de la corriger.

//Now we fix what the .constructor property is pointing to    
Student.prototype.constructor = Student

//If we check instanceof here
console.log(eve instanceof Person) //true

Dans l'ES5, notre constructor propriété est une référence qui fait référence à une fonction que nous avons écrit avec l'intention d'être une 'constructeur'. Côté de ce que le new mot-clé nous donne, le constructeur est le contraire d'un "simple" fonction.

Dans l'ES6, la constructor est maintenant intégrée dans la façon d'écrire des classes - comme dans, il est fourni en tant que méthode lors de la déclaration d'une classe. C'est simplement du sucre syntaxique, mais il est en accord nous des commodités comme l'accès à un super quand nous permet d'étendre une classe existante. Donc, nous devons écrire le code ci-dessus comme ceci:

class Person {
  //constructor function here
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
  //static getter instead of a static property
  static get species() {
    return 'human';
  }
}

class Student extends Person {
   constructor(name, age, school) {
      //calling the superclass constructor
      super(name, age);
      this.school = school;
   }
}

Cela a l'énorme piège que si vous avez écrit

Student.prototype.constructor = Student;

mais alors, si il y avait un Professeur dont le prototype a été également Personne et que vous avez écrit

Teacher.prototype.constructor = Teacher;

ensuite, l'Élève constructeur est maintenant Professeur!

Edit:
Vous pouvez éviter cela en veillant à ce que vous aviez mis de l'Élève et l'Enseignant à l'aide de prototypes de nouvelles instances de la classe Personne créée à l'aide de l'Objet.créer, comme dans l'exemple Mozilla.

Student.prototype = Object.create(Person.prototype);
Teacher.prototype = Object.create(Person.prototype);

Obtenu un bon exemple de code d'pourquoi il est vraiment nécessaire de définir le prototype du constructeur..

function CarFactory(name){ 
   this.name=name;  
} 
CarFactory.prototype.CreateNewCar = function(){ 
    return new this.constructor("New Car "+ this.name); 
} 
CarFactory.prototype.toString=function(){ 
    return 'Car Factory ' + this.name;
} 

AudiFactory.prototype = new CarFactory();      //Here's where the inheritance occurs 
AudiFactory.prototype.constructor=AudiFactory;       //Otherwise instances of Audi would have a constructor of Car 

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

AudiFactory.prototype.toString=function(){ 
    return 'Audi Factory ' + this.name;
} 

var myAudiFactory = new AudiFactory('');
  alert('Hay your new ' + myAudiFactory + ' is ready.. Start Producing new audi cars !!! ');            

var newCar =  myAudiFactory.CreateNewCar(); //calls a method inherited from CarFactory 
alert(newCar); 

/*
Without resetting prototype constructor back to instance, new cars will not come from New Audi factory, Instead it will come from car factory ( base class )..   Dont we want our new car from Audi factory ???? 
*/

C'est nécessaire quand vous avez besoin d'une alternative à toString sans monkeypatching:

JS:

//Local
foo = [];
foo.toUpperCase = String(foo).toUpperCase;
foo.push("a");
foo.toUpperCase();
//Global
foo = [];
window.toUpperCase = function (obj) {return String(obj).toUpperCase();}
foo.push("a");
toUpperCase(foo);
//Prototype
foo = [];
Array.prototype.toUpperCase = String.prototype.toUpperCase;
foo.push("a");
foo.toUpperCase();
//toString alternative via Prototype constructor
foo = [];
Array.prototype.constructor = String.prototype.toUpperCase;
foo.push("a,b");
foo.constructor();
//toString override
var foo = [];
foo.push("a");
var bar = String(foo);
foo.toString = function() { return bar.toUpperCase(); }
foo.toString();
//Object prototype as a function
Math.prototype = function(char){return Math.prototype[char]};
Math.prototype.constructor = function() 
{
var i = 0, unicode = {}, zero_padding = "0000", max = 9999;
while (i < max) 
{
Math.prototype[String.fromCharCode(parseInt(i, 16))] = ("u" + zero_padding + i).substr(-4);
i = i + 1;
}    
}
Math.prototype.constructor();
console.log(Math.prototype("a") );
console.log(Math.prototype["a"] );
console.log(Math.prototype("a") === Math.prototype["a"]);

Donnée simple fonction constructeur:

function Person(){
this.name = 'test';
}
console.log(Person.prototype.constructor) //function Person(){...}
Person.prototype = { //constructor in this case is Object
sayName: function(){
return this.name;
}
}
var person = new Person();
console.log(person instanceof Person); //true
console.log(person.sayName()); //test
console.log(Person.prototype.constructor) //function Object(){...}

Par défaut (à partir de la spécification https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor), tous les prototypes d'obtenir automatiquement une propriété appelée constructeur qui renvoie à la fonction à laquelle il est une propriété.
Selon le constructeur, d'autres propriétés et méthodes pourraient être ajoutés au prototype qui n'est pas une pratique très courante, mais encore il est permis pour les extensions.

Donc simplement répondre: nous avons besoin de vous assurer que la valeur à l'état de prototype.le constructeur est correctement réglé comme il est supposé par la spécification.

Ne nous ont toujours réglé correctement cette valeur? Il permet le débogage et rend la structure interne cohérente rapport aux spécifications. L'on doit certainement lors de notre API est utilisée par les tiers, mais pas vraiment quand le code est finalement exécuté dans le runtime.

Il n'est pas nécessaire. C'est juste une des nombreuses choses traditionnelles, OOP champions faire pour essayer d'activer le JavaScript de l'héritage par prototype dans la classique héritage. La seule chose que la suite de

Student.prototype.constructor = Student; 

n', c'est que vous avez maintenant une référence de la "constructeur".

Dans Wayne réponse, qui a été marqué comme étant correcte, vous pouvez exactement la même chose que le code suivant ne

Person.prototype.copy = function() {  
//return new Person(this.name); //just as bad
return new this.constructor(this.name);
};  

avec le code ci-dessous (il suffit de remplacer cette.constructeur avec Personne)

Person.prototype.copy = function() {  
//return new Person(this.name); //just as bad
return new Person(this.name);
}; 

Dieu merci, avec ES6 classique héritage puristes peuvent utiliser la langue maternelle des opérateurs comme la classe, s'étend et super et nous n'avons pas à voir, comme prototype.constructeur de corrections et parent refereces.