Ces dernières années, Node.js (ci-après dénommé Node) est devenue l'une des plateformes JavaScript côté serveur les plus populaires au monde. Bien qu'il possède de nombreuses fonctionnalités, qu'il s'agisse de la vitesse d'exécution, de l'empreinte mémoire ou des bibliothèques et frameworks pris en charge, Node a encore ses propres limites sur certains aspects. L'un des problèmes les plus importants est que Node.js ne peut pas être hérité.
Dans la programmation orientée objet, l'héritage est une fonctionnalité importante, qui permet aux développeurs de créer une classe de base (classe parent) et de créer d'autres sous-classes basées sur celle-ci. Ces sous-classes peuvent remplacer les méthodes de la classe parent ou ajouter de nouvelles méthodes pour étendre et réutiliser les fonctionnalités. Dans le contexte de Node.js, l'héritage prend généralement la forme d'une copie de propriétés et de méthodes entre classes. Cependant, en raison du modèle asynchrone de Node.js et de son interaction avec la flexibilité de JavaScript, l'héritage n'est pas très intuitif dans Node et est parfois difficile à mettre en œuvre. Cet article explorera pourquoi Node.js ne parvient pas à hériter et quelques alternatives.
1. Le problème de l'implémentation de l'héritage dans Node.js
Le problème de l'implémentation de l'héritage dans Node.js, il y a deux facteurs clés :
- Modèle de programmation asynchrone
L'une des caractéristiques de Node.js est son Modèle de programmation asynchrone, étroitement lié à JavaScript. Étant donné que Node.js est monothread, il doit utiliser un modèle asynchrone afin de gérer plusieurs requêtes client et autres tâches asynchrones. Le modèle asynchrone rend Node.js plus efficace, mais entre en conflit avec l'implémentation héritée. Parce que dans la programmation asynchrone, les appels de fonctions sont effectués en fonction de minuteries. Après avoir appelé une fonction asynchrone, le programme continuera à s'exécuter jusqu'à la fin du rappel asynchrone avant de revenir à la fonction.
Considérons le morceau de code suivant :
class Person {
constructor(name) {
this.name = name;
}
greet() {
console.log(`Hello, my name is ${this.name}.`);
}
}
class User extends Person {
constructor(name, email) {
super(name);
this.email = email;
}
static log(email) {
console.log(`User ${email} logged in.`);
}
login() {
User.log(this.email);
this.greet();
}
}
const alice = new User('Alice', 'alice@example.com');
alice.login();Copier après la connexion
Dans cet exemple, nous avons une classe Person et une autre classe User, qui hérite de Person>. Lorsque nous appelons la méthode login sur une instance User, une méthode log unique à la classe User sera d'abord appelé , puis appelez la méthode greet de la classe parent. Mais comme la fonction est exécutée de manière asynchrone, le résultat ne sera pas celui attendu : Person 类和另一个类 User，它继承自 Person。当我们对一个 User 实例调用 login 方法时，会先调用一个 User 类独有的 log 方法，然后调用父类的 greet 方法。但由于函数是异步执行的，结果将不如我们所愿：
User alice@example.com logged in.
undefined
Copier après la connexion
实际上，调用顺序是不正确的。由于 this.greet 是基于异步行为调用的，因此该方法的执行是在异步 User.log 方法的回调后进行的。这就是为什么 undefined 是打印在屏幕上的原因。
- 面向对象的JavaScript
第二个问题，是 JavaScript 自身对面向对象程序设计模式的支持。 JavaScript 不是一种传统的面向对象语言，它使用一种基于原型的对象模型，而不是使用基于类的对象模型。原型模型并不像继承那样直接支持类继承，如果想在 Node.js 中实现继承，就需要使用一些 JavaScript 的面向对象编程技巧。
在基于原型的继承模式中，开发者需要使用 Object.create() 方法来创建对象，并将其作为一个原型传递给子类。这种继承模式的优点是更加灵活，因为它允许您不仅继承类的方法，而且还可以继承属性。
以下是一个基于原型的示例：
class Person {
constructor(name) {
this.name = name;
}
greet() {
console.log(`Hello, my name is ${this.name}.`);
}
}
const User = Object.create(Person.prototype, {
email: { value: null, enumerable: true, writable: true }
});
User.constructor = User;
User.constructor('Tom', 'tom@example.com');
console.log(User);
User.greet();Copier après la connexion
在这个例子中，我们手动创建了一个对象，然后将其原型指向 Person.prototype。在定义User的时候，我们没有直接继承 Person，而是使用了 Object.create 方法创建了一个基于父类原型的对象。User 通过User.constructor函数调用注册用户。
二、解决方案
尽管 Node.js 有一些限制，但还有一些解决方案可以实现继承的功能。这里我们来介绍一些常见的解决方案：
- 基于模块的继承
Node.js 具有基于模块的架构，可以使用该模型创建实现继承的模块。Node.js 的模块系统允许您在不同的 JavaScript 文件中导入函数、对象和类，并将它们合并成一个单独的模块。实现继承的方式是创建父类模块和子类模块，并在子类模块中使用父类模块的函数、对象和类。
这里有一种例子，实现继承Person 类
//person.js
module.exports = class Person {
constructor(name) {
this.name = name;
}
greet() {
console.log(`Hello, my name is ${this.name}.`);
}
};
//user.js
const Person = require('./person');
class User extends Person {
constructor(name, email) {
super(name);
this.email = email;
}
static log(email) {
console.log(`User ${email} logged in.`);
}
login() {
User.log(this.email);
this.greet();
}
}
const user = new User('Tom', 'tom@example.com');
user.login();Copier après la connexion
在这个例子中，我们有一个 Person 模块和一个 User 模块，后者继承自前者。请注意，我们在 User 模块中使用了 require('./person') 导入了 Person 模块，并使用了 extends Person 将 User 继承自 Person。最后，我们创建了一个 User 对象并试图调用 greet
class Person {
constructor(name) {
this.name = name;
}
greet() {
console.log(`Hello, my name is ${this.name}.`);
}
}
class User extends Person {
constructor(name, email) {
super(name);
this.email = email;
this.proxy = new Proxy(this, {
get(target, propKey) {
return target[propKey] || target.__proto__[propKey];
},
});
}
static log(email) {
console.log(`User ${email} logged in.`);
}
login() {
User.log(this.email);
this.proxy.greet();
}
}
const user = new User('Tom', 'tom@example.com');
user.login();Copier après la connexion
Copier après la connexion
En fait, l'ordre d'appel est incorrect. Puisque
this.greet est appelé en fonction d'un comportement asynchrone, l'exécution de cette méthode se produit après le rappel de la méthode asynchrone
User.log. C'est pourquoi
undefined est imprimé à l'écran.
- JavaScript orienté objet
Le deuxième problème est la propre prise en charge par JavaScript du modèle de programmation orienté objet. JavaScript n'est pas un langage orienté objet traditionnel et utilise un modèle objet basé sur un prototype plutôt qu'un modèle objet basé sur une classe. Le modèle prototype ne prend pas directement en charge l'héritage de classe comme l'héritage. Si vous souhaitez implémenter l'héritage dans Node.js, vous devez utiliser certaines compétences en programmation orientée objet JavaScript.
Dans le modèle d'héritage basé sur un prototype, les développeurs doivent utiliser la méthode
Object.create() pour créer un objet et le transmettre aux sous-classes en tant que prototype. L’avantage de ce modèle d’héritage est qu’il est plus flexible car il permet d’hériter non seulement des méthodes de la classe, mais également des propriétés. 🎜🎜Voici un exemple basé sur un prototype : 🎜rrreee🎜Dans cet exemple, nous créons manuellement un objet, puis pointons son prototype vers
Person.prototype. Lors de la définition de
User, nous n'avons pas directement hérité de
Person, mais avons utilisé la méthode
Object.create pour créer un objet basé sur le prototype de la classe parent. . L'utilisateur enregistre les utilisateurs via des appels de fonction
User.constructor. 🎜🎜2. Solution🎜🎜Bien que Node.js présente certaines limites, il existe des solutions pour obtenir des fonctions héritées. Nous présentons ici quelques solutions courantes : 🎜🎜🎜Héritage basé sur des modules🎜🎜🎜Node.js a une architecture basée sur des modules, et vous pouvez utiliser ce modèle pour créer des modules qui implémentent l'héritage. Le système de modules de Node.js vous permet d'importer des fonctions, des objets et des classes dans différents fichiers JavaScript et de les combiner en un seul module. La façon d'implémenter l'héritage consiste à créer un module de classe parent et un module de classe enfant, et à utiliser les fonctions, objets et classes du module de classe parent dans le module de classe enfant. 🎜🎜Voici un exemple d'implémentation de la classe Person héritée🎜rrreee🎜Dans cet exemple, nous avons un module
Person et un module
Utilisateur, ce dernier hérite du premier. Notez que nous avons utilisé
require('./person') dans le module
User, importé le module
Person et utilisé
extends Person hérite de
Utilisateur de
Personne. Enfin, nous créons un objet
User et tentons d'appeler la méthode
greet. Le résultat cette fois n’a posé aucun problème. 🎜🎜🎜Utiliser le proxy ES6🎜🎜🎜 Une autre façon de résoudre le problème dans Node.js consiste à utiliser le proxy ES6. Proxy est une nouvelle fonctionnalité de JavaScript qui nous permet d'exécuter des fonctions hook sur des objets ou des fonctions et de modifier leur comportement en fonction de nos requêtes. 🎜🎜Voici un exemple : 🎜
class Person {
constructor(name) {
this.name = name;
}
greet() {
console.log(`Hello, my name is ${this.name}.`);
}
}
class User extends Person {
constructor(name, email) {
super(name);
this.email = email;
this.proxy = new Proxy(this, {
get(target, propKey) {
return target[propKey] || target.__proto__[propKey];
},
});
}
static log(email) {
console.log(`User ${email} logged in.`);
}
login() {
User.log(this.email);
this.proxy.greet();
}
}
const user = new User('Tom', 'tom@example.com');
user.login();Copier après la connexion
Copier après la connexion
在这个例子中，我们使用了一个新的属性 this.proxy。该属性是使用 new Proxy() 创建一个新的 Proxy 实例，该实例包装了当前的对象。 我们在 get 钩子函数中进行了一些重点的操纵，当我们通过 this.proxy.greet() 调用 greet 方法时，它会在当前对象上执行搜索不到，然后自动查找其原型，并在原型上找到该方法。
三、总结
继承是面向对象编程中的一个重要特性。然而，在 Node.js 的环境中，由于其异步性和 JavaScript 本身的面向对象编程模型，继承并不像在传统面向对象语言中那样简单直观。但是，我们可以通过模块模式和 ES6 Proxy 等解决方案来实现继承，以实现更完整的面向对象编程体验。无论使用哪种方案，重要的是确保我们在开发过程中遵循最佳实践，以确保代码的可维护性和稳健性。
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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
