【问题标题】:Break out of for(ever) loop by resolved Promise通过已解决的 Promise 打破 for(ever) 循环
【发布时间】:2022-02-02 03:57:08
【问题描述】:

我希望这是一个简单的问题,但我目前无法解决问题。

我想要做的是跳出一个 while 循环,该循环在承诺得到解决时包含延迟。

在伪代码中,这看起来像:

while( ! promise.resolved ){
    doSomthing()
    await sleep( 5min )
}

循环必须在 promise 解决后立即中断,而不是等待 sleep 完成。

sleep 目前由setTimeout 简单实现,但可以以不同方式实现。

我希望在等待的 promise 和 sleep 之间进行某种空间分离,以更清楚地显示它的工作原理*)(并且因为我希望有一个优雅的解决方案可供学习)。 那么但我不喜欢可行的方法是:

while( true ){

    doSomething()
    try {
        await Promise.race([promise,rejectAfter(5000)])
        break
    } catch( e ){}
} 

如果你必须知道:

doSomething 正在发送状态信息。

promise 正在等待用户交互。

*) 这段代码的部分目的是向其他人展示/演示事物的预期工作方式。因此,我正在寻找这种实施水平上最清晰的解决方案。

【问题讨论】:

  • 好问题。等待解决方案。
  • 我有理由确定你可以给 while 循环一个标签,然后调用 break label 语法,例如someLabel: while(true) { ... other code ... break someLabel }
  • 更好的解决方案,不要依赖这种模式。
  • “等待的承诺和睡眠之间存在某种空间分离”是什么意思?
  • @Scheintod 啊,在那种情况下,只需编写一个函数,适当地命名它并很好地记录它。甚至可以使用一些流畅的 API,例如 const result = await runInterval(doSomething,5000).untilPromiseSettles( someTask() );。然后您可以将任何可能的实现放入该函数中,读者不会在意。是的,控制异步代码中的异常流很难:-)

标签: javascript asynchronous promise


【解决方案1】:

一种方法是等待承诺结果,假设它是一个真实值1:

const promise = someTask();
let result = undefined;
while (!result) {
    doSomething();
    result = await Promise.race([
        promise, // resolves to an object
        sleep(5000), // resolves to undefined
    ]);
}

1: 如果不是,则将.then(_ => true) 链接到promise,或者使sleep 实现一个特殊值,您可以将其与someTask 可能返回的所有内容区分开来(例如杰夫的答案中的符号)。

同样适用于 do-while 循环,因为 result 一开始总是未定义:

const promise = someTask();
let result = undefined;
do {
    doSomething();
    result = await Promise.race([
        promise, // resolves to an object
        sleep(5000), // resolves to undefined
    ]);
} while (!result);

这里的缺点是如果doSomething() 抛出异常,则永远不会等待承诺,并且可能会在任务出错时导致未处理的拒绝崩溃。


另一种方法是不使用循环,而是使用老式间隔:

const i = setInterval(doSomething, 5000);
let result;
try {
    result = await someTask();
} finally {
    clearInterval(i);
}

这里的一个缺点是doSomething 不会立即被调用,而只会在第一次 5 秒后调用。此外,如果doSomething 抛出异常,它会立即使应用程序崩溃。如果您不希望 doSomething 抛出(或在 setInterval 回调中处理每个异常并希望“循环”继续进行),它仍然可能是一个好方法。


从someTask() 和doSomething() 转发所有异常的“正确”方法可能如下所示:

let done = false;
const result = await Promise.race([
    (async() => {
        while (!done) {
            doSomething();
            await sleep(5000)
        }
    })(),
    someTask().finally(() => {
        done = true;
    }),
]);

(除了.finally(),您还可以将Promise.race 包裹在try-finally 中,就像方法二一样。)

与方法二相比,唯一的小缺点是sleep(5000) 将继续运行,并且不会在someTask 完成时立即取消(即使result 立即可用),这可能会阻止您的程序尽快退出随心所欲。

