Valeur

Un objet.

Description

Lorsque une fonction est appelée avec new, la propriété prototype du constructeur devient le prototype de l'objet résultant.

function Ctor() {}
const inst = new Ctor();
console.log(Object.getPrototypeOf(inst) === Ctor.prototype); // true

Vous pouvez lire Héritage et chaîne de prototypes pour plus d'informations sur les interactions entre la propriété prototype d'une fonction constructeur et le prototype de l'objet résultant.

Une fonction ayant une propriété prototype n'est pas suffisante pour qu'elle soit éligible en tant que constructeur. Les fonctions génératrices ont une propriété prototype, mais ne peuvent pas être appelées avec new :

async function* fonctionGeneratriceAsynchrone() {}
function* fonctionGeneratrice() {}

Au lieu de cela, la propriété prototype des fonctions génératrices est utilisée lorsqu'elles sont appelées sans new. La propriété prototype deviendra le prototype de l'objet Generator retourné.

De plus, certaines fonctions peuvent avoir une propriété prototype mais lancer une exception de manière inconditionnelle lorsqu'elles sont appelées avec new. Par exemple, les fonctions Symbol() et BigInt() lancent une exception lorsqu'elles sont appelées avec new, car Symbol.prototype et BigInt.prototype sont uniquement destinés à fournir des méthodes pour les valeurs primitives, mais les objets wrapper ne doivent pas être construits directement.

Les fonctions suivantes n'ont pas de prototype et ne sont donc pas éligibles en tant que constructeurs, même si une propriété prototype est ultérieurement assignée manuellement :

const methode = { toto() {} }.toto;
const fonctionFlechee = () => {};
async function fonctionAsynchrone() {}

Les constructeurs valides suivants ont une propriété prototype :

class Classe {}
function fn() {}

Une fonction liée n'a pas de propriété prototype, mais peut être constructible. Lorsqu'elle est construite, la fonction cible est construite à la place, et si la fonction cible est constructible, elle retournerait une instance normale.

const fonctionLiee = function () {}.bind(null);

La propriété prototype d'une fonction, par défaut, est un objet simple avec une propriété : constructor, qui est une référence à la fonction elle-même. La propriété constructor est modifiable, non énumérable et configurable.

Si la propriété prototype d'une fonction est réassignée avec autre chose qu'un Object, lorsque la fonction est appelée avec new, le prototype de l'objet retourné sera Object.prototype à la place. (En d'autres termes, new ignore la propriété prototype et construit un objet simple.)

function Ctor() {}
Ctor.prototype = 3;
console.log(Object.getPrototypeOf(new Ctor()) === Object.prototype); // true

Exemples

Changer le prototype de toutes les instances en modifiant la propriété prototype

function Ctor() {}
const p1 = new Ctor();
const p2 = new Ctor();
Ctor.prototype.prop = 1;
console.log(p1.prop); // 1
console.log(p2.prop); // 1

Ajouter une propriété qui n'est pas une méthode à la propriété prototype d'une classe

Champs de classe ajoutent des propriétés à chaque instance. Les méthodes de classe déclarent des propriétés fonction sur le prototype. Cependant, il n'y a aucun moyen d'ajouter une propriété non fonctionnelle au prototype. Si vous souhaitez partager des données statiques entre toutes les instances (par exemple, Error.prototype.name est le même pour toutes les instances d'erreur), vous pouvez l'assigner manuellement sur le prototype d'une classe.

class Chien {
  constructor(name) {
    this.name = name;
  }
}

Chien.prototype.espece = "chien";

console.log(new Chien("Jack").espece); // "chien"

Cela peut être rendu plus ergonomique en utilisant des blocs d'initialisation statiques, qui sont appelés lorsque la classe est initialisée.

class Chien {
  static {
    Chien.prototype.espece = "chien";
  }
  constructor(name) {
    this.name = name;
  }
}

console.log(new Chien("Jack").espece); // "chien"

Spécifications

Voir aussi

• L'objet Function
• Héritage et chaîne de prototypes