相关疑难解决方法(0)

假设我有一组承诺正在发出网络请求,其中一个会失败:

// http://does-not-exist will throw a TypeError
var arr = [ fetch('index.html'), fetch('http://does-not-exist') ]

Promise.all(arr)
  .then(res => console.log('success', res))
  .catch(err => console.log('error', err)) // This is executed   

让我们说我想等到所有这些都结束了,不管一个人是否失败了.对于我可以没有的资源,可能存在网络错误,但如果我可以获得,我希望在继续之前.我想优雅地处理网络故障.

既然Promise没有留下任何空间,那么在不使用promises库的情况下,处理此问题的推荐模式是什么？

这更像是一个概念性问题.我理解Promise设计模式,但找不到可靠的来源来回答我的问题promise.all():

什么是正确的使用场景 promise.all()

要么

有没有最好的做法promise.all()？理想情况下,只有当所有promise对象具有相同或相似类型时才能使用吗？

我唯一能想到的是:

• 使用promise.all(),如果你想解决的承诺只有当所有的承诺的对象决心和拒绝,如果连一个拒绝.

我正在学习javascript中的类和继承。我认为以下是扩展现有对象的相当标准的方法，因为我从Object.create的MDN文档中获得了样式

我期待看到“确定”，然后看到“是！控制台中的“ Hello”，但出现此错误：

Uncaught TypeError: #<MyPromise> is not a promise
at new MyPromise (<anonymous>:5:17)
at <anonymous>:19:6

看起来Promise构造函数正在抛出异常，因为它可以告诉我给我初始化的对象不是一个简单的Promise。

我希望Promise构造函数初始化我的对象，就像它是一个Promise对象一样，这样我就可以扩展该类。他们为什么不编写Promise构造函数来使用这种通用模式？难道我做错了什么？为您加油！

MyPromise = function(message, ok) {
    var myPromise = this;
    this.message = message;
    this.ok = ok;
    Promise.call(this, function(resolve, reject) {
        if(this.ok) {
            console.log('ok');
            resolve(myPromise.message);
        } else {
            console.log('not ok');
            reject(myPromise.message);
        }   
    }); 
};  

MyPromise.prototype = Object.create(Promise.prototype);
MyPromise.prototype.constructor = MyPromise;

(new MyPromise('Hello', true))
    .then(function(response) {console.log('Yay! ' + response);})
    .except(function(error) {console.log('Aww! ' + error);});

我最初试图制作一个可以使用的BatchAjax类，例如：

(new BatchAjax([query1, query2]))
    .then(function(response) {console.log('Fires when …

我能够成功执行Promise.all,并且优雅地处理解析和拒绝.但是,有些承诺会在几毫秒内完成,有些可能/可能需要一段时间.

我希望能够为Promise.all中的每个promise设置超时,因此它可以尝试最多花费5秒.

getData() {
    var that = this;
    var tableUrls = ['http://table-one.com','http://table-two.com'];
    var spoonUrls = ['http://spoon-one.com','http://spoon-two.com'];

    var tablePromises = that.createPromise(tableUrls);
    var spoonPromises = that.createPromise(spoonUrls);
    var responses = {};

    var getTableData = () => {
        var promise = new Promise((resolve, reject) => {
            Promise.all(tablePromises.map(that.rejectResolveHandle))
                .then((results) => {
                    responses.tables = results.filter(x => x.status === 'resolved');
                    resolve(responses);
                });
        });
        return promise;
    };

    var getSpoonData = () => {
        var promise = new Promise((resolve, reject) => {
            Promise.all(spoonPromises.map(that.rejectResolveHandle))
                .then((results) => {
                    responses.tables = results.filter(x …

鉴于以下内容

Promise.all(promises).then(resolved => {
    ...
}).catch(rejected => {
    ...
});

rejected只会包含被拒绝的第一个承诺.有没有办法捕捉所有被拒绝的承诺？

我对承诺还很陌生，我目前所做的所有道路都引导我走向Promise.all()，但我不确定如何处理结果。

我有一些这样的数据

let data = {
  "format_oid":["35474527960032","2595837960032"]
};

然后我将它传递给类似的函数

服务器.js

jobHandler.handle(data)
  .then((info) => {
    console.log(info);
  })
  .catch((err) => {
    console.error(err);
  });

在我的jobHandler班级里我有

jobHandler.js

class Handler {
  // constructor etc
  handle(data) {
    return this.extract(data);
  }

  extract(data) {
    let request = data.format_oid.map( (releaseId) => {
      return this._getReleaseId(releaseId);
     });
     return Promise.all(request);
  }

  _getReleaseId(releaseId) {
    return new Promise( (resolve, reject) => {
      if (_hasRelease(releaseId)){
        resolve('yay');
      } else {
        reject('boo');
      }
    });
}

目前request将有一系列 Promise，例如[ Promise { <pending> …

例如:

function myFunc(args ...){
  ...
  return Promise.all(myPromisesArray)
}

如果内部的承诺myPromisesArray失败,我将只在返回值中得到拒绝原因.

有没有办法恢复所有其他已解决的值？

我正在尝试运行一个for循环，该循环将一堆异步请求排队。一旦所有的请求完整，独立的是否resolve还是reject，我希望再运行一些代码。我试图利用异步/等待模式，因为它看起来更好。:)

这就是我在做什么：

var promises = []
for ( item in list ) {
    prom = AsyncFunction( item )
    promises.push(prom)
}

await Promise.all(promises)

doMoreAfter()

但是，某些承诺失败了，而第二个承诺也失败了Promise.all()。

我只想忽略所有失败的承诺，并在所有承诺完成后运行下一个代码。

我发现像解决此。

Promise.all([a(), b(), c()].map(p => p.catch(e => e)))
  .then(results => console.log(results)) // 1,Error: 2,3
  .catch(e => console.log(e));

但是，当尝试将其转换为异步/等待格式时，它似乎并不起作用。

await Promise.all(promises.map(p => p.catch(e => e)))

我想念什么？