Question

我有一个嵌套的承诺。承诺根据另一个使用setTimeout为0解析或拒绝的承诺来解决或拒绝，以免堵塞：

  return new Promise((resolve, reject) => {
    promiseInst
    .then(value => {
      executeSoon(() => {
        dispatch({ ...action, status: "done", value: value });
        resolve(value);
      });
    })
    .catch(error => {
      executeSoon(() => {
        dispatch({
          ...action,
          status: "error",
          error: error.message || error
        });
        reject(error);
      });
    });
});

executeSoon()为executeSoon(fn) { setTimeout(fn, 0); }

如何简化此操作？试图摆脱外部的承诺包装并直接返回内部承诺，但坚持决心并拒绝不被定义。所以我想我只是从.then和Promise.resolve(value)内部返回一个Promise.reject(error)，但这也不起作用。我觉得有可能简化这个，但不能完全理解它。

Answer 1

只需使用有前途的计时器：

  const timer = ms => new Promise(res => setTimeout(res, ms));

然后就这么简单：

  timer(0).then(() => promiseInst)
   .then(...)
   .catch(...)

....但实际上你不需要计时器，因为保证在调用resolve()后解决一个勾号。

Answer 2

请记住，then处理程序总是异步执行，在正常情况下不需要setTimeout(..., 0)。因此，如果setTimeout没有其他目的：

return promiseInst
    .then(value => {
        dispatch({ ...action, status: "done", value: value });
        return value;
    })
    .catch(error => {
        dispatch({ ...action, status: "error", error: error.message || error });
        throw error;
    });

如果它做了重要的事情，我可能会有一个启用许可的版本，就像这样：

const setTimeoutPromise = (delay = 0) => new Promise(resolve => {
    setTimeout(resolve, delay);
});

然后看下面有***的行：

return promiseInst
    .then(value => setTimeoutPromise().then(() => value) // ***
    .then(value => {
        dispatch({ ...action, status: "done", value: value });
        return value;
    })
    .catch(error => setTimeoutPromise().then(() => {     // ***
        dispatch({ ...action, status: "error", error: error.message || error });
        throw error;
    })); // <== *** Note one more )

嵌套Promise与setTimeout

2 个答案: