Comment le « nouveau » opérateur JavaScript fonctionne-t-il de manière magique ?

Démêler l'énigme du "nouvel" opérateur JavaScript

Dans les profondeurs de la complexité de JavaScript se cache une construction mystérieuse réputée pour son potentiel à laisser perplexe : le "nouveau" opérateur. Ses rouages ​​obscurs côtoient la chaîne des prototypes, laissant de nombreuses personnes perdues dans le labyrinthe du code.

Plongez dans le mécanisme du nouvel opérateur

Pour dévoiler les secrets du « nouveau " opérateur, disséquons ses opérations complexes :

• Il se dispute avec la méthode interne [[Construct]], une force invisible au sein de JavaScript.
• [[Construct]] élabore méticuleusement un objet avec des propriétés natives.
• Une danse subtile s'ensuit, où le [[Prototype]] de l'objet est attaché au prototype de fonction. À moins que la fonction ne manque d'un prototype d'objet (le reléguant à des valeurs primitives), Object.prototype intervient gracieusement pour guider l'objet.
• Le "nouvel" opérateur orchestre alors une grande invocation de la fonction, lui conférant le objet fraîchement créé comme sa valeur "this".
• Un moment crucial se produit : si la fonction produit une valeur primitive, l'objet généré en interne occupe le devant de la scène. Cependant, si un objet est restitué, l'objet original sombre malheureusement dans l'oubli.

Une lentille alternative

Pour faire la lumière davantage sur l'énigmatique « nouveau » opérateur, explorons une implémentation alternative qui reflète ses actions :

<code class="javascript">function NEW(f) {
  var obj, ret, proto;

  // Prototype verification
  proto = Object(f.prototype) === f.prototype ? f.prototype : Object.prototype;

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

  // Function invocation with object as "this"
  ret = f.apply(obj, Array.prototype.slice.call(arguments, 1));

  // Object return
  if (Object(ret) === ret) {
    return ret;
  }
  return obj;
}

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

var obj = NEW(Foo, 'bar');
console.log(obj.prop); // 'bar'
console.log(obj.inherited); // 'baz'
console.log(obj instanceof Foo); // true</code>

Ce code sert de balise, éclairant la façon dont le « nouvel » opérateur exerce avec diligence ses fonctions dans les coulisses.

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!