Node.js EventEmitter: on, once, emit va maxsus "error" hodisasi

Qisqacha: EventEmitter (node:events) — Node'dagi hodisalar mexanizmi: kimdir emit("nom", ma'lumot) qiladi, on("nom", funksiya) bilan ro'yxatdan o'tganlar chaqiriladi. Soket, readline, stream, server, process — hammasi EventEmitter. Ikkita muhim qoida: tinglovchilar sinxron, qo'shilgan tartibda chaqiriladi; "error" hodisasining tinglovchisi bo'lmasa, emit("error") xatoni tashlaydi va jarayon yiqiladi.

Bu darsda

• Hodisa mexanizmini o'zingiz 15 qatorda yozasiz va uning ichini tushunasiz.
• on, once, emit, off va listenerCount bilan ishlaysiz.
• Tinglovchilar nega sinxron chaqirilishini va bundan kelib chiqadigan tuzoqlarni bilasiz.
• "error" hodisasining maxsusligini va uni qanday to'g'ri ushlashni tushuntirasiz.
• EventEmitter dan meros olib, o'z hodisali klassingizni yozasiz.

Oldin bilishingiz kerak: addEventListener asoslari, Listener opsiyalari: once, passive, signal, ES Modules Node'da, net, dns va tls.

1. Nega bu kerak?

Oxirgi darslarni eslang. readline da rl.on("line", …) va rl.on("close", …) yozdik. child_process da child.on("close", …) va child.on("message", …). net da socket.on("error", …) — usiz server yiqilardi. Hammasida bir xil on. Bu tasodif emas: ularning hammasi bitta klassdan — EventEmitter dan kelib chiqqan.

Node'ning ko'p qismi "biror narsa bo'lganda — xabar ber" g'oyasiga qurilgan. Fayl o'qildi, ulanish keldi, qator tugadi, jarayon tugadi — bu hodisalar. Kimdir hodisani e'lon qiladi, boshqalar unga obuna bo'ladi. Brauzerda buni addEventListener bilan ko'rgansiz (addEventListener asoslari). Node'da DOM yo'q, lekin g'oya aynan o'sha.

O'xshatish: Telegram kanal. Kanal egasi post qo'yadi (emit), obunachilar xabar oladi (on). Egasi kim obuna bo'lganini bilishi shart emas. Obunachi xohlasa — chiqib ketadi (off), yoki bitta postni o'qib, keyin chiqadi (once).

Bu naqshning nomi — kuzatuvchi (observer). U ikki tomonni bir-biridan ajratadi: soket ma'lumot kelganini bildiradi, lekin uni kim va qanday ishlatishini bilmaydi.

2. Mexanizmni o'zimiz yozamiz

EventEmitter ichida sehr yo'q. Uning yuragi — "hodisa nomi → funksiyalar ro'yxati" jadvali. Keling, uni o'zimiz yozamiz. Bu blok toza JavaScript — saytda «Ishga tushir» bilan ham ishlaydi:

class TinyEmitter {
  #listeners = new Map(); // nom → funksiyalar massivi

  on(name, fn) {
    const list = this.#listeners.get(name) ?? [];
    list.push(fn);
    this.#listeners.set(name, list);
    return this;
  }

  off(name, fn) {
    const list = this.#listeners.get(name) ?? [];
    this.#listeners.set(name, list.filter((f) => f !== fn));
    return this;
  }

  emit(name, ...args) {
    const list = this.#listeners.get(name) ?? [];
    for (const fn of [...list]) fn.apply(this, args);
    return list.length > 0;
  }
}

const channel = new TinyEmitter();
const ali = (post) => console.log("Ali o'qidi:", post);
channel.on("post", ali);
channel.on("post", (post) => console.log("Malika o'qidi:", post));
channel.emit("post", "Dollar kursi 11 903");
channel.off("post", ali);
console.log(channel.emit("post", "Yevro kursi 13 372"));
console.log(channel.emit("reklama", "..."));

