Javascript 如何编写一个异步函数，在触发'data'事件发射器时解析该函数

我正在使用node serialport与一个硬件进行通信。它只写一个命令并接收一个响应

以下代码起作用：

const port = new SerialPort(path);
const parser = port.pipe(new Readline({ delimiter: '\r', encoding: 'ascii' }));

const requestArray = [];

parser.on('data', (data) => {
  // get first item in array
  const request = requestArray[0];

  // remove first item
  requestArray.shift();

  // resolve promise
  request.promise.resolve(data);
});

export const getFirmwareVersion = async () => {
  let resolvePromise;
  let rejectPromise;

  const promise = new Promise((resolve, reject) => {
    resolvePromise = resolve;
    rejectPromise = reject;
  });

  const title = 'getFirmwareVersion';
  const cmd = 'V\r';

  requestArray.push({
    title,
    cmd,
    promise: {
      resolve: resolvePromise,
      reject: rejectPromise
    }
  });

  await v2Port.write(cmd);

  return promise;
};

然后从我的应用程序（用electron/react编写）调用该函数：

<Button onClick={() => {
  let data = await _api.getFirmwareVersion();
  console.log('done waiting...');
  console.log(data);
}>
  Click Me
</Button>

{
让data=wait_api.getFirmwareVersion（）；
log（'done waiting…'）；
控制台日志（数据）；
}>
点击我

我是否可以重构此代码以使其更简洁

有没有办法从

async

函数中获得承诺，而不必做出新的承诺

有没有一种方法可以利用已经存在的转换流，并以某种方式将承诺导入其中

我还不熟悉async/await，希望避免使用回调，尤其是在React/Redux方面

---

我的目标是为api提供许多这样的端点（即

getFirmwareVersion

，

getTemperature

，等等）。所以我想让代码尽可能简洁。我不想让UI了解API是如何获取数据的。它只需要像其他API一样请求它，然后等待响应。

哦，我想我明白了。解析器不断地接收数据。因此，当一个请求到来时，您等待下一个数据，并在它到达时发送它。我建议你写一个中级班

像这样：

const SerialPort = require('serialport')
const Readline = require('@serialport/parser-readline')
const { EventEmitter } = require('events');

class SerialPortListener extends EventEmitter {
  constructor(path) {
    super();
    this.serialPortPath = path;
  }

  init() {
    this.serialPort = new SerialPort(this.serialPortPath);
    const parser = this.serialPort.pipe(new Readline({ delimiter: '\r', encoding: 'ascii' }));

    parser.on('data', data => this.emit('data', data));
  }
}

然后可以修改getFirmwareVersion，如下所示：

const serialPortListener = new SerialPortListener(path);

serialPortListener.init();

export const getFirmwareVersion = () => {
  return new Promise((resolve, reject) => {
    serialPortListener.once('data', async (data) => {
      try {
        const cmd = 'V\r';
        await v2Port.write(cmd);
        resolve(data);
      } catch (ex) {
        reject(ex);
      }
    });
  });
};

---

基于Mehmet的帮助，以下是我的结论：

const _port = new SerialPort(path);
const _parser = _port.pipe(new Readline({ delimiter: '\r', encoding: 'ascii' }));

const waitForData = async () => {
  return new Promise((resolve, reject) => {
    const timeoutId = setTimeout(() => reject('Write Timeout'), 500);

    _parser.once('data', (data) => {
      clearTimeout(timeoutId);
      resolve(data);
    });
  });
};

const createAPIFunction = (cmdTemplate, validationString) => {
  return async (config) => {
    try {
      // replace {key} in template with config[key] props
      const cmd = cmdTemplate.replace(/{(\w+)}/g, (_, key) => {
        return config[key];
      });

      _port.write(cmd + '\r');

      const data = await waitForData();

      // validate data
      if (data.startsWith(validationString)) {
        // is valid
        return data;
      } else {
        // invalid data
        throw new Error('Invalid Data Returned');
      }
    } catch (err) {
      throw err;
    }
  };
};

export const getFirmwareVersion = createAPIFunction('V', 'V1');
export const enableSampling = createAPIFunction('G1{scope}', 'G11');