解决承诺一个接一个(即顺序)?

考虑下面以串行/顺序方式读取文件数组的代码。readFiles返回一个承诺，只有在顺序读取所有文件后才会解析这个承诺。

var readFile = function(file) {
  ... // Returns a promise.
};

var readFiles = function(files) {
  return new Promise((resolve, reject) => {
    var readSequential = function(index) {
      if (index >= files.length) {
        resolve();
      } else {
        readFile(files[index]).then(function() {
          readSequential(index + 1);
        }).catch(reject);
      }
    };

    readSequential(0); // Start with the first file!
  });
};

上面的代码可以工作，但是我不喜欢为了使事情按顺序发生而进行递归。是否有一种更简单的方法可以重写这段代码，这样我就不必使用奇怪的readSequential函数了?

最初我尝试使用Promise。但是这会导致所有的readFile调用并发发生，这不是我想要的:

var readFiles = function(files) {
  return Promise.all(files.map(function(file) {
    return readFile(file);
  }));
};

当前回答

这里有很多答案，但我没有看到这个简单的解决方案:

await array.reduce(
  async (promise, member) => await myLongSequentialPromise(member),
  array[0]
)

证明:https://jsbin.com/nulafus/1/edit?js,控制台

2019-02-27 23:29:54

其他回答

(function() {
  function sleep(ms) {
    return new Promise(function(resolve) {
      setTimeout(function() {
        return resolve();
      }, ms);
    });
  }

  function serial(arr, index, results) {
    if (index == arr.length) {
      return Promise.resolve(results);
    }
    return new Promise(function(resolve, reject) {
      if (!index) {
        index = 0;
        results = [];
      }
      return arr[index]()
        .then(function(d) {
          return resolve(d);
        })
        .catch(function(err) {
          return reject(err);
        });
    })
      .then(function(result) {
        console.log("here");
        results.push(result);
        return serial(arr, index + 1, results);
      })
      .catch(function(err) {
        throw err;
      });
  }

  const a = [5000, 5000, 5000];

  serial(a.map(x => () => sleep(x)));
})();

这里的关键是如何调用sleep函数。你需要传递一个函数数组，它本身返回一个promise，而不是一个promise数组。

2020-02-26 17:04:12

我能想到的最好的解决办法就是蓝鸟承诺。你可以执行Promise.resolve(files).each(fs.readFileAsync);这保证了承诺是按顺序被解决的。

2015-05-06 07:32:01

我在Promise对象上创建了这个简单的方法:

创建并添加承诺。sequence方法添加到Promise对象

Promise.sequence = function (chain) {
    var results = [];
    var entries = chain;
    if (entries.entries) entries = entries.entries();
    return new Promise(function (yes, no) {
        var next = function () {
            var entry = entries.next();
            if(entry.done) yes(results);
            else {
                results.push(entry.value[1]().then(next, function() { no(results); } ));
            }
        };
        next();
    });
};

用法:

var todo = [];

todo.push(firstPromise);
if (someCriterium) todo.push(optionalPromise);
todo.push(lastPromise);

// Invoking them
Promise.sequence(todo)
    .then(function(results) {}, function(results) {});

Promise对象的这个扩展最好的一点是，它与Promise的风格一致。的承诺。一切和承诺。序列以同样的方式调用，但具有不同的语义。

谨慎

连续运行承诺通常不是使用承诺的好方法。通常使用Promise会更好。所有这些，并让浏览器尽可能快地运行代码。然而，它也有一些实际的用例——例如在使用javascript编写移动应用程序时。

2015-07-29 12:32:33

我想重复很多人说过的，解决这个问题的最好方法是使用async/await函数。我想重申这个解决方案，但是，也指出另一个解决方案，其中async/await不存在:

函数readFile(文件){ 返回新的Promise(函数(解析，拒绝){ console.log('模拟读取文件${file} '); setTimeout(决心,1000); }); ｝ (async函数(){ Let files = ["file1.txt"， "file2.txt"， "file3.txt"]; For (let file of files) 等待readFile(文件); }) ();

对于不支持async/await的JavaScript环境，我们可以选择使用https://babeljs.io来编译上面的内容，但要使用babel-plugin-transform-async-to-generator之类的插件。下面是使用插件的v6.24.1生成的:

如果你研究一下_asyncToGenerator()中发生了什么，你会发现它正在使用递归使用Promise链。您可以通过函数生成器提供Promise，因此，您可以专注于业务逻辑。

2022-08-30 06:11:23

下面是我的Angular/TypeScript方法，使用RxJS:

给定一个URL字符串数组，使用from函数将其转换为一个可观察对象。使用管道包装Ajax请求、即时响应逻辑、任何所需的延迟和错误处理。在管道内部，使用concatMap序列化请求。否则，使用Javascript forEach或map会同时发出请求。使用RxJS ajax进行调用，并在每次调用返回后添加所需的延迟。

工作示例:https://stackblitz.com/edit/rxjs-bnrkix?file=index.ts

代码看起来像这样(我留下了一些额外的内容，这样你可以选择保留或丢弃什么):

import { ajax } from 'rxjs/ajax';
import { catchError, concatMap, delay, from, of, map, Observable } from 'rxjs';

const urls = [
  'https://randomuser.me/api/',
  'https://randomuser.me/api/',
  'https://randomuser.me/api/',
];
const delayAfterCall = 500;

from(urls)
  .pipe(
    concatMap((url: string) => {
      return ajax.getJSON(url).pipe(
        map((response) => {
          console.log('Done! Received:', response);
          return response;
        }),
        catchError((error) => {
          console.error('Error: ', error);
          return of(error);
        }),
        delay(delayAfterCall)
      );
    })
  )
  .subscribe((response) => {
    console.log('received email:', response.results[0].email);
  });

2022-06-27 23:01:54

解决承诺一个接一个(即顺序)?

推荐文章

最新文章

标签