相关疑难解决方法(0)

我有一个Promise数组,我正在使用Promise.all(arrayOfPromises)解析;

我接着继续承诺链.看起来像这样

existingPromiseChain = existingPromiseChain.then(function() {
  var arrayOfPromises = state.routes.map(function(route){
    return route.handler.promiseHandler();
  });
  return Promise.all(arrayOfPromises)
});

existingPromiseChain = existingPromiseChain.then(function(arrayResolved) {
  // do stuff with my array of resolved promises, eventually ending with a res.send();
});

我想添加一个catch语句来处理单个promise,以防它出错.但是当我尝试时,Promise.all返回它找到的第一个错误(忽略其余的),然后我无法从其余的数据中获取数据数组中的promise(没有错误).

我尝试过像......

existingPromiseChain = existingPromiseChain.then(function() {
      var arrayOfPromises = state.routes.map(function(route){
        return route.handler.promiseHandler()
          .then(function(data) {
             return data;
          })
          .catch(function(err) {
             return err
          });
      });
      return Promise.all(arrayOfPromises)
    });

existingPromiseChain = existingPromiseChain.then(function(arrayResolved) {
      // do stuff with my array of resolved promises, eventually ending with a res.send();
}); …

我正在使用async/ 并行await触发多个api调用:

async function foo(arr) {
  const results = await Promise.all(arr.map(v => {
     return doAsyncThing(v)
  }))
  return results
}

我知道的是,不同于loops,Promise.all 执行并行(即,等待换结果部分是并行地).

但我也知道:

如果其中一个元素被拒绝且Promise.all快速失败,则Promise.all被拒绝:如果有四个promise在超时后解析,并且一个立即拒绝,则Promise.all立即拒绝.

当我读到这个时,如果我Promise.all有5个承诺,并且第一个完成返回a reject(),那么其他4个被有效取消并且它们的承诺resolve()值将丢失.

还有第三种方式吗？执行是否有效并行,但单一故障不会破坏整个群体？

如何更改以下代码,以便触发异步操作并同时运行？

const value1 = await getValue1Async();
const value2 = await getValue2Async();
// use both values

我需要做这样的事情吗？

const p1 = getValue1Async();
const p2 = getValue2Async();
const value1 = await p1;
const value2 = await p2;
// use both values

在我的应用程序中,我会调用fetchData函数来验证用户身份.如果用户令牌变为无效,应用程序将运行axios.all(),我的拦截器将返回大量错误.

axios.all()第一次出错后如何防止继续运行？并只向用户显示一个通知？

interceptors.js

export default (http, store, router) => {
    http.interceptors.response.use(response => response, (error) => {
        const {response} = error;

        let message = 'Ops. Algo de errado aconteceu...';

        if([401].indexOf(response.status) > -1){
            localforage.removeItem('token');

            router.push({
                name: 'login'
            });

            Vue.notify({
                group: 'panel',
                type: 'error',
                duration: 5000,
                text: response.data.message ? response.data.message : message
            });
        }

        return Promise.reject(error);
    })
}

auth.js

