Nodejs 8.x:EventEmitter 异步/等待

Question

在其他信息来源中，我如何将async函数与事件发射器一起使用：请勿将async函数与事件emitter一起使用。

我基本上希望将异步函数与事件发射器混合，以便它可以解决并显示邮件。

代码如下：

server.on('published', async (packet, client) => { // event emitter with async function
  debug(`Received: ${packet.topic}`)
  switch (packet.topic) {
    case 'agent/connected':
    case 'agent/disconnected':
      debug(`Payload: ${packet.payload}`)
      break
    case 'agent/message':
      debug(`Payload: ${packet.payload}`)
      const payload = parsePayload(packet.payload)
      if (payload) {
        payload.agent.connected = true
        let agent
        try {
          agent = await Agent.createOrUpdate(payload.agent)
        } catch (e) {
          return handleError(e)
        }
        debug(`Agent ${agent.uuid} saved`)
        // Notify Agent is Connected
        if (!clients.get(client.id)) {
          clients.set(client.id, agent)
          server.publish({
            topic: 'agent/connected',
            payload: JSON.stringify({
              agent: {
                uuid: agent.uuid,
                name: agent.name,
                hostname: agent.hostname,
                pid: agent.pid,
                connected: agent.connected
              }
            })
          })
        }
        // Store Metrics
        for (let metric of payload.metrics) {
          let m
          try {
            m = await Metric.create(agent.uuid, metric)
          } catch (e) {
            return handleError(e)
          }
          debug(`Metric ${m.id} saved on agent ${agent.uuid}`)
        }
      }
      break
  }
})

我想道歉，如果这个问题已经在某个地方完成。我在nodejs中新来，我什么也没发现。

标题Nodejs 7：EventEmitter 等待/异步中的类似问题，但与此问题无关。

Answer 1

在事件emmiter中使用异步函数的主要问题是，您无法处理结果拒绝。因此，您可以做这样的事情：

const asyncEventHandler = async function(...args) { /* do anything here */ };
const eventHandlerWrapper = function(...args) {
  const promise = asyncEventHandler(...args);
  promise.catch(function(error) {
    // handle error here
  });
};
emitter.on("some-event", eventHandlerWrapper);

另一方面 - 使用同步函数，您知道，听众将按顺序调用（下一个在上一端时开始）。使用异步侦听器，下一个侦听器将在当前侦听器中的第一个await之后立即开始。而且您无能为力。