【讨论】:

  • 嗨,Bergi。第一部分是我不想做的。请参阅我在 VLAZ 的回答中的评论。我喜欢第二部分保持简单的方法。
  • @Scheintod 如果您想要干净的代码将循环与主要流程分开,我建议将其放入辅助函数并执行const result = await runUntilSettled(someTask(), doSomething, 5000)。 runUntilSettled 可以像 VLAZ' waitAndDo 一样实现。
  • 干净的代码。完全是我的事:) 但真的。你的第二个例子很适合我。尽管它很“无聊”,但每个人都会理解它的作用,并且没有什么可隐瞒的。没有严格回答我的问题,但您第三个确实以某种方式回答了我的问题。我喜欢你清晰的风格。因此,如果您对该主题有更多想法,请继续提出;)
【解决方案2】:

对您的想法进行细微修改以使其更好地发挥作用:

const sleep = ms =>
    new Promise(resolve => setTimeout(resolve, ms));

async function waitAndDo(promise) {
  let resolved = false;
  const waitFor = promise
    .then((result) => resolved = true);
    
  while(!resolved) {
    doSomething();
    await Promise.race([waitFor, sleep(5000)]);
  }
}
  1. 该函数接受一个 Promise 并将一直工作直到它解决。
  2. waitFor 承诺将在promise 完成并且resolved 更新为true 后完成。
  3. 然后while 循环可以循环,直到resolved 变量设置为true。在这种情况下,循环将结束执行,然后继续执行。
  4. 在循环内部,Promise.race() 将确保在承诺解决或睡眠到期后立即停止等待。以先到者为准。

因此,一旦承诺得到解决,.then() 处理程序首先触发并更新resolved。 await Promise.race(); 将结束等待,while 循环不会再次执行,因为 resolved 现在是 true。

【讨论】:

  • 嗨 Vlaz。非常感谢您的努力。你写的东西会起作用,但它与我展示的我不喜欢使用的代码非常相似。我正在寻找某种方法来分离睡眠和聆听某些用户交互的任务。不是因为它不起作用,而是因为语义/美学/清晰的原因。
【解决方案3】:

似乎你只是使用某种间隔并在承诺完成时将其杀死。

const updateMessage = (fnc, ms, runInit) => {
  if (runInit) fnc();
  const timer = window.setInterval(fnc, ms);
  return function () {
    console.log('killed');
    timer && window.clearTimeout(timer);
  }
}

const updateTime = () => {
  document.getElementById("out").textContent = Date.now();
}

const updateEnd = updateMessage(updateTime, 100, true);

new Promise((resolve) => {
  window.setTimeout(resolve, Math.floor(Math.random()*5000));
}).then(updateEnd);
<div id="out"></div>

【讨论】:

  • 嗨@espascarello:非常感谢您的回答。这一个花了我最长的时间来咀嚼:) 我认为它基本上与 Bergi 的第二个相同。我喜欢在间隔开始时返回停止函数的方法。我肯定会把一些东西放在我的工具包里。
【解决方案4】:

作为 VLAZ 非常合理的 answer 的替代方案,您可以通过让 sleep 函数返回某种指示超时的唯一标记返回值来避免单独的布尔标记。 Symbol 正是这种用例的轻量级、独特对象。

function sleepPromise(ms, resolveWith) {
  return new Promise(resolve => {
    setTimeout(resolve, ms, resolveWith);
  });
}

const inputPromise = new Promise(
    resolve => document.getElementById("wakeUp").addEventListener("click", resolve));

async function yourFunction() {
  const keepSleeping = Symbol("keep sleeping");
  do {
    /* loop starts here */
    console.log("Sleeping...");
    /* loop ends here */
  } while (await Promise.race([inputPromise, sleepPromise(3000, keepSleeping)]) === keepSleeping);
  console.log("Awake!");
}

yourFunction();
<button id="wakeUp">Wake up</button>

【讨论】:

  • 嗨,杰夫。非常感谢您的回答。我花了一些时间来完全理解发生了什么(以及什么是符号......以前从未使用过......但两天前需要它来做另一件事:) 现在我学到了很多新东西。跨度>
猜你喜欢
  • 1970-01-01
  • 1970-01-01
  • 2021-03-11
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2021-08-12
  • 1970-01-01
相关资源
最近更新 更多