Comment accéder à une instance de classe à partir d'un appel de fonction lors de l'extension de fonctions avec des classes ES6

Extension de fonctions avec les classes ES6

Dans ES6, les programmeurs ont la possibilité d'étendre des objets spéciaux, y compris des fonctions. En utilisant l'héritage, il devient possible de dériver des classes à partir de fonctions. Bien que ces objets étendus puissent être invoqués comme des fonctions, la mise en œuvre de la logique appropriée pour ces appels peut poser un défi.

Une question importante se pose dans ce scénario : comment obtenir une référence à l'instance de classe lorsque l'objet est invoqué en fonction, étant donné que les méthodes régulières y accèdent via ceci ? Malheureusement, cette référence pointe vers l'objet global (fenêtre) dans ces cas.

Solution :

Pour résoudre ce problème, on peut utiliser le concept de fermetures, ainsi création d'une fonction renvoyée qui encapsule l'accès aux variables d'instance. Voici une illustration :

class Smth extends Function {
  constructor(x) {
    super(() => { return x; });
  }
}

Dans cet exemple, la super expression dans le constructeur initie le constructeur de fonction, nécessitant une chaîne représentant le code à exécuter. Cependant, l'accès aux données d'instance n'est pas simple, c'est pourquoi une approche codée en dur est adoptée, donnant le résultat souhaité :

console.log((new Smth(256))()); // Logs: 256

Une approche alternative pour atteindre le même objectif consiste à manipuler la chaîne de prototypes :

class Smth extends Function {
  constructor(x) {
    const smth = function() { return x; };
    Object.setPrototypeOf(smth, Smth.prototype);
    return smth;
  }
}

Cette méthode offre une plus grande flexibilité en permettant à la fonction renvoyée d'être une fermeture capable d'accéder aux variables d'instance.

De plus, il est possible d'abstraire cette fonctionnalité dans un utilitaire réutilisable :

class ExtensibleFunction extends Function {
  constructor(f) {
    return Object.setPrototypeOf(f, new.target.prototype);
  }
}

class Smth extends ExtensibleFunction {
  constructor(x) {
    super(() => { return x; });
  }
}

Cette approche crée un niveau supplémentaire d'indirection dans la hiérarchie d'héritage, mais elle peut être bénéfique dans certains scénarios. De plus, on peut éviter cela en utilisant la construction suivante :

function ExtensibleFunction(f) {
  return Object.setPrototypeOf(f, new.target.prototype);
}
ExtensibleFunction.prototype = Function.prototype;

Veuillez cependant noter que Smth n'héritera pas dynamiquement des propriétés statiques de la fonction dans ce cas.

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!