Konsolda:

Ali o'qidi: Dollar kursi 11 903
Malika o'qidi: Dollar kursi 11 903
Malika o'qidi: Yevro kursi 13 372
true
false

Hammasi shu: on — ro'yxatga qo'shish, off — ro'yxatdan olib tashlash, emit — ro'yxatdagi hammasini navbat bilan, shu zahoti chaqirish. emit tinglovchi bor-yo'qligini qaytaradi: "reklama"ga hech kim obuna emas — false.

Ikki nozik joy:

• off uchun aynan o'sha funksiya kerak. Shuning uchun Ali tinglovchisi ali nomli o'zgaruvchiga saqlandi. Malikaniki — nomsiz strelka funksiya, uni endi olib tashlab bo'lmaydi.
• for (const fn of [...list]) — nusxa ustida aylanamiz. Agar tinglovchi o'zini off qilsa, ro'yxat aylanish paytida o'zgarmasin. Haqiqiy EventEmitter ham shunday qiladi.

Tekshirib ko'ring: channel.on("post", ali) ikki marta chaqirilsa, bitta emit da Ali necha marta o'qiydi?

3. Haqiqiy EventEmitter

3.1 Asosiy metodlar

Endi Node'niki. Bu va keyingi bloklar node:events ni ishlatadi — ular faqat Node'da ishlaydi, o'z terminalingizda node fayl.mjs bilan sinang:

import { EventEmitter } from "node:events";

const rates = new EventEmitter();
rates.on("ozgardi", (code, rate) => console.log(`${code}: ${rate}`));
rates.once("ozgardi", () => console.log("(birinchi o'zgarish)"));

console.log(rates.emit("ozgardi", "USD", 11903.15));
console.log(rates.emit("ozgardi", "EUR", 13372.4));
console.log(rates.listenerCount("ozgardi"), rates.eventNames());

Konsolda:

