F.prototype

Rappelez-vous que de nouveaux objets peuvent tre crs avec une fonction constructeur, comme new F().

Si F.prototype est un objet, alors loprateur new lutilise pour dfinir [[Prototype]] pour le nouvel objet.

Veuillez noter que F.prototype signifie ici une proprit rgulire nomme "prototype" sur F. Cela ressemble quelque peu au terme prototype, mais nous entendons ici une proprit rgulire portant ce nom.

Voici lexemple :

let animal = {
  eats: true
};

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

Rabbit.prototype = animal;

let rabbit = new Rabbit("White Rabbit"); //  rabbit.__proto__ == animal

alert( rabbit.eats ); // true

Dfinir Rabbit.prototype=animal nonce littralement ce qui suit : Lorsquun new Rabbit est cr, assigner son [[Prototype]] animal.

Voici limage rsultante :

[]

Sur limage, "prototype" est une flche horizontale, ce qui signifie une proprit normale, et [[Prototype]] est vertical, ce qui signifie lhritage de rabbit de animal.

F.prototype par dfaut, proprit du constructeur

Chaque fonction a la proprit "prototype" mme si nous ne la fournissons pas.

Le "prototype" par dfaut est un objet avec comme seule proprit constructor qui renvoie la fonction elle-mme.

Comme a :

function Rabbit() {}

/* prototype par dfaut
Rabbit.prototype = { constructor: Rabbit };
*/

[]

Nous pouvons le vrifier :

function Rabbit() {}
// par dfaut:
// Rabbit.prototype = { constructor: Rabbit }

alert( Rabbit.prototype.constructor == Rabbit ); // true

Naturellement, si nous ne faisons rien, la proprit constructor est disponible pour tous les rabbits via [[Prototype]] :

function Rabbit() {}
// par dfaut:
// Rabbit.prototype = { constructor: Rabbit }

let rabbit = new Rabbit(); // hrite de {constructor: Rabbit}

alert(rabbit.constructor == Rabbit); // true (de prototype)

[]

Nous pouvons utiliser la proprit constructor pour crer un nouvel objet en utilisant le mme constructeur que lexistant.

Comme ici :

function Rabbit(name) {
  this.name = name;
  alert(name);
}

let rabbit = new Rabbit("White Rabbit");

let rabbit2 = new rabbit.constructor("Black Rabbit");

Cest pratique lorsque nous avons un objet, ne sachant pas quel constructeur a t utilis pour cela (par exemple, il provient dune bibliothque externe), et nous devons en crer un autre du mme type.

Mais probablement la chose la plus importante propos de "constructor" est que

JavaScript lui-mme nassure pas la bonne valeur de "constructor".

Oui, il existe dans le "prototype" par dfaut des fonctions, mais cest tout. Ce quil en adviendra par la suite dpend entirement de nous.

En particulier, si nous remplaons le prototype par dfaut dans son ensemble, il ne contiendra pas de constructor.

Par exemple :

function Rabbit() {}
Rabbit.prototype = {
  jumps: true
};

let rabbit = new Rabbit();
alert(rabbit.constructor === Rabbit); // false

Donc, pour garder le bon "constructor", nous pouvons choisir dajouter/supprimer des proprits au "prototype" par dfaut au lieu de lcraser dans son ensemble :

function Rabbit() {}

// Ne pas craser Rabbit.prototype totalement
// juste y ajouter
Rabbit.prototype.jumps = true
// le Rabbit.prototype.constructor par dfaut est conserv

Ou bien, recrez manuellement la proprit constructor :

Rabbit.prototype = {
  jumps: true,
  constructor: Rabbit
};

// maintenant le constructeur est galement correct, car nous l'avons ajout

Rsum

Dans ce chapitre, nous avons brivement dcrit la manire de dfinir un [[Prototype]] pour les objets crs via une fonction constructeur. Plus tard, nous verrons des modles de programmation plus avancs qui en dpendent.

Tout est assez simple, juste quelques prcisions pour clarifier les choses :

• La proprit F.prototype (ne pas confondre avec [[Prototype]]) dfinit [[Prototype]] sur les nouveaux objets lorsque new F() est appele.
• La valeur de F.prototype devrait soit tre un objet ou null : les autres valeurs ne fonctionneront pas.
• La proprit "prototype" na cet effet spcial que lorsquelle est dfinie dans une fonction constructeur et invoque avec new.

Sur les objets ordinaires, le prototype na rien de spcial :

let user = {
  name: "John",
  prototype: "Bla-bla" // pas de magie
};

Par dfaut, toutes les fonctions ont F.prototype={constructor:F}, nous pouvons donc obtenir le constructeur dun objet en accdant sa proprit "constructor".