---
title: "Издатель и подписчик в игре: порядок доставки событий, отписка и утечки памяти"
description: "Как устроить шину событий в 2D-игре на JavaScript: порядок доставки по приоритету, отписка прямо во время рассылки через снимок списка, разовая подписка once, очередь событий с разбором в конце кадра и лимитом 100 событий против бесконечных цепочек, и как 20 волн по 30 врагов оставляют 600 лишних обработчиков. Код проверен в Node.js 24."
slug: izdatel-i-podpischik-v-igre-poryadok-sobytij-otpiska-i-utechki
date: 2026-11-07
updated: 2026-11-07
scheduled_at: "2026-11-07T09:00:00+03:00"
rubric: logika-i-arhitektura
tags: ["sobytiya", "javascript", "arhitektura-igry", "otladka", "professionalam"]
reading_time: 10
draft: false
summary: "Шина событий отделяет того, кто сообщает о попадании, от звука, счёта и здоровья, которые на него реагируют, но порядок их вызова нужно задавать явно — приоритетом, а не порядком подписки. Рассылка идёт по снимку списка обработчиков, поэтому отписка во время события ничего не ломает. События, порождённые другими событиями, лучше класть в очередь и разбирать в конце кадра с лимитом. Каждый объект, который подписался, обязан отписаться при удалении — иначе 20 волн по 30 врагов оставят 600 обработчиков."
---

## Коротко

Шина событий отделяет того, кто сообщает о попадании, от звука, счёта и здоровья, которые на него реагируют, но порядок их вызова нужно задавать явно — приоритетом, а не порядком подписки. Рассылка идёт по снимку списка обработчиков, поэтому отписка во время события ничего не ломает, а события, порождённые другими событиями, лучше класть в очередь и разбирать в конце кадра с лимитом. Каждый объект, который подписался, обязан отписаться при удалении: в нашем прогоне 20 волн по 30 врагов без отписки оставили 600 обработчиков.

## Содержание

1. Зачем игре издатель и подписчик
2. Порядок доставки: приоритет вместо случайности
3. Отписка во время рассылки
4. Событие внутри события: сразу или в очередь
5. Утечки: подписчик, который пережил объект
6. Код на JavaScript
7. Практический сценарий: смерть врага
8. Когда вам это не подойдёт

## Зачем игре издатель и подписчик

Издатель и подписчик нужны, чтобы код, где враг получает удар, не вызывал напрямую звук, счёт, тряску камеры и достижения. Враг сообщает `emit('hit', данные)`, а каждый модуль сам подписывается через `on('hit', обработчик)`. Новый модуль добавляется без правки врага, а удалённый модуль не ломает остальные.

Цена — неявность: по коду врага больше не видно, что произойдёт после удара. Поэтому у шины должны быть понятные правила по четырём вопросам из таблицы.

| Вопрос | Правило в нашей шине |
|---|---|
| Кто вызывается первым | больший `priority`, при равном — порядок подписки |
| Что если подписчик отписался во время рассылки | текущая рассылка идёт по снимку, со следующей его нет |
| Что если обработчик породил новое событие | `emit` — сразу, `post` — в очередь до конца кадра |
| Кто отписывает | тот, кто подписался, через функцию, которую вернул `on` |

## Порядок доставки: приоритет вместо случайности

Порядок доставки задают приоритетом, потому что порядок подписки зависит от порядка загрузки модулей и меняется при любой перестановке импортов. Типичная ошибка: интерфейс показывает здоровье до того, как модуль здоровья его уменьшил, и полоса отстаёт на одно попадание.

Правило из нашего примера: модуль здоровья подписан с приоритетом 10, звук и счёт — с 0. Вывод прогона — `здоровье → звук → счёт`, хотя здоровье подписалось последним. Приоритетов должно быть мало, 2–3 уровня; если их десяток, это признак того, что модулям нужны отдельные события, например `hit` и `hitResolved`.

## Отписка во время рассылки

Отписка во время рассылки безопасна, если рассылка перебирает снимок списка, а отписка создаёт новый массив вместо удаления из текущего. Если удалять элемент из массива, по которому идёт цикл, следующий обработчик сдвигается на место удалённого и пропускается.

Отсюда честное правило, которое стоит записать в комментарий: подписчик, отписанный во время рассылки, ещё получит текущее событие, если он в снимке, и не получит следующее. В прогоне обработчик A при первом `tick` отписывает себя и B; B всё равно получает первый `tick`, а второй `tick` не получает никто. На этом же устроен `once` — подписка, которая снимает себя при первом вызове: два события `coin` дали 1 бонус и 0 оставшихся обработчиков.

## Событие внутри события: сразу или в очередь

Вложенное событие, отправленное через `emit`, обрабатывается немедленно — раньше, чем остальные подписчики исходного события. Когда враг умирает, обработчик смерти начисляет очки, и если сделать это через `emit`, счёт обновится до того, как второй подписчик смерти выбросит награду. Через `post` событие встаёт в очередь, и порядок получается `died 7 | drop | score +100`.

Очередь разбирается в конце кадра методом `flush` с лимитом. Лимит нужен против цепочек, где обработчик сам себе отправляет событие: без него кадр не закончится. В прогоне цепочка `ping → ping` остановилась на 100 событиях, одно осталось в очереди на следующий кадр. Если лимит срабатывает, это ошибка в логике, и в отладочной сборке её стоит выводить в консоль.

## Утечки: подписчик, который пережил объект

Утечка подписок возникает, когда объект удалён из игры, а его обработчик остался в шине и держит ссылку на объект. Сборщик мусора такой объект не освободит, а обработчик продолжит вызываться: в прогоне 20 волн по 30 врагов без отписки дали 600 обработчиков на `playerMoved` и 600 вызовов на одно движение игрока. С отпиской в конце волны — 0.

Рецепт: `on` возвращает функцию отписки, объект складывает такие функции в свой список и вызывает их при удалении. Отложенное удаление объектов разобрано в статье про спавн и пулы, а уборка подписок при смене сцены — в статье про сцены, ссылки в конце.

## Код на JavaScript

Код содержит шину с приоритетами, снимком при рассылке, `once`, очередью с лимитом и проверку утечек. Он запускается в Node.js 24, вывод совпадает с комментариями.

```js
function makeBus() {
  const handlers = new Map(); // имя -> массив { fn, priority }
  const queue = [];
  let dispatching = false;
  const bus = {
    on(name, fn, priority = 0) {
      const list = handlers.get(name) ?? [];
      list.push({ fn, priority });
      list.sort((a, b) => b.priority - a.priority); // сортировка стабильная: при равном приоритете — порядок подписки
      handlers.set(name, list);
      return () => {
        const cur = handlers.get(name) ?? [];
        handlers.set(name, cur.filter((h) => h.fn !== fn)); // новый массив, текущая рассылка не ломается
      };
    },
    once(name, fn, priority = 0) {
      const off = bus.on(name, (data) => { off(); fn(data); }, priority);
      return off;
    },
    emit(name, data) { // сразу
      for (const h of handlers.get(name) ?? []) h.fn(data); // перебираем снимок массива
    },
    post(name, data) { // в очередь, разбор в конце кадра
      queue.push({ name, data });
    },
    flush(limit = 100) {
      if (dispatching) return 0;
      dispatching = true;
      let n = 0;
      while (queue.length && n < limit) { const e = queue.shift(); bus.emit(e.name, e.data); n++; }
      dispatching = false;
      return n;
    },
    count(name) { return handlers.get(name)?.length ?? 0; },
    pending() { return queue.length; },
  };
  return bus;
}

// 1. Порядок доставки
const bus = makeBus();
const order = [];
bus.on('hit', () => order.push('звук'));
bus.on('hit', () => order.push('счёт'));
bus.on('hit', () => order.push('здоровье'), 10);
bus.emit('hit');
console.log(order.join(' → ')); // здоровье → звук → счёт

// 2. Отписка во время рассылки
const got = [];
const offA = bus.on('tick', () => { got.push('A'); offA(); offB(); });
const offB = bus.on('tick', () => got.push('B'));
bus.emit('tick'); bus.emit('tick');
console.log(got.join(' ')); // A B — B получил первое событие из снимка, второе не получил никто

// 3. once
let bonus = 0;
bus.once('coin', () => bonus++);
bus.emit('coin'); bus.emit('coin');
console.log(bonus, bus.count('coin')); // 1 0

// 4. Цепочка: событие внутри события
const chain = [];
bus.on('enemyDied', (e) => { chain.push('died ' + e.id); bus.post('scoreChanged', 100); });
bus.on('scoreChanged', (s) => chain.push('score +' + s));
bus.on('enemyDied', () => chain.push('drop'));
bus.emit('enemyDied', { id: 7 });
bus.flush();
console.log(chain.join(' | ')); // died 7 | drop | score +100

// 5. Бесконечная цепочка ограничена лимитом
const loop = makeBus();
loop.on('ping', () => loop.post('ping'));
loop.post('ping');
console.log(loop.flush(100), loop.pending()); // 100 1

// 6. Утечка: враги подписываются и удаляются без отписки
const leak = makeBus();
let calls = 0;
for (let wave = 0; wave < 20; wave++) {
  for (let i = 0; i < 30; i++) leak.on('playerMoved', () => { calls++; });
}
leak.emit('playerMoved');
console.log(leak.count('playerMoved'), calls); // 600 600

const clean = makeBus();
for (let wave = 0; wave < 20; wave++) {
  const offs = [];
  for (let i = 0; i < 30; i++) offs.push(clean.on('playerMoved', () => {}));
  offs.forEach((off) => off()); // волна закончилась — отписали всех
}
console.log(clean.count('playerMoved')); // 0
```

Сортировка при каждой подписке стоит `O(n log n)`; для десятков подписчиков на событие это незаметно, а если их тысячи, держите отдельные массивы по приоритетам.

## Практический сценарий: смерть врага

Возьмём аркаду, где при смерти врага должны сработать 4 реакции: уменьшить счётчик живых врагов, выбросить награду, начислить очки и проверить конец волны. Входное условие: экран «Волна пройдена» не должен появиться раньше, чем начислены очки за последнего врага. Порядок работы:

1. **Событие.** Враг при смерти вызывает `emit('enemyDied', { id, x, y, reward })` и больше ничего не знает.
2. **Приоритеты.** Счётчик живых врагов — приоритет 10, награда и очки — 0.
3. **Очередь.** Очки начисляются через `post('scoreChanged', reward)`, проверка конца волны подписана на `scoreChanged` и тоже уходит в очередь через `post('waveCheck')`.
4. **Разбор.** В конце кадра `flush(100)`: сначала очки, потом проверка волны — экран победы видит уже итоговый счёт.
5. **Отписка.** Каждый враг, который подписывался, например на `playerMoved`, хранит функции отписки и вызывает их при удалении.
6. **Проверка.** После 20 волн число обработчиков `playerMoved` равно числу живых врагов, а не числу всех когда-либо созданных.

## Когда вам это не подойдёт

Шина событий полезна для связей «один ко многим», но не для всех случаев:

- **Строгая последовательность из 2–3 шагов.** Если после удара всегда нужно уменьшить здоровье и обновить полосу, прямой вызов функции понятнее и проще в отладке, чем событие с приоритетами.
- **Горячий цикл.** Сотни снарядов, которые каждый кадр сообщают о позиции, дешевле обработать одним циклом по массиву, чем тысячами `emit`.
- **Нужен ответ.** Шина рассылает сообщения, но не возвращает результат. Вопрос «можно ли открыть дверь» — это вызов функции, а не событие.
- **Маленькая игра в одном файле.** Для мини-игры на 300 строк шина добавит слой, который сложнее читать, чем сам код.

Мы разрабатываем **J2DRU** — браузерный 2D игровой движок, где логика собирается из событий, условий и действий, а проект можно углублять на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на [странице раннего доступа](/early-access?utm_source=blog&utm_medium=article&utm_campaign=izdatel-i-podpischik-v-igre-poryadok-sobytij-otpiska-i-utechki) (подача заявки не гарантирует приглашение).

**Источники:** внешних фактов в статье нет. Приоритеты, лимит очереди 100, число волн и врагов и все выводы — наш пример и наш прогон в Node.js 24.

**Читайте также:**
- [Сцены и переходы на JavaScript: меню, уровень, пауза, экран победы и передача счёта](/blog/sceny-i-perehody-na-javascript-menyu-uroven-pobeda)
- [Спавн и удаление объектов в 2D-игре: время жизни, отложенное удаление и пулы](/blog/spavn-i-udalenie-obektov-v-2d-igre-vremya-zhizni-i-puly)
- [Модульная архитектура логики 2D-игры без циклических зависимостей](/blog/modulnye-listy-sobytij-i-funkcii-v-2d-proekte)
