Une analyse approfondie de l'événement Node.js loop_node.js

Node.js est une application à processus unique et à thread unique, mais prend en charge la concurrence via des événements et des rappels, ses performances sont donc très élevées.

(Source : Javascript est monothread et asynchrone, mais ces langages​​ont une caractéristique commune : ils sont pilotés par des événements. Les événements qui les animent proviennent d'une plateforme hétérogène.)

Chaque API de Node.js est asynchrone et s'exécute comme un thread distinct, utilise des appels de fonction asynchrones et gère la concurrence.

Fondamentalement, tous les mécanismes d'événements dans Node.js sont implémentés à l'aide du modèle d'observateur dans le modèle de conception.

Le thread unique Node.js revient à entrer dans une boucle d'événement while (true) jusqu'à ce qu'aucun observateur d'événement ne se termine. Chaque événement asynchrone génère un observateur d'événement. Si un événement se produit, la fonction de rappel est appelée.

Modèle événementiel

Node.js utilise un modèle basé sur les événements. Lorsque le serveur Web reçoit une requête, il la ferme et la traite, puis sert la requête Web suivante.

Lorsque cette requête est terminée, elle est remise dans la file d'attente de traitement, et lorsque le début de la file d'attente est atteint, le résultat est renvoyé à l'utilisateur.

Ce modèle est très efficace et évolutif car le serveur Web accepte toujours les requêtes sans attendre aucune opération de lecture ou d'écriture.
(Cela est également appelé IO non bloquant ou IO piloté par événement)

Dans le modèle basé sur les événements, une boucle principale est générée pour écouter les événements, et une fonction de rappel est déclenchée lorsqu'un événement est détecté.

C'est ainsi que l'ensemble du processus événementiel est mis en œuvre, ce qui est très simple. Un peu similaire au modèle d'observateur, l'événement est équivalent à un sujet (Sujet) et toutes les fonctions de gestionnaire enregistrées pour cet événement sont équivalentes à des observateurs (Observateur).

Node.js a plusieurs événements intégrés. Nous pouvons lier et écouter des événements en introduisant le module d'événements et en instanciant la classe EventEmitter, comme le montre l'exemple suivant :

//引入events模块
var events = require('events');
//创建eventEmitter对象
var eventEmitter = new events.EventEmitter();
//创建事件处理程序
var connectHandler = function connected() {
 console.log('连接成功。');
 //触发data_received事件 
 eventEmitter.emit('data_received');
}
//绑定connection事件处理程序
eventEmitter.on('connection', connectHandler);
//使用匿名函数绑定data_received事件
eventEmitter.on('data_received', function(){
 console.log('数据接收成功。');
});
//触发connection事件 
eventEmitter.emit('connection');
console.log("程序执行完毕。"); 

Le résultat de sortie du code ci-dessus est :

Connexion réussie.

Données reçues avec succès.

L'exécution du programme est terminée.

Les résultats ci-dessus sont exactement comme vous le pensez. Grâce à ce modèle basé sur les événements, nous pouvons réaliser des opérations asynchrones.

(Par exemple, nous pouvons lire le fichier tout en exécutant d'autres commandes. Une fois la lecture du fichier terminée, nous renvoyons le contenu du fichier en tant que paramètre de la fonction de rappel. De cette façon, il n'y a pas de blocage ou d'attente du fichier I /O lors de l'exécution du code. Cela améliore considérablement les performances de Node.js et peut gérer un grand nombre de requêtes simultanées)
.

var fs = require("fs");
fs.readFile('input.txt', function (err, data) {
 if (err){
 console.log(err.stack);
 return;
 }
 console.log(data.toString());
});
console.log("程序执行完毕。"); 

Le résultat de sortie du code ci-dessus est :

L'exécution du programme est terminée.

Contenu de input.txt.

D'après le code ci-dessus, nous pouvons voir que fs.readFile peut distribuer des événements. Bien entendu, de nombreux objets dans Node.js distribueront des événements. Un objet net.Server distribuera également un événement à chaque nouvelle connexion. Tous ces objets Event générés sont des instances de events.EventEmitter.

Mais la plupart du temps, nous n'utilisons pas EventEmitter directement, mais en héritons dans l'objet. Y compris fs, net, http, tant que les modules de base qui prennent en charge la réponse aux événements sont des sous-classes d'EventEmitter.

Pourquoi fais-tu ça ? Il y a deux raisons :

Tout d'abord, l'implémentation événementielle d'un objet avec une certaine fonction d'entité est conforme à la sémantique. La surveillance et l'émission d'événements doivent être des méthodes d'un objet.
Deuxièmement, le mécanisme objet de JavaScript est basé sur un prototype et prend en charge l'héritage multiple partiel. L'héritage d'EventEmitter ne perturbera pas la relation d'héritage d'origine de l'objet.

Laissez-moi partager avec vous mon premier projet NodeJs

Il existe généralement deux façons d'installer Node.js : compiler le code source vous-même et utiliser des fichiers compilés. J'utilise ici des fichiers compilés
. Actuellement, j'ai le node-v4.2.3-linux-x64 que je viens de télécharger dans mon répertoire personnel

1. Décompressez d'abord

Copier le code Le code est le suivant :

tar xvf node-v4.2.3-linux-x64

2. Définissez le lien. Le but de la définition du lien est que la commande node peut être utilisée dans n'importe quel chemin

Copier le code Le code est le suivant :

ln -s /home/node-v4.2.3-linux-x64/bin/node /usr/local/bin/node
ln -s /home/node-v4.2.3-linux-x64/bin/npm /usr/local/bin/npm

3. Créez un répertoire appelé mynodeproj sous le dossier personnel, puis créez un fichier appelé server.js (bien sûr, vous pouvez également le nommer d'une autre manière)

var http = require('http');
http.createServer(function (request, response) {
 //发送 HTTP 头部 
 //HTTP 状态值: 200 : OK
 //内容类型: text/plain
 response.writeHead(200, {'Content-Type': 'text/plain'});
 //发送响应数据 "Hello World"
 response.end('Hello World\n');
}).listen(8888);
//终端打印如下信息
console.log('Server running at http://127.0.0.1:8888/'); 

4. node 명령어를 사용하여 위 코드를 실행합니다

노드 서버.js

위 명령을 실행하면 "Server runnint at http://127.0.0.1:8888/"이 명령줄에 표시됩니다. 이는 프로그램이 성공적으로 실행되었음을 의미합니다!

내 서버가 Alibaba Cloud에서 실행되고 있기 때문에 외부 브라우저에 Alibaba Cloud IP 포트를 입력하기만 하면 액세스할 수 있습니다.