Object.prototype.__proto__

L'accesseur __proto__ expose la valeur du [[Prototype]] interne d'un objet.

• Pour les objets créés via un littéral objet, cette valeur est Object.prototype.
• Pour les objet créés via un littéral de tableau, cette valeur est Array.prototype.
• Pour les fonctions, cette valeur est Function.prototype.
• Pour les objets créés en utilisant new fun, avec fun un des constructeurs natif de fonctions, fournis par JavaScript (Array, Boolean, Date, Number, Object, String, etc.), cette valeur est fun.prototype.
• Pour les objets créés en utilisant new fun, avec fun une function definie dans un script, cette valeur est la valeur de fun.prototype au moment où new fun est évaluée. (Ainsi, si on affecte une nouvelle valeur à fun.prototype, les instances crées précédemment conserveront leur [[Prototype]], les objets créés par la suite bénéficieront de la nouvelle valeur pour leur [[Prototype]].)

Le mutateur __proto__ permet de changer le [[Prototype]] d'un objet. Cet objet doit être extensible selon Object.isExtensible, si ce n'est pas le cas, une exception TypeError sera renvoyée. La valeur fournie pour le nouveau prototype doit être un objet ou null. Toute autre valeur entraînera un échec silencieux.

Pour plus d'éléments sur le fonctionnement de l'héritage et des prototypes, voir la page sur l'héritage et les chaînes de prototypes.

Le propriété __proto__ n'est qu'une propriété accesseur (composée d'une fonction accesseur (getter) et d'une fonction mutateur (setter)) pour Object.prototype. Si l'accès à __proto__ consulte Object.prototype, on trouvera la propriété. Un accesseur qui ne consulte pas Object.prototype ne pourra pas trouver le prototype. Si une propriété __proto__ est trouvée avant que Object.prototype ne soit consulté, cette propriété « cachera » Object.prototype.

var aucunProto = Object.create(null);

console.log(typeof aucunProto.__proto__); // undefined
console.log(Object.getPrototypeOf(aucunProto)); // null

aucunProto.__proto__ = 17;

console.log(aucunProto.__proto__); // 17
console.log(Object.getPrototypeOf(aucunProto)); // null

var protoCaché = {};
Object.defineProperty(protoCaché, "__proto__", {
  value: 42,
  writable: true,
  configurable: true,
  enumerable: true,
});

console.log(protoCaché.__proto__); // 42
console.log(Object.getPrototypeOf(protoCaché) === Object.prototype); // true

Dans ce qui suit, on crée un nouvelle instance d'Employé et on teste si __proto__ est bien le même objet que le prototype de son constructeur.

// On déclare une fonction à utiliser comme constructeur
function Employé() {
  /* on initialise l'instance */
}

// On crée une nouvelle instance d'Employé
var fred = new Employé();

// On teste l'équivalence
fred.__proto__ === Employé.prototype; // true

À cet instant, fred hérite de Employé. On peut toutefois changer ça en assignant un nouvel objet à fred.__proto__ :

// Assigner un nouvel objet à __proto__
fred.__proto__ = Object.prototype;

fred n'hérite plus de Employé.prototype, mais de Object.prototype. Il perd donc les propriétés héritées de Employé.prototype.

Cela n'est possible que pour les objets extensibles. La propriété __proto__ d'un objet non-extensible ne peut pas être changée :

var obj = {};
Object.preventExtensions(obj);

obj.__proto__ = {}; // renvoie une exception TypeError

On notera que même la propriété __proto__ de Object.prototype peut être redéfinie tant que la chaîne de prototypes se termine par null :

var b = {};

Object.prototype.__proto__ = Object.create(
  null, //[[Prototype]]
  {
    salut: {
      value: function () {
        console.log("salut");
      },
    },
  },
);

b.salut();

Si la propriété __proto__ de Object.prototype ne permet pas d'aboutir à null via la chaîne de prototypes, on a une chaîne cyclique et on doit avoir une exception TypeError "cyclic __proto__ value".

• Object.prototype.isPrototypeOf()
• Object.getPrototypeOf()
• Object.setPrototypeOf()