USD: 11903.15
(birinchi o'zgarish)
true
EUR: 13372.4
true
1 [ 'ozgardi' ]

emit ga istalgancha argument berish mumkin — ular tinglovchiga shu tartibda keladi (code, rate). Brauzer dispatchEvent dan farqi shu: u yerda bitta event obyekti, bu yerda — oddiy argumentlar.

3.2 Tinglovchi ichida this

Oddiy function tinglovchida this — emitterning o'zi. Strelka funksiyada esa this tashqaridan olinadi (this darsidagi qoida):

import { EventEmitter } from "node:events";

const e = new EventEmitter();
e.on("x", function () {
  console.log("function:", this === e);
});
e.on("x", () => console.log("strelka:", this));
e.emit("x");

Konsolda:

function: true
strelka: undefined

ES modulning yuqori darajasida this — undefined. Amalda this ga tayanish kam; kerakli obyektni yopilish (closure) orqali olgan ma'qul.

4. Tinglovchilar sinxron chaqiriladi

4.1 Tartibni ko'ramiz

Bu darsning eng muhim qoidasi. "Hodisa" so'zi asinxronlikni eslatadi, lekin emit — oddiy funksiya chaqiruvi:

import { EventEmitter } from "node:events";

const e = new EventEmitter();
e.on("buyurtma", (dish) => console.log("1-tinglovchi:", dish));
e.on("buyurtma", (dish) => console.log("2-tinglovchi:", dish));

console.log("emit oldidan");
e.emit("buyurtma", "osh");
console.log("emit dan keyin");

Konsolda:

emit oldidan
1-tinglovchi: osh
2-tinglovchi: osh
emit dan keyin

"emit dan keyin" ikkala tinglovchidan keyin chiqdi. emit hamma tinglovchini tugatmaguncha qaytmaydi. Event loop, navbat, microtask — hech biri ishtirok etmaydi.

Qadamlarda stekka qarang: tinglovchilar emit ning ichida — xuddi oddiy funksiya chaqiruvidek. Vizual sodda model bilan qurilgan (EventEmitter ning o'zi emas), lekin tartib bir xil.

4.2 Bundan kelib chiqadigan uchta natija

Birinchi: sekin tinglovchi hammani to'xtatadi. Bitta tinglovchi 300 ms hisoblasa, emit ham 300 ms "qotadi", undan keyingi tinglovchilar ham kutadi. Va bu vaqtda event loop ham bloklangan (Event loop'ni bloklash).

Ikkinchi: tinglovchidagi xato emit ga uchadi. Tinglovchi throw qilsa, xato emit ni chaqirgan joyga chiqadi va qolgan tinglovchilar chaqirilmaydi.

Uchinchi: konstruktor ichidagi emit yo'qoladi. Klassik xato:

import { EventEmitter } from "node:events";

class Loader extends EventEmitter {
  constructor() {
    super();
    this.emit("tayyor"); // ❌ hali hech kim tinglamayapti
  }
}
const loader = new Loader();
loader.on("tayyor", () => console.log("eshitildi"));
console.log("tinglovchilar:", loader.listenerCount("tayyor"));

Konsolda:

tinglovchilar: 1

"eshitildi" chiqmadi: emit konstruktorda sinxron bajarildi, on esa keyinroq qo'shildi. Hodisa havoga ketdi. Tuzatish — emit ni joriy kod tugagandan keyinga surish:

import { EventEmitter } from "node:events";

class Loader extends EventEmitter {
  constructor() {
    super();
    process.nextTick(() => this.emit("tayyor")); // ✅
  }
}
const loader = new Loader();
loader.on("tayyor", () => console.log("eshitildi"));

Konsolda:

eshitildi

process.nextTick callback'i joriy sinxron kod tugagach, lekin boshqa har qanday ishdan oldin bajariladi (Microtask, process.nextTick va setImmediate). Bu vaqtgacha on allaqachon qo'shilgan. Node'ning o'z modullari ham aynan shunday qiladi.

Tekshirib ko'ring: Uchta tinglovchi bor, ikkinchisi throw new Error("x") qiladi. emit ni try/catch ga o'radik. Uchinchi tinglovchi chaqiriladimi?

5. "error" hodisasi — maxsus

5.1 Tinglovchi bo'lmasa — throw

Boshqa har qanday hodisa tinglovchisiz emit qilinsa, hech narsa bo'lmaydi (false qaytadi). "error" esa boshqacha:

import { EventEmitter } from "node:events";

const e = new EventEmitter();
console.log("oldin");
e.emit("error", new Error("CBU javob bermadi"));
console.log("keyin");

Konsolda:

oldin
Error: CBU javob bermadi

"keyin" chiqmadi — jarayon yiqildi. Terminalda to'liq iz ko'rinadi, oxirida Node Emitted 'error' event at: qatorini qo'shadi ("error hodisasi shu yerda chiqarilgan"). Kanon tajribasida ham xuddi shu (t27-events.txt: "error tinglovchisiz → throw").

Nega bunday? Node falsafasi: xato jimgina yo'qolmasin. Soket uzildi, fayl o'qilmadi — agar buni hech kim eshitmasa, dastur noto'g'ri holatda davom etardi. Undan ko'ra baland ovozda yiqilgan yaxshi. net darsida ECONNRESET serverni aynan shu sabab bilan yiqitdi.

Error emas, oddiy satr bilan emit("error", "matn") qilinsa, Node uni o'raydi: ERR_UNHANDLED_ERROR, xabar Unhandled error. ('matn').

5.2 To'g'ri ushlash

Bitta qoida: xato chiqarishi mumkin bo'lgan har emitterga "error" tinglovchisi.

import { EventEmitter } from "node:events";

const e = new EventEmitter();
e.on("error", (err) => console.log("ushlandi:", err.message));
e.emit("error", new Error("CBU javob bermadi"));
console.log("dastur davom etyapti");

Konsolda:

ushlandi: CBU javob bermadi
dastur davom etyapti

try/catch emitter xatosi uchun odatda ishlamaydi: xato ko'pincha keyinroq, boshqa event loop aylanishida chiqadi — try bloki allaqachon tugagan bo'ladi. Shuning uchun Node'da "soket, stream, server — har biriga "error" tinglovchisi" degan odat bor.

Diqqat: process.on("uncaughtException") — hamma ushlanmagan xatolarni tutadi, lekin uni "yiqilmaslik uchun" ishlatmang. Xatodan keyin dastur holati noma'lum. U faqat log yozib, jarayonni to'xtatish uchun (Ushlanmagan xatolar).

6. O'z hodisali klassingiz

EventEmitter dan meros olib, istalgan obyektni hodisa manbaiga aylantirish mumkin. valyuta mavzusida — kursni kuzatadigan klass:

import { EventEmitter } from "node:events";

class RateWatcher extends EventEmitter {
  #last = new Map();

  update(code, rate) {
    const old = this.#last.get(code);
    this.#last.set(code, rate);
    if (old === undefined) return;
    if (rate !== old) this.emit("change", { code, old, rate });
    if (Math.abs(rate - old) / old > 0.01) {
      this.emit("jump", code);
    }
  }
}

const watcher = new RateWatcher();
watcher.on("change", ({ code, old, rate }) =>
  console.log(`${code}: ${old} → ${rate}`),
);
watcher.on("jump", (code) =>
  console.log(`${code}: 1% dan ko'p sakradi!`),
);

watcher.update("USD", 11903.15);
watcher.update("USD", 11965.51);
watcher.update("USD", 11965.51);
watcher.update("USD", 12200);

Konsolda:

USD: 11903.15 → 11965.51
USD: 11965.51 → 12200
USD: 1% dan ko'p sakradi!

RateWatcher faqat "nima bo'ldi" ni biladi. Telegram'ga yuborish, logga yozish, ekranga chiqarish — tinglovchilarning ishi. Ertaga yangi tinglovchi qo'shsangiz, klass o'zgarmaydi. Hodisa nomlari — oddiy satr; ularni klass hujjatida (JSDoc yoki TypeScript turi) yozib qo'ying.

TypeScript'da hodisalar turini ham berish mumkin: class RateWatcher extends EventEmitter<{ change: [Change]; jump: [string] }> — @types/node buni qo'llaydi va noto'g'ri nom yoki argumentni tip xatosi qiladi.

7. Hodisa, callback yoki Promise?

Natijani bildirishning uch yo'lini bilasiz. Qaysi biri qachon to'g'ri?

Asosiy savol — "necha marta?". Kurs bir marta olinsa — Promise. Server kun bo'yi yangi ulanishlarni qabul qilsa — har ulanish uchun Promise yaratib bo'lmaydi, bu hodisa. child_process ikkalasini ham beradi: execFile (bir natija, promisify bilan Promise) va spawn (oqim va hodisalar).

Ikki dunyo orasida ko'prik ham bor. Hodisani bir marta kutish kerak bo'lsa — uni Promise'ga aylantirish mumkin, ko'p marta kutish kerak bo'lsa — for await bilan o'qiladigan oqimga. readline da for await (const qator of rl) aynan shunday: ichida "line" hodisasi, tashqarida — qulay sikl. Bu ko'priklar — events.once va events.on — keyingi darsning mavzusi.

Yana bitta kichik imkoniyat: tinglovchilar qo'shilgan tartibda chaqiriladi, lekin prependListener(nom, fn) tinglovchini ro'yxat boshiga qo'yadi. Kanon tajribasida: avval on bilan 1, keyin prependListener bilan 0 qo'shildi — natija [ 0, 1 ]. Kutubxona yozayotganda "mening tinglovchim foydalanuvchinikidan oldin ishlasin" kerak bo'lsa ishlatiladi. Har yangi tinglovchi qo'shilganda emitter "newListener" hodisasini ham chiqaradi — kim obuna bo'layotganini kuzatish uchun.

Tekshirib ko'ring: Telegram bot har yangi xabar kelganda funksiya chaqirishi kerak. Promise mosmi yoki hodisa?

8. CLI qadami: holat yo'q — emitterlar ichkarida

valyuta o'zi hech qanday klassni EventEmitter dan meros qilmaydi: CLI'da tashqi hodisa manbai yo'q — buyruq keldi, natija chiqdi, tugadi. Shuning uchun kanon bu darsda kod qo'shmadi (QADAMLAR: "CLI'da hodisa manbai yo'q, readline/stream ichida bor"). Lekin valyuta kodida emitterlar allaqachon ishlayapti:

Kanon tajribasi (natijalar/tajriba/t27-events.txt, Node 24.21.0) bu darsga tegishli qismi:

1) error tinglovchisiz → throw: tinglovchisiz xato
2) await once(e, 'tayyor'): [ 42 ]
6) tinglovchilar tartibi: prependListener: [ 0, 1 ]