const actions = {
    fetchData({commit, dispatch}) {
        function getChannels() {
            return http.get('channels')
        }

        function getContacts() {
            return http.get('conversations')
        }

        function getEventActions() …

我想知道如何一次获取多个GET URL,然后将获取的JSON数据放入我的React DOM元素中.

这是我的代码:

fetch("http://localhost:3000/items/get")
.then(function(response){
        response.json().then(
            function(data){
                ReactDOM.render(
                    <Test items={data}/>,
                    document.getElementById('overview')
                );}
        );
    })
.catch(function(err){console.log(err);});

但是,我想从我的服务器获取额外的JSON数据,然后渲染我的ReactDOM,并将所有这些JSON数据传递给它.例如:

ReactDOM.render(
   <Test items={data} contactlist={data2} itemgroup={data3}/>,
   document.getElementById('overview')
);

这可能吗？如果没有,那么将多个JSON数据提取到渲染ReactDOM元素的其他解决方案是什么？

我误解了Promise.all吗？我在数组中有X个promise,我正在尝试聚合数组的成功/失败率.

以下是我认为我所知道的:

Promise.all采取了一系列承诺.

如果所有承诺都成功,则.then运行回调.

如果其中一个promise失败,则.catch调用回调,传入的参数是单个引发的错误的值.

如果有些成功并且有些失败,则没有回复触发,这是所有承诺的结果.即它不能给你一个类似(伪代码)的数组[success, fail, success, success]- 就像人们所期望的那样,可以在许多JS库中找到它们(ajax,ember等).

它就.then像是一个更像是.success一个函数,而不是一个在所有承诺完成后总是运行的函数,无论一些成功还是一些失败.为什么没有.when .finally .runThisShizNoMatterWhat？或者我错过了什么(非常可能)？

假设我有一个Promise.all()处理两个承诺.如果一个承诺产生错误,但另一个承诺解决,我希望能够在Promise.all()结算后根据情况处理错误.

ES6承诺缺少结算方法,我假设有充分的理由.但我不禁想到这个.settle()方法会让我这个问题变得容易多了.

我是以错误的方式解决这个问题,还是通过一种解决方法扩展ES6 Promise,这是正确的做法？

我正在考虑如何使用的一个例子.settle():

Promise.all([Action1,Action2])
.settle(function(arrayOfSettledValues) 
    //if 1 failed but not 2, handle
    //if 2 failed but not 1, handle
    //etc....
)

据我所知,Promise.all()并行执行所有操作,并在任何一个Promises中的第一个错误实例中返回错误.

现在如果我想并行运行所有承诺并等待它们完成即使其中一个失败了怎么办？

是否有我应该使用的Promise方法或模块？

我并行发送一堆用户FCM推送通知,如果其中任何一个失败,则无法通过.then()排队.

我在我的代码中这样做

//then chain

    .then(()=>{
            let startChatPromises = [];
            for (let i = 0 ; i < queue_length ; i ++){
                startChatPromises.push(matchUsers(some_key,some_key));
            }
            return Promise.all(startChatPromises);
        }).then(()=>{// Continue processing even after failure ?});


let matchUsers = (room_id,...user_ids) => {

    let chat_key = admin.database().ref().child("chats").child(room_id).push().key;

    let participants = {};

    user_ids.forEach(user_id=> {
        participants[`${user_id}`] = true;
    });

    return admin.database().ref().child("chats").child(room_id).child(chat_key).update({
        "last_message_ts" : new Date().getTime(),
        "participants" : participants
    }).then(()=>{
        //Get Users
        let getFCMTokenPromises = [];
        user_ids.forEach(user_id => {
            getFCMTokenPromises.push(admin.database().ref("users").child(user_id).child("fcm_id").once('value'));
        });
        return Promise.all(getFCMTokenPromises);
    }).then(results => …

据MDN称:

如果任何传入的承诺拒绝,则所有承诺立即拒绝拒绝的承诺的价值,放弃所有其他承诺,无论他们是否已经解决.

该ES6规格似乎证实了这一点.

我的问题是:如果他们中的任何人拒绝,为什么Promise.all放弃承诺,因为我希望它等待"所有"承诺解决,"丢弃"究竟是什么意思？(很难说"丢弃"对于飞行中的承诺与可能尚未运行的承诺意味着什么.)

我问,因为我经常遇到一些情况,我有一份承诺清单,并希望等待他们全部解决,并得到可能已经发生的所有拒绝,这Promise.all是不满足的.相反,我必须使用这样的黑客:

const promises = []; // Array of promises
const settle = promise => promise.then(result => ({ result }), reason => ({ reason }));
Promise.all(promises.map(settle))
  .then(/ * check "reason" property in each element for rejection */);

我目前正在等待所有承诺按顺序完成:

(async() => {
  let profile = await profileHelper.getUserData(username);
   let token = await tokenHelper.getUserToken(username);
   console.log(profile);
   console.log(token);
   return {profile: profile, token: token};
})();

但是这样,配置文件和令牌按顺序执行.由于两者彼此独立,我希望它们两者一起独立执行.我认为这可以使用Promise.all完成,但我不确定语法,我也找不到任何帮助.

所以我的问题是如何将上面的api调用转换为一起运行然后返回最终输出.