EventEmitter ב-Node.js: on, emit, once ואירועים משלכם

EventEmitter היא המחלקה במודול events של Node שמאפשרת לאובייקט להכריז על אירועים עם שם. רושמים listener עם emitter.on('name', fn) ומפעילים אותו עם emitter.emit('name', ...args); כל listener של השם הזה רץ, לפי הסדר שבו הוא נוסף, עם הארגומנטים שהעברתם. שרתי HTTP, ‏streams ו-process הם כולם EventEmitters, כך שאותן כמה מתודות עובדות בכל מקום ב-Node.

const EventEmitter = require('events');

const shop = new EventEmitter();

shop.on('order', (item, qty) => {
    console.log('order received:', qty, 'x', item);
});
shop.on('order', (item) => {
    console.log('update stock for', item);
});

console.log('before emit');
shop.emit('order', 'coffee', 2);
console.log('after emit');

שני ה-listeners רצים בין before emit ל-after emit: ‏emit קורא להם באופן סינכרוני וחוזר רק כשהם סיימו. החליפו את הסדר של שתי הקריאות ל-shop.on, ושתי השורות האמצעיות יתחלפו גם הן.

on, ‏once ו-off

on שומר listener עד שמסירים אותו, once מסיר אותו אחרי הקריאה הראשונה, ו-off (זהה ל-removeListener) מסיר אחד. כדי להסיר listener צריך את אותה פונקציה שהוספתם, אז תנו לה שם במקום להעביר arrow function ישירות.

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

function logOpen(who) {
    console.log('opened by', who);
}

door.on('open', logOpen);
door.once('open', () => console.log('first open ever'));

door.emit('open', 'Ada');
door.emit('open', 'Linus');

door.off('open', logOpen);
console.log('listeners left:', door.listenerCount('open'));
console.log('emit returned', door.emit('open', 'Grace'));

first open ever מודפס פעם אחת, אחרי Ada. ברגע ש-logOpen מוסר אף אחד לא מאזין, ולכן ה-emit האחרון מחזיר false; ‏door.removeAllListeners('open') היה מנקה את שני ה-listeners בקריאה אחת.

אירוע ה-error

'error' הוא אירוע מיוחד. אם פולטים אותו ואף אחד לא מאזין, emit זורק את השגיאה, ובתוכנית אמיתית זריקה שלא נתפסה מפילה את התהליך. תמיד הוסיפו listener ל-'error' ב-emitters שיכולים להיכשל, כמו streams ושרתים.

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

try {
    job.emit('error', new Error('disk full'));
} catch (err) {
    console.log('emit threw:', err.message);
}

job.on('error', (err) => {
    console.log('handled:', err.message);
});
job.emit('error', new Error('disk full'));
console.log('still running');

בלי listener, ‏emit זורק וה-catch תופס את זה; עם ה-listener, אותו emit פשוט קורא לו והתוכנית ממשיכה. כל שם אירוע אחר בלי listeners פשוט מתעלמים ממנו בשקט.

הרחבת EventEmitter במחלקה משלכם

הדרך המקובלת להשתמש בו היא לגרום למחלקה שלכם לרשת מ-EventEmitter, לקרוא ל-super() ב-constructor ול-this.emit כשמשהו קורה. מי שמשתמש באובייקט נרשם אליו כמו לכל אובייקט של Node.

const EventEmitter = require('events');

class Upload extends EventEmitter {
    constructor(name, chunks) {
        super();
        this.name = name;
        this.chunks = chunks;
    }

    start() {
        for (let i = 1; i <= this.chunks; i++) {
            this.emit('progress', Math.round((i / this.chunks) * 100));
        }
        this.emit('done', this.name);
    }
}

const up = new Upload('photo.png', 4);
up.on('progress', (pct) => console.log(pct + '%'));
up.once('done', (name) => console.log(name, 'uploaded'));
up.start();

הוא מדפיס 25%, 50%, 75%, 100% ואז photo.png uploaded. העבירו את up.start() אל מעל שתי שורות ה-up.on ושום דבר לא יודפס: האירועים נפלטים לפני שמישהו מאזין.

אותה מלכודת קיימת כשפולטים אירוע מתוך constructor. ספריות שחייבות לפלוט מיד עוטפות את הקריאה ב-process.nextTick, שרץ אחרי שורות ה-on של הקוד הקורא (ראו את הדף על ה-event loop).

לחכות לאירוע עם events.once

events.once(emitter, name) מחזיר promise שמתממש עם הארגומנטים של האירוע, כמערך, בפעם הבאה שהוא נפלט. הוא הופך אירוע חד פעמי למשהו שאפשר לעשות לו await, והוא נדחה אם ה-emitter פולט 'error' קודם.

import { EventEmitter, once } from 'events';

const db = new EventEmitter();

setTimeout(() => db.emit('ready', 'v1.4', 3), 100);

console.log('waiting for ready');
const [version, tables] = await once(db, 'ready');
console.log('ready:', version, 'with', tables, 'tables');

ה-await מחכה עד שהטיימר פולט ready, ואז המערך מתפרק לשני הארגומנטים. לאירוע שנפלט הרבה פעמים, events.on(emitter, name) נותן async iterator שאפשר לעבור עליו בלולאה עם for await.

טעויות נפוצות

הוספת listener בתוך פונקציה שרצה הרבה. קריאה ל-on בכל request handler צוברת listeners וזיכרון. הוסיפו אותו פעם אחת, או השתמשו ב-once.

הסרה של פונקציה שנכתבה ישירות בקריאה. off('data', () => ...) לא מסיר כלום, כי ה-arrow function הזו היא פונקציה חדשה. שמרו הפניה לפונקציה שהוספתם.

לצפות ש-listeners ירוצו מאוחר יותר. emit הוא סינכרוני, כך ש-listener איטי מעכב את הקוד שפלט את האירוע. לסמן את ה-listener כ-async לא עוזר, כי הקוד שלו עדיין רץ על אותו thread עד ה-await הראשון. חלקו עבודה כבדה לחלקים עם setImmediate ביניהם, או העבירו אותה ל-worker thread.