Birinchi qator — «"error" hodisasi — maxsus» bo'limidagi qoida. Ikkinchisi — once ning promise ko'rinishi, oltinchisi — prependListener (tinglovchini ro'yxat boshiga qo'shish). prependListener ni «Hodisa, callback yoki Promise?» bo'limida ko'rdik; once va qolgan qatorlar (3–5) — keyingi darsning mavzusi. Bu darsda commit yo'q.

9. Ko'p uchraydigan xatolar

10. Mashqlar

Mashqlar kurs/mashqlar/24/27-eventemitter/ da.

1-mashq (oson): natijani ayting

import { EventEmitter } from "node:events";

const e = new EventEmitter();
e.once("x", () => console.log("A"));
e.on("x", () => console.log("B"));
e.emit("x");
e.emit("x");
console.log(e.emit("y"));

Konsolda nechta qator va qaysilar chiqadi? Javob: (bo'shliq bilan).

A
B
B
false

2-mashq (o'rta): once ni o'zingiz yozing

«Mexanizmni o'zimiz yozamiz» bo'limidagi TinyEmitter ga once(name, fn) metodini qo'shing: tinglovchi bir marta chaqirilib, keyin o'zini off qilsin. Maslahat: fn ni o'rab oladigan yangi funksiya yarating, u avval off qilsin, keyin fn ni chaqirsin.

class TinyEmitter {
  #listeners = new Map();
  on(name, fn) {
    const list = this.#listeners.get(name) ?? [];
    this.#listeners.set(name, [...list, fn]);
    return this;
  }
  off(name, fn) {
    const list = this.#listeners.get(name) ?? [];
    this.#listeners.set(name, list.filter((f) => f !== fn));
    return this;
  }
  once(name, fn) {
    const wrapper = (...args) => {
      this.off(name, wrapper);
      fn.apply(this, args);
    };
    return this.on(name, wrapper);
  }
  emit(name, ...args) {
    const list = this.#listeners.get(name) ?? [];
    for (const fn of [...list]) fn.apply(this, args);
    return list.length > 0;
  }
}

const shop = new TinyEmitter();
shop.once("open", () => console.log("birinchi mijozga chegirma!"));
shop.on("open", (day) => console.log(`${day}: do'kon ochildi`));
shop.emit("open", "dushanba");
shop.emit("open", "seshanba");

birinchi mijozga chegirma!
dushanba: do'kon ochildi
seshanba: do'kon ochildi

3-mashq (qiyin): buyurtmalar navbati

Kitchen klassini EventEmitter dan meros qilib yozing. order(dish) — buyurtma qabul qiladi va "yangi" hodisasini chiqaradi. Buyurtma bo'sh satr bo'lsa — throw emas, "error" hodisasi (Error("Bo'sh buyurtma")). "tayyor" hodisasi — ready(dish) chaqirilganda. Tinglovchilar: hisoblagich ("yangi" larni sanaydi), "error" ni ekranga chiqaruvchi. Natija: buyurtmalar osh, "", manti; tayyor — osh.

import { EventEmitter } from "node:events";

class Kitchen extends EventEmitter {
  order(dish) {
    if (!dish.trim()) {
      this.emit("error", new Error("Bo'sh buyurtma"));
      return;
    }
    this.emit("yangi", dish);
  }
  ready(dish) {
    this.emit("tayyor", dish);
  }
}

const kitchen = new Kitchen();
let count = 0;
kitchen.on("yangi", (dish) => {
  count++;
  console.log(`${count}-buyurtma: ${dish}`);
});
kitchen.on("tayyor", (dish) => console.log(`${dish} tayyor`));
kitchen.on("error", (err) => console.log("xato:", err.message));

for (const dish of ["osh", "", "manti"]) kitchen.order(dish);
kitchen.ready("osh");
console.log("jami:", count);

1-buyurtma: osh
xato: Bo'sh buyurtma
2-buyurtma: manti
osh tayyor
jami: 2

4-mashq: CLI qadami — emitterlarni toping

O'z valyuta loyihangizda \.on\(|\.once\( ni qidiring (git grep -nE "\.on\(|\.once\(" src test). Har topilgan joy uchun yozing: qaysi obyekt, qaysi hodisa, "error" tinglovchisi kerakmi. Kod o'zgarmaydi.

11. Real ishda

• Node'ning o'zi — http.Server ("request"), net.Socket, stream'lar, process ("exit", "SIGINT"), child_process — hammasi EventEmitter. Ularni o'qish uchun shu darsdagi bilim yetadi.
• Kutubxonalar — Socket.IO, Mongoose, ws (WebSocket) — hodisalar bilan ishlaydi. NestJS'da hodisalar uchun alohida modul bor (keyingi qismlarda).
• Monolit ichida bo'linish — "buyurtma yaratildi" hodisasini chiqarib, email, hisob-faktura va statistika modullarini bir-biridan ajratish.
• Intervyu savollari: "emit sinxronmi yoki asinxron?" — sinxron; "error hodisasining tinglovchisi bo'lmasa nima bo'ladi?" — throw, jarayon yiqiladi.

Xulosa

• EventEmitter — "nom → tinglovchilar ro'yxati"; on, once, off, emit.
• emit sinxron: tinglovchilar shu zahoti, qo'shilgan tartibda chaqiriladi; emit ulardan keyin qaytadi.
• Konstruktordagi emit yo'qoladi — process.nextTick bilan keyinga suring.
• "error" tinglovchisiz emit qilinsa — throw; har xato chiqaradigan emitterga "error" tinglovchisi.
• extends EventEmitter — o'z hodisali klassingiz; ishni tinglovchilarga bo'ling.

Keyingi dars: EventEmitter chuqur — hodisani await qilish (events.once), for await bilan hodisalar oqimi, tinglovchi sizishi (memory leak) ogohlantirishi va brauzerdagi EventTarget.

Manbalar

• Node.js hujjati — Events (EventEmitter, "Asynchronous vs. synchronous", "Error events", newListener): https://nodejs.org/docs/latest-v24.x/api/events.html
• Node.js hujjati — process.nextTick va "Why use process.nextTick()?": https://nodejs.org/en/learn/asynchronous-work/understanding-processnexttick
• Kanon: natijalar/tajriba/t27-events.txt (Node 24.21.0, Windows 11, 2026-10-23); valyuta holat 24 testlari. Darsdagi node:events misollari — biz ishga tushirdik (Node 24.21.0).