Comment le « nouvel » opérateur en JavaScript crée-t-il des objets et établit-il leur héritage ?

Démystifier le fonctionnement interne du nouvel opérateur en JavaScript

Le terrain incompris de JavaScript, semblable à la chaîne de prototypes, dévoile une question fondamentale : comment l'opérateur « nouveau » orchestre-t-il la création d'objets, définissant leur lignée et leurs attributs fondamentaux ?

L'essence du nouveau

Pour résoudre cette énigme, considérons une illustration alternative :

function NEW(f) {
  var obj, ret, proto;

  // Examine `f.prototype`
  proto = Object(f.prototype) === f.prototype ? f.prototype : Object.prototype;

  // Inherit from `proto`
  obj = Object.create(proto);

  // Invoke `f` with `obj` as `this`
  ret = f.apply(obj, Array.prototype.slice.call(arguments, 1));

  // Determine return type
  if (Object(ret) === ret) { // Object returned?
    return ret;
  }

  // Otherwise, return inherited object
  return obj;
}

Comprendre le mécanisme

Le nouvel opérateur s'appuie sur le mécanisme interne [[Construct]], qui :

1. Crée un objet natif.
2. Définit son [[Prototype]] sur le prototype de la fonction ou Object.prototype (si le prototype est primitif).
3. Appelle la fonction avec l'objet comme "this. "
4. Renvoie l'objet créé en interne si la fonction renvoie une primitive, ou l'objet renvoyé par la fonction si elle renvoie un objet.

Application pratique

Illustre la puissance de ce concept :

function Foo(arg) {
  this.prop = arg;
}
Foo.prototype.inherited = 'baz';

var obj = NEW(Foo, 'bar');

Cela crée un objet héritant de Foo, avec la propriété héritée "inherited" et la propriété "prop" avec la valeur "bar".

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!