Der EventEmitter

// A small emitter with the rules of EventEmitter's on, once, off and emit.
export function createEmitter() {
  const listeners = new Map(); // event name -> array of functions

  function on(name, fn) {
    if (!listeners.has(name)) listeners.set(name, []);
    listeners.get(name).push(fn);
  }

  function off(name, fn) {}

  function once(name, fn) {
    on(name, fn);
  }

  function emit(name, ...args) {
    for (const fn of listeners.get(name) ?? []) fn();
  }

  return {on, once, off, emit};
}

const door = createEmitter();
door.on('open', (who) => console.log('hello', who));
door.once('open', () => console.log('first visitor'));
console.log(door.emit('open', 'Ada'), door.emit('open', 'Lin'), door.emit('close'));

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {createEmitter} from './main.js';

test('Listener laufen in der Reihenfolge des Hinzufügens, mit den Argumenten von emit', () => {
  const e = createEmitter();
  const seen = [];
  e.on('sale', (item, price) => seen.push('first ' + item + ' ' + price));
  e.on('sale', (item) => seen.push('second ' + item));
  e.emit('sale', 'tea', 3);
  assert.deepEqual(seen, ['first tea 3', 'second tea'], `die Listener sahen ${JSON.stringify(seen)}`);
});

test('emit liefert true mit Listenern und false ohne', () => {
  const e = createEmitter();
  e.on('sale', () => {});
  assert.equal(e.emit('sale'), true, 'emit für ein Event mit Listener sollte true liefern');
  assert.equal(e.emit('refund'), false, 'emit für ein Event ohne Listener sollte false liefern');
});

test('off entfernt eine Instanz der Funktion', () => {
  const e = createEmitter();
  let calls = 0;
  const count = () => calls++;
  e.on('ping', count);
  e.on('ping', count);
  e.off('ping', count);
  e.emit('ping');
  assert.equal(calls, 1, `count lief nach zweimal on und einmal off ${calls}-mal; erwartet war 1-mal`);
  e.off('ping', count);
  assert.equal(e.emit('ping'), false, 'nach dem Entfernen beider Instanzen sollte emit false liefern');
});

test('Ein once-Listener läuft nur beim nächsten emit', () => {
  const e = createEmitter();
  let calls = 0;
  e.once('ring', (n) => (calls += n));
  assert.equal(e.emit('ring', 5), true, 'das erste emit sollte den once-Listener finden');
  assert.equal(e.emit('ring', 5), false, 'das zweite emit sollte keinen Listener finden');
  assert.equal(calls, 5, `der once-Listener kam auf ${calls}; erwartet war 5`);
});

test('Ein Listener, der sich selbst entfernt, lässt den nächsten nicht ausfallen', () => {
  const e = createEmitter();
  const seen = [];
  const first = () => {
    seen.push('first');
    e.off('open', first);
  };
  e.on('open', first);
  e.on('open', () => seen.push('second'));
  e.emit('open');
  assert.deepEqual(seen, ['first', 'second'], `gelaufen sind die Listener ${JSON.stringify(seen)}`);
});

{
  "type": "module"
}

import {EventEmitter} from 'node:events';

// A kettle that reports what it does as events.
export class Kettle extends EventEmitter {
  constructor() {
    super();
    this.temperature = 20;
  }

  // Heats in steps of 20 degrees up to target, with a 'temperature' event for each
  // new value, then 'boiled' at 100. Above 100: an 'error' event, and no heating.
  heat(target) {
    this.temperature = target;
  }
}

const kettle = new Kettle();
kettle.on('temperature', (degrees) => console.log(degrees + ' degrees'));
kettle.once('boiled', () => console.log('boiled'));
kettle.on('error', (error) => console.log('error:', error.message));
kettle.heat(100);
kettle.heat(120);

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {Kettle} from './main.js';

test('heat(80) emittiert temperature 40, 60 und 80', () => {
  const kettle = new Kettle();
  const seen = [];
  kettle.on('temperature', (degrees) => seen.push(degrees));
  kettle.heat(80);
  assert.deepEqual(seen, [40, 60, 80], `die temperature-Events waren ${JSON.stringify(seen)}`);
});

test('Die Schritte gehen nie über das Ziel hinaus', () => {
  const kettle = new Kettle();
  const seen = [];
  kettle.on('temperature', (degrees) => seen.push(degrees));
  kettle.heat(50);
  assert.deepEqual(seen, [40, 50], `die temperature-Events waren ${JSON.stringify(seen)}`);
});

test('boiled wird einmal emittiert, wenn 100 erreicht ist', () => {
  const kettle = new Kettle();
  let boiled = 0;
  kettle.on('boiled', () => boiled++);
  kettle.heat(60);
  assert.equal(boiled, 0, 'bei 60 Grad sollte boiled nicht emittiert werden');
  kettle.heat(100);
  assert.equal(boiled, 1, `boiled wurde ${boiled}-mal emittiert; erwartet war 1-mal`);
});

test('Über 100 ein error-Event mit RangeError und kein Heizen', () => {
  const kettle = new Kettle();
  const errors = [];
  kettle.on('error', (error) => errors.push(error));
  kettle.heat(120);
  assert.equal(errors.length, 1, `es gab ${errors.length} error-Events; erwartet war 1`);
  assert.ok(errors[0] instanceof RangeError, 'das error-Event sollte einen RangeError tragen');
  assert.equal(kettle.temperature, 20, `die Temperatur ist ${kettle.temperature}; sie sollte 20 bleiben`);
});

test('Ohne error-Listener wirft heat(120) den RangeError', () => {
  assert.throws(() => new Kettle().heat(120), RangeError, 'heat(120) ohne error-Listener sollte einen RangeError werfen');
});

{
  "type": "module"
}