如何在异步函数中分配在同步作用域中定义的变量

Question

我正在尝试编写一个使用服务获取有关系统数据的 GUI 前端。我正在为此客户端使用net.Socket。我希望能够访问其他模块的数据事件处理程序中分配的某些变量，但该回调函数完成后赋值不会保留。

有问题的代码：

client.on('data', (data) => {
      var array = [...data];
      array.splice(0,2);
      for (var i=0;i<array.length;i++) {
        dataInBuffer = dataInBuffer + String.fromCharCode(array[i]);
      }
      console.log(dataInBuffer);
      if (dataInBuffer.startsWith('batStat')) {
        let lastBatteryJSON = JSON.parse(dataInBuffer.split(';')[1]);
        module.exports.hasBattery = lastBatteryJSON.hasBattery == 'true';
        module.exports.isCharging = lastBatteryJSON.isCharging == 'true';
        module.exports.lastBatteryReading = parseFloat(lastBatteryJSON.batteryLife);
      }
      dataInBuffer = '';
    });

这三个导出的变量赋值实际上不起作用，变量始终保持未定义状态，或者它们的默认值在函数之外。我尝试使用承诺来解决这个问题，但得到了相同的结果。我不知所措，找不到任何其他问题或论坛帖子来解决这个问题。

编辑我无法选择将依赖于这些变量的代码移动到回调中。为了做到这一点，我必须每帧等待数据并因此淹没服务器。

Answer 1

正如苹果评论的那样; 您可以导出一个对象并在每次收到数据时对其进行更改：

const data = {};
client.on('data', (data) => {
  var array = [...data];
  array.splice(0, 2);
  for (var i = 0; i < array.length; i++) {
    dataInBuffer = dataInBuffer + String.fromCharCode(array[i]);
  }
  console.log(dataInBuffer);
  if (dataInBuffer.startsWith('batStat')) {
    let lastBatteryJSON = JSON.parse(dataInBuffer.split(';')[1]);
    //mutate the data object
    data.hasBattery = lastBatteryJSON.hasBattery == 'true';
    data.isCharging = lastBatteryJSON.isCharging == 'true';
    data.lastBatteryReading = parseFloat(lastBatteryJSON.batteryLife);
  }
  dataInBuffer = '';
});
//export the data object
module.exports.batteryData = data;

或者，当CertainPerformance回答时，您可以让呼叫者决定何时询问信息并提供承诺。

以下是 CertainPerformance 答案的扩展版本，它也会侦听错误，因此可以拒绝承诺，并在解决或拒绝承诺时清理事件侦听器：

//wrapper for client.on to add and remove event listeners
const listeners = (function(){
  var listenerCounter = -1;
  const listeners = [];
  const triggerEvent = event => data =>{
    listeners.filter(
      listener=>listener[2] === event
    ).forEach(
      listener=>listener[1](data)
    );
  };
  client.on('data', triggerEvent("data"));
  client.on('error', triggerEvent("error"));//assuming you have an error event
  return {
    add:(event,fn)=>{
      listenerCounter = listenerCounter + 1;
      if(listenerCounter>1000000){
        listenerCounter=0;
      }
      listeners.push([listenerCounter,fn,event]);
      return listenerCounter;
    },
    remove:num=>{
      listeners = listeners.filter(
        listener=>{
          num !== listener[0];
        }
      )
    }
  }
}());
//convert data to object or false
const getObjectFromData = data => {
  var array = [...data];
  var dataInBuffer="";
  array.splice(0,2);
  for (var i=0;i<array.length;i++) {
    dataInBuffer = dataInBuffer + String.fromCharCode(array[i]);
  }
  console.log(dataInBuffer);
  if (dataInBuffer.startsWith('batStat')) {
    let lastBatteryJSON = JSON.parse(dataInBuffer.split(';')[1]);
    return {
      hasBattery : lastBatteryJSON.hasBattery == 'true',
      isCharging : lastBatteryJSON.isCharging == 'true',
      lastBatteryReading : parseFloat(lastBatteryJSON.batteryLife)
    };
  }
  return false;
}
//export this function
const getBatteryData = () =>  
  new Promise((resolve,reject) => {
    const removeListeners = ()=>{
      listeners.remove(okId);
      listeners.remove(errorId);
    }
    const okId = listeners.add(
      "data",
      data=>{
        const resultObject = getObjectFromData(data);
        if(resultObject){
          resolve(data);
          removeListeners();//clean up listeners
        }else{
          //not sure of on data is triggered multiple times by client.on.data
          //  if it is then at what point do we need to reject the returned promise?
        }
      }
    )
    const errorId = listeners.add(
      "error",
      error=>{
        reject(error);
        removeListeners();//clean up listeners
      }
    )
  });
  //you can call getBatteryData like so:
  //getBatteryData()
  // .then(batteryData=>console.log(batteryData))
  // .catch(error=>console.warn("an error getting battery data:",error))

Answer 2

您的模块应导出一个函数，该函数返回返回返回所需值的承诺。此外，尽可能使用const而不是var：

let resolveObj;
const haveData = new Promise((resolve) => {
  let resolved = false;
  client.on('data', (data) => {
    const array = [...data];
    array.splice(0, 2);
    for (let i = 0; i < array.length; i++) {
      dataInBuffer = dataInBuffer + String.fromCharCode(array[i]);
    }
    console.log(dataInBuffer);
    if (dataInBuffer.startsWith('batStat')) {
      const {
        hasBattery,
        isCharging,
        batteryLife,
      } = JSON.parse(dataInBuffer.split(';')[1]);
      resolveObj = {
        hasBattery: hasBattery === 'true',
        isCharging: isCharging === 'true',
        lastBatteryReading: Number(batteryLife),
      };
      if (!resolved) resolve();
      resolved = true;
    }
    dataInBuffer = '';
  });
});
const getData = () => haveData.then(() => resolveObj);
module.exports = getData;

然后与

moduleFunction().then(({ hasBattery, isCharging, lastBatteryReading }) => {
  // do something with results
});

如果在填充 resolveObj 之前调用，则承诺将等到第一个client.on('data'解析。之后，该函数将返回一个承诺，该承诺立即解析为当前值resolveObj(将在client.on('data'上正确更新(