我们可以从传递给事件发射器的回调函数中结束一个异步函数而不承诺事件发射器吗？

否. async/await语法只是then调用的糖，依赖于promise。

async function bakeMeSomeBurgers () {
  let canIHave = await canIHazACheezBurger();
  if (canIHave)
    console.log('Hehe, you can have...');
  else
    console.log('NOPE');

  // Here we create and await our promise:
  await new Promise((resolve, reject) => {
    // Here invoke our event emitter:
    let cook = new BurgerCooking('cheez');
    // a normal event callback:
    cook.on('update', percent => {
      console.log(`The burger is ${percent}% done`);
    });
    cook.on('end', resolve); // call resolve when its done
    cook.on('error', reject); // don't forget this
  });

  console.log('I\'ve finished the burger!');
  if (canIHave)
    console.log('Here, take it :)');
  else
    console.log('Too bad, you can\'t have it >:)');
}

字符串

下面是一个类，它扩展了Node.js EventEmitter以支持异步事件侦听器，并提供了一个函数来等待事件完全处理，然后再继续执行代码的其余部分：

import EventEmitter from 'events';

export const EventResolverSymbol = Symbol.for('EventResolver');

export class AsyncEventEmitter extends EventEmitter {
  private listenerMap = new WeakMap<
    (...args: any[]) => void,
    (...args: any[]) => void
  >();

  emitAsync(eventName: string | symbol, ...args: any[]): Promise<void> {
    return new Promise(async resolve => {
      resolve.prototype.key = EventResolverSymbol;
      super.emit(eventName, ...args, resolve);
    });
  }

  on(eventName: string | symbol, listener: (...args: any[]) => void): this {
    const wrappedListener = async (...args: any[]) => {
      // check if event called from `awaitForEventDone` function
      if (args?.length) {
        const resolver = args[args.length - 1];
        if (
          typeof resolver === 'function' &&
          resolver.prototype.key === EventResolverSymbol
        ) {
          try {
            await listener(...args);
          } catch (e) {}
          return await resolver();
        }
      }
      return await listener(...args);
    };
    this.listenerMap.set(listener, wrappedListener);
    return super.on(eventName, wrappedListener);
  }

  once(eventName: string | symbol, listener: (...args: any[]) => void): this {
    const wrappedListener = async (...args: any[]) => {
      if (args?.length) {
        const resolver = args[args.length - 1];
        if (
          typeof resolver === 'function' &&
          resolver.prototype.key === EventResolverSymbol
        ) {
          try {
            await listener(...args);
          } catch (e) {}
          // remove listeners after the event is done
          this.removeListener(eventName, listener);
          this.removeListener(eventName, wrappedListener);
          return await resolver();
        }
      }
      // remove listeners after the event is done
      this.removeListener(eventName, listener);
      this.removeListener(eventName, wrappedListener);
      return await listener(...args);
    };
    this.listenerMap.set(listener, wrappedListener);
    return super.once(eventName, wrappedListener);
  }

  removeListener(
    eventName: string | symbol,
    listener: (...args: any[]) => void,
  ): this {
    const wrappedListener = this.listenerMap.get(listener);
    if (wrappedListener) {
      this.listenerMap.delete(listener);
      return super.removeListener(eventName, wrappedListener);
    }

    return this;
  }

  off = this.removeListener;
}

字符串

示例

// Create a new async event emitter
 const emitter = new AsyncEventEmitter();
 
 // Define an async event listener
 const listener = async (message: string) => {
   console.log('event start with param: ', message);
   await sleep(5000);
 };
 
 // Listen for 'greet' event
 emitter.on('TestEvent', listener);
 
 // Emit the 'greet' event and wait for it to be done
 emitter.emitAsync('TestEvent', 'Hello World!');
    // will be call after 5000ms delay
   .then(() => console.log('event done'));

型