Explication détaillée des événements dans Node.js

Recommandations associées : "tutoriel nodejs"

Le front-end n'est certainement pas étranger aux événements, reliant les événements de défilement pour Windows

window.addEventListener('scroll', ev => {
	console.log(ev);
});

La plupart des opérations asynchrones dans Node.js sont pilotées par des événements. Tous les objets qui peuvent déclencher des événements héritent de la EventEmitter classe

Event Listener

on

<.>Node L'utilisation de l'écoute d'événements .js est très similaire à l'API jQuery

emitter.on(eventName, listener)

const ee = new EventEmitter();
ee.on('foo', () => console.log('a'));

L'instance EventEmitter maintiendra un tableau d'écoute, et chaque écouteur sera ajouté à la fin du array par défaut
1. À chaque fois qu'il est ajouté, l'écouteur ne vérifiera pas s'il a été ajouté. Appeler plusieurs fois et transmettre le même nom d'événement et le même écouteur entraînera l'ajout de l'écouteur plusieurs fois
2. <.>
   
prependListener

Vous pouvez ajouter l'auditeur à la tête du tableau d'écoute via prependListeneremitter.prependListener(eventName, listener)

const ee = new EventEmitter();
ee.prependListener('foo', () => console.log('a'));

once

Si vous voulez que l'écouteur soit déclenché une fois puis ne se déclenche plus, vous pouvez utiliser une fois pour lier l'événement

const ee = new EventEmitter();
ee.once('foo', () => console.log('a'));

Déclenchement d'événement

La plupart des événements du développeur sont liés Le travail dans l'environnement du navigateur consiste à s'abonner aux événements, c'est-à-dire à lier l'écouteur de la fonction de traitement des événements, dans la programmation d'événements Node.js. Il est souvent nécessaire de créer des objets d'événement qui déclenchent réellement des événements lorsque cela est raisonnablement possible. En utilisant la méthode submit, vous pouvez emitter.emit(eventName[, ...args])de manière synchrone
appeler chaque écouteur enregistré à l'événement nommé eventName dans l'ordre dans lequel les auditeurs sont enregistrés, et transmettre le paramètre fourni

const EventEmitter = require('events');
const myEmitter = new EventEmitter();

// 第一个监听器。
myEmitter.on('event', function firstListener() {
  console.log('第一个监听器');
});
// 第二个监听器。
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`第二个监听器中的事件有参数 ${arg1}、${arg2}`);
});
// 第三个监听器
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`第三个监听器中的事件有参数 ${parameters}`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// 第一个监听器
// 第二个监听器中的事件有参数 1、2
// 第三个监听器中的事件有参数 1, 2, 3, 4, 5

cela pointe vers

La méthode

peut transmettre n'importe quel nombre de paramètres à l'écouteur. Le mot-clé

sera pointé vers l'instance EventEmitter liée à l'écouteur eventEmitter.emit()

const myEmitter = new MyEmitter();
myEmitter.on('event', function(a, b) {
  console.log(a, b, this, this === myEmitter);
  // 打印:
  //   a b MyEmitter {
  //     domain: null,
  //     _events: { event: [Function] },
  //     _eventsCount: 1,
  //     _maxListeners: undefined } true
});
myEmitter.emit('event', 'a', 'b');

this Vous pouvez également utiliser la flèche ES6. fonctionne comme un auditeur. Mais le mot-clé ne pointe pas vers l'instance EventEmitter :

const myEmitter = new MyEmitter();
myEmitter.on('event', (a, b) => {
  console.log(a, b, this);
  // 打印: a b {}
});
myEmitter.emit('event', 'a', 'b');

thisAppel asynchrone

appelle tous les auditeurs de manière synchrone dans l'ordre d'enregistrement, ce qui garantit le bon ordre des événements, et l'auditeur peut utiliser les méthodes

et EventEmitter pour passer en mode de fonctionnement asynchrone setImmediate()

const myEmitter = new MyEmitter();
myEmitter.on('event', (a, b) => {
  setImmediate(() => {
    console.log('异步地发生');
  });
});
myEmitter.emit('event', 'a', 'b');

process.nextTick()Déchargement d'événement

Node.js fournit plusieurs méthodes pour désinstaller la liaison d'événement

off/removeListener

off est un alias de la méthode removeListener, utilisée pour nettoyer les liaisons d'événements

const callback = (stream) => {
  console.log('已连接');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);

emitter.removeListener(eventName, listener)removeListener() ne supprimera qu'au plus un écouteur de le périphérique du réseau d'écoute. Si un écouteur est ajouté plusieurs fois au tableau d'écouteurs pour un nom d'événement spécifié, removeListener() doit être appelé plusieurs fois pour supprimer toutes les instances

removeAllListeners

Supprimez l'écouteur de l'événement eventName spécifié. Si eventName n'est pas spécifié, supprimez tous les écouteurs de l'objet événement. Le tableau eventName sur l'objet événement peut être obtenu via emitter.removeAllListeners([eventName])

const EventEmitter = require('events');
const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

myEE.eventNames().forEach(eventName => myEE.removeAllListeners);

emitter.eventNames()Pour plus de connaissances sur la programmation, veuillez visiter : Vidéo de programmation

 ! !

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!