Javascript：在没有库的情况下以串行(或序列)运行异步任务

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Javascript：在没有库的情况下以串行(或序列)运行异步任务，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含3675字，纯文字阅读大概需要6分钟。

内容图文

我想在循环中运行一些异步任务,但它应该按顺序执行(一个接一个).它应该是vanilla JS,而不是任何库.

var doSome = function(i) {
   return Promise.resolve(setTimeout(() => {
      console.log('done... ' + i)
   }, 1000 * (i%3)));
}

var looper = function() {
   var p = Promise.resolve();

   [1,2,3].forEach((n) => {
      p = p.then(() => doSome(n))
   })

   return p;
}

looper();

当前输出：

calling for ...1
calling for ...2
calling for ...3
Promise?{<resolved>: 8260}
done... 3
done... 1
done... 2

预期产量：

calling for ...1
calling for ...2
calling for ...3
Promise?{<resolved>: 8260}
done... 1
done... 2
done... 3

注意：请回答,如果您尝试过并且按预期工作

解决方法:

因此,从下面的评论中,我认为您自己的示例代码与您的描述不完全匹配.我认为你想要的例子更接近下面的片段：

var doSome = function(i) {
  return new Promise((resolve, reject) => {
    setTimeout(() => resolve(`Completing ${i}`), 1000*(i%3))
  });
}

var looper = function() {
  [1,2,3].forEach((n) => {
    doSome(n).then(console.log);
  });
}

looper();

这里,迭代数组[1,2,3],并为每一个生成异步过程.当每个异步进程完成时,我们会在它们和控制台上记录它们的解析结果.

那么,现在问题是如何最好地排队结果？下面,我将它们存储到一个数组中,然后利用async/await暂停执行结果,直到它们按顺序完成.

// This is probably what you want
var doSome = function(i) {
  return new Promise((resolve, reject) => {
    setTimeout(() => resolve(`Completing ${i}`), 1000*(i%3))
  });
}

var looper = async function() {
  const nums = [1,2,3];
  const promises = []
  nums.forEach((n) => {
    console.log(`Queueing ${n}`);
    promises.push(doSome(n));
  });
  for (let promise of promises) {
    const result = await promise;
    console.log(result);
  }
}

looper();

现在,我们可以消除一个循环,只在最后一次完成后执行一个循环：

// Don't use this-- it is less efficient
var doSome = function(i) {
  return new Promise((resolve, reject) => {
    setTimeout(() => resolve(`Completing ${i}`), 1000*(i%3))
  });
}

var looper = async function() {
  const nums = [1,2,3];
  const promises = [];
  for (let n of nums) {
    console.log(`Queueing ${n}`);
    const result = await doSome(n);
    console.log(result);
  };
}

looper();

但是,正如您在日志中看到的那样,此方法将不会排队下一个异步进程,直到上一个异步进程完成为止.这是不可取的,与您的用例不符.我们从这个前面的双循环方法得到的是所有异步进程都立即执行,但随后我们对结果进行排序/排队,以便它们遵守我们预定义的顺序,而不是它们解决的顺序.

UPDATE

关于Promise.all,async / await和排队的预期行为：

所以,如果你想避免使用async / await,我想你可以写一些实用程序：

var doSome = function(i) {
  return new Promise((resolve, reject) => {
    setTimeout(() => resolve(`Completing ${i}`), 1000*(i%3))
  });
}

function handlePromiseQueue(queue) {
  let promise = queue.shift();
  promise.then((data) => {
    console.log(data)
    if (queue.length > 0) {
      handlePromiseQueue(queue);
    }
  })
}

var looper = function() {
  const nums = [1,2,3];
  const promises = []
  nums.forEach((n) => {
    console.log(`Queueing ${n}`);
    promises.push(doSome(n));
  });
  handlePromiseQueue(promises);
}

looper();

但是,让我说清楚 – 如果用户Bergi的断言是正确的,并且每个异步承诺一旦结算就被执行并不重要,只有在它们全部回来之前它们都没有被执行,那么这个使用Promise.all可以100％简化：

// This is probably what you want
var doSome = function(i) {
  return new Promise((resolve, reject) => {
    setTimeout(() => resolve(`Completing ${i}`), 1000*(i%3))
  });
}

function handlePromiseQueue(queue) {
  let promise = queue.shift();
  promise.then((data) => {
    console.log(data)
    if (queue.length > 0) {
      handlePromiseQueue(queue);
    }
  })
}

var looper = function() {
  const nums = [1,2,3];
  const promises = []
  nums.forEach((n) => {
    console.log(`Queueing ${n}`);
    promises.push(doSome(n));
  });
  Promise.all(promises).then(() => handlePromiseQueue(promises));
}

looper();

最后,正如Bergi所指出的那样,我在这里玩得很快,没有在这些不同的承诺上设置任何catch–我在实例中省略了它们,但为了你的目的,你会想要包含正确的错误处理或错误处理要求.

内容总结

以上是互联网集市为您收集整理的Javascript：在没有库的情况下以串行(或序列)运行异步任务全部内容，希望文章能够帮你解决Javascript：在没有库的情况下以串行(或序列)运行异步任务所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端