以同步方式调用异步 socket.io io.emit()

Question

全新的插座 io 在这里。

我想发出从我在服务器上运行的循环中运行的数据。 循环运行一段时间（几秒钟，最多几分钟），我想从我的节点服务器发出数据，然后我想在浏览器的客户端上可视化（使用图表 js）。 基本上是实时数据图表。

发生的问题是，显然只有在循环完成后才会触发发射。 据我了解，因为发出 function 是异步的（非阻塞）。 而且由于循环本身会阻塞直到完成（最初使用 while 循环），所以异步调用只会在之后触发。 正确的？

while (CONDITION) {
  ...
io.emit('data update', DATA);
}

现在我想出了自己的解决方案，但感觉很笨拙。 我想知道是否有更好的，更多的书本方法来做到这一点。 我现在正在做的是递归调用循环步骤（最后我调用emit）作为对持续时间设置为0的setTimeout（）的回调。

function loopStep() {
  if (CONDITION) {
    ...
    io.emit('data update', DATA);
    setTimeout(loopStep,0)
  }
}

setTimeout(loopStep,0);

我的问题是，还有其他更好的方法吗？

编辑：

我被要求添加完整的代码。

这是早期（循环）版本的完整代码代码（据我所知，不得不在这里快速重建）：

let stp = 0;
while (stp < maxLogStep) {
    let new_av_reward;

        var smallStep = 0;
        

        while (smallStep < maxSmallStep) {


            let ran1 = get_random();
            let cum_prob = 0;

            let chosen_action = pref.findIndex((el, i) => {
                let pro = prob(i);
                let result = pro + cum_prob > ran1;
                cum_prob += pro;
                return result;
            })

            let cur_reward = get_reward(chosen_action);
            if (stp*maxSmallStep + smallStep == 0) {
                new_av_reward = cur_reward
            } else {
                new_av_reward = prev_av_reward + (cur_reward - prev_av_reward) / (stp * maxSmallStep + smallStep)
            }
            let cur_prob = prob(chosen_action);

            pref.forEach((element, index, array) => {
                if (chosen_action === index) {
                    array[index] = element + stepSize * (cur_reward - new_av_reward) * (1 - cur_prob)
                } else {
                    array[index] = element - stepSize * (cur_reward - new_av_reward) * (cur_prob)
                }
            });
            prev_av_reward = new_av_reward;
            smallStep++
        }


        io.emit('graph update', {
            learnedProb: [prob(0), prob(1), prob(2)],
            averageReward: new_av_reward,
            step: stp * maxSmallStep + smallStep
        });
        stp++
    };

这是带有 setTimeout 的递归 function：

function learnStep(stp, prev_av_reward) {
    let new_av_reward;
    if (stp < maxLogStep) {
        var smallStep = 0;
        

        while (smallStep < maxSmallStep) {


            let ran1 = get_random();
            let cum_prob = 0;

            let chosen_action = pref.findIndex((el, i) => {
                let pro = prob(i);
                let result = pro + cum_prob > ran1;
                cum_prob += pro;
                return result;
            })

            let cur_reward = get_reward(chosen_action);
            if (stp*maxSmallStep + smallStep == 0) {
                new_av_reward = cur_reward
            } else {
                new_av_reward = prev_av_reward + (cur_reward - prev_av_reward) / (stp * maxSmallStep + smallStep)
            }
            let cur_prob = prob(chosen_action);

            pref.forEach((element, index, array) => {
                if (chosen_action === index) {
                    array[index] = element + stepSize * (cur_reward - new_av_reward) * (1 - cur_prob)
                } else {
                    array[index] = element - stepSize * (cur_reward - new_av_reward) * (cur_prob)
                }
            });
            prev_av_reward = new_av_reward;
            smallStep++
        }


        io.emit('graph update', {
            learnedProb: [prob(0), prob(1), prob(2)],
            averageReward: new_av_reward,
            step: stp * maxSmallStep + smallStep
        });
        setTimeout(learnStep, 0, stp + 1, new_av_reward);
    };

Answer 1

如果您的目标是确保在发出完成并且客户端接收并确认该数据之前保持您的 while 循环，您可能需要考虑使用 Promises 和 socket.io 确认功能，如下例所示：

服务器端

io.on("connection", async (socket) => {

  // ...
  while (CONDITION) {
    //  ...
    await new Promise((resolve, reject) => {
      io.emit('data update', data, (ack) => {
        //client acknowledged received
        resolve(true)
      });        
    });
  }
  
});

客户端

socket.on("data update", (data, fn) => {
  console.log(data)
  fn("ack");
});