从后台进程中止异步函数

Question

我有一个异步函数，我想从中止正在后台运行的进程。 中止不需要取消异步函数内部当前未决的任何承诺。 它只需要使函数返回并防止任何进一步的行被执行。 我怎么能这样做？ 当前代码不起作用，因为错误是在 setInterval 而不是 try 块中引发的。

setInterval(() => { //background proccess
  abort();
}, 5000); 

async function func() {
  try {
    abort = function thr() {
      throw new Error("dsaf");
    };
    await new Promise((r) => setTimeout(r, 10000));
    await new Promise((r) => setTimeout(r, 10000));
    await new Promise((r) => setTimeout(r, 10000));
    await new Promise((r) => setTimeout(r, 10000));
    await new Promise((r) => setTimeout(r, 10000));
    await new Promise((r) => setTimeout(r, 10000));
    await new Promise((r) => setTimeout(r, 10000));
  } catch {
    console.log("caught");
  }  
}   

func()

更新：是否有其他语言更好地支持这种类型的模式，或者所有语言都这样？

Answer 1

你可能正在寻找

let throwIfAborted = () => {};

setInterval(() => { //background proccess
  throwIfAborted = () => { throw new Error("Abort"); };
}, 5000);

async function func() {
  try {
    throwIfAborted();
    await new Promise((r) => setTimeout(r, 10000));
    throwIfAborted();
    await new Promise((r) => setTimeout(r, 10000));
    throwIfAborted();
    await new Promise((r) => setTimeout(r, 10000));
    throwIfAborted();
    await new Promise((r) => setTimeout(r, 10000));
    throwIfAborted();
    await new Promise((r) => setTimeout(r, 10000));
    throwIfAborted();
    await new Promise((r) => setTimeout(r, 10000));
    throwIfAborted();
    await new Promise((r) => setTimeout(r, 10000));
    throwIfAborted();
  } catch {
    console.log("caught");
  }  
}   

func()

Answer 2

使用CPromise 包，可以按如下方式完成（Live sandbox）：

import { CPromise } from "c-promise2";

const func = CPromise.promisify(function* () {
  try {
    yield new Promise((r) => setTimeout(r, 10000));
    yield new Promise((r) => setTimeout(r, 10000));
    yield new Promise((r) => setTimeout(r, 10000));
    yield new Promise((r) => setTimeout(r, 10000));
    yield new Promise((r) => setTimeout(r, 10000));
    yield new Promise((r) => setTimeout(r, 10000));
    yield new Promise((r) => setTimeout(r, 10000));
  } catch (err) {
    console.log(`caught: ${err}`);
  }
});

const promise = func();

setInterval(() => {
  promise.cancel();
}, 5000);

Answer 3

为了让生活更轻松，您可以创建一个辅助函数。

下面我创建了一个简单的可中止函数，您只需将异步代码放入run，然后在准备好时调用abort。

例如。

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

function abortable() {
  let aborted = false;
  return {
    abort: () => aborted = true,
    run: async cb => {
      if (aborted) throw new Error('Aborted');
      return await cb();
    }
  }
}


async function hello(caption, ms) {
  await sleep(ms);
  return `Ran ${caption}`;
}


const {abort, run} = abortable();
setTimeout(() => abort(), 2000);

async function test() {
  try {
    console.log(await run(() => hello('One', 1500)));
    console.log(await run(() => hello('Two', 1500)));
    //this next one should not run, as it's over 2000ms
    console.log(await run(() => hello('Three', 1500)));
  } catch (e) {
    console.log(e.message);
  }
}

test();

使用生成器，就像@Dmitriy 对 CPromise 的回答看起来不错，唯一的小问题是，如果下一个需要来自前一个的返回值。一个简单的解决方案是使用某种形式的状态并将其传递给每个函数。

以下是使用生成器的示例，但没有任何 3rd 方库。

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

function abortable() {
  let aborted = false;
  return {
    abort: () => aborted = true,
    run: async p => {
      for (const r of p()) {
        if (aborted) throw new Error('aborted');
        console.log(await r);
      }
    }
  }
}


async function hello(state, value, ms) {
  await sleep(ms);
  state.total += value;
  return `Total ${state.total}`;
}

const {abort, run} = abortable();
setTimeout(() => abort(), 2000);

run(function *() {
  const state = {total: 0};
  yield hello(state, 5, 1500);
  yield hello(state, 10, 1500);
  yield hello(state, 15, 1500);
}).catch(e => console.log(e.message));