Function : propriété prototype

La propriété de données prototype d'une instance de Function est utilisée lorsque la fonction est utilisée comme constructeur avec l'opérateur new. Elle deviendra le prototype du nouvel objet.

Note : Tous les objets Function n'ont pas la propriété prototype — voir la description.

Dans cet article

Valeur

Un objet.

Attributs de Function : propriété prototype

Écrivable	Oui
Énumérable	Non
Configurable	Non

Note : Les classes sont un type de fonction, donc la plupart de la description ici s'applique également à la propriété prototype des classes. La seule différence notable est que la propriété prototype d'une classe n'est pas modifiable.

Description

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

js
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 :

js
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 :

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

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

js
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.)

js
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

js
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.

js
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.

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

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

Spécifications

Spécification

ECMAScript® 2027 Language Specification
# sec-function-instances-prototype

Voir aussi

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

Aider à améliorer MDN

Cette page vous a-t-elle été utile ?

Oui Non

Apprendre à contribuer

Cette page a été modifiée le 25 févr. 2026 par les contributeur·ice·s du MDN.

Voir cette page sur GitHub • Signaler un problème avec ce contenu

Objets natifs standards
Function
Constructeur
1. Function()
Méthodes d'instance
Propriétés d'instance
Héritage
Object/Function
Méthodes statiques
Propriétés statiques
Méthodes d'instance
Propriétés d'instance
1. Object.prototype.__proto__
2. Object.prototype.constructor