Promise.all dosyasındaki hataları işleme

Çözdüğüm bir dizi Sözüm var Promise.all(arrayOfPromises);

Söz zincirine devam etmeye devam ediyorum. Böyle bir şey görünüyor

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();
});

Hata durumunda bireysel bir söz işlemek için bir catch deyimi eklemek istiyorum, ama denediğimde, Promise.allbulduğu ilk hatayı döndürür (geri kalanını göz ardı eder) ve sonra vaatlerin geri kalanından veri alamıyorum dizi (bu hata vermedi).

Gibi bir şey yapmayı denedim ..

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();
});

Ancak bu çözülmez.

Teşekkürler!

-

Düzenle:

Aşağıdaki cevapların söyledikleri tamamen doğruydu, kod başka nedenlerden dolayı kırılıyordu. Kimsenin ilgilenmesi durumunda, bu benim çözüm buldum ...

Node Express Sunucu Zinciri

serverSidePromiseChain
    .then(function(AppRouter) {
        var arrayOfPromises = state.routes.map(function(route) {
            return route.async();
        });
        Promise.all(arrayOfPromises)
            .catch(function(err) {
                // log that I have an error, return the entire array;
                console.log('A promise failed to resolve', err);
                return arrayOfPromises;
            })
            .then(function(arrayOfPromises) {
                // full array of resolved promises;
            })
    };

API Çağrısı (route.async çağrısı)

return async()
    .then(function(result) {
        // dispatch a success
        return result;
    })
    .catch(function(err) {
        // dispatch a failure and throw error
        throw err;
    });

Koymak .catchiçin Promise.allönce .thenorijinal vaatlerinden hataları yakalamak, ama sonra bir sonraki için tüm diziyi dönen amacına hizmet etmiş görünüyor.then

Teşekkürler!

Promise.allya hep ya hiç. Dizideki tüm vaatler çözüldüğünde çözülür veya bunlardan biri reddedilir reddedilmez . Başka bir deyişle, tüm çözümlenmiş değerlerin bir dizisiyle çözümlenir veya tek bir hatayla reddedilir.

Bazı kütüphanelerin bir şeyleri var Promise.when, bunun yerine herkesin bekleyeceğini anladım dizideki vaatlerin çözülmesini veya reddedilmesini anladım, ancak buna aşina değilim ve ES6'da değil.

Senin kodun

Burada düzeltmenizin işe yarayacağı konusunda başkalarına katılıyorum. Başarılı değerler ve hata nesnelerinin bir karışımını içerebilecek bir dizi ile çözülmelidir. Başarı yolunda hata nesneleri geçmek alışılmadık ama kod onları bekliyor varsayalım, ben hiçbir sorun görmüyorum.

Neden "çözmeyeceğini" düşünebilmemizin tek nedeni, bize göstermediğiniz kodda başarısız olması ve bu konuda herhangi bir hata mesajı görmemenizin nedeni, bu söz zincirinin bir final ile sonlandırılmamış olmasıdır. (zaten bize gösterdiğiniz kadarıyla).

Örneğinizden "mevcut zinciri" çarpanlara ayırma ve zinciri bir yakalama ile sonlandırma özgürlüğünü aldım. Bu sizin için doğru olmayabilir, ancak bunu okuyan insanlar için zincirleri her zaman iade etmek veya sonlandırmak önemlidir veya potansiyel hatalar, hatta kodlama hataları bile gizlenir (burada olduğundan şüphelendiğim şey budur):

Promise.all(state.routes.map(function(route) {
  return route.handler.promiseHandler().catch(function(err) {
    return err;
  });
}))
.then(function(arrayOfValuesOrErrors) {
  // handling of my array containing values and/or errors. 
})
.catch(function(err) {
  console.log(err.message); // some coding error in handling happened
});

YENİ CEVAP

const results = await Promise.all(promises.map(p => p.catch(e => e)));
const validResults = results.filter(result => !(result instanceof Error));

GELECEK Promise API'sı

• Chrome 76: https://developer.mozilla.org/tr-TR/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled
• İndirebilirsin Hemen edinmek için https://www.npmjs.com/package/promise.allsettled . Belirli tarayıcılarda allSettled, tarayıcının kendisiyle önceden yüklenmiş olarak gelir. Gönül rahatlığı için paketi indirmeye değer çünkü örn. TypeScript, allSettled için varsayılan tanımlara sahip değildir.

Döngüye devam etmek için Promise.all(bir Promise reddedildiğinde bile) çağrılan bir yardımcı program yazdım executeAllPromises. Bu yardımcı program işlevi resultsve ile bir nesne döndürür errors.

Fikir, geçtiğiniz tüm Sözlerin executeAllPromisesher zaman çözülecek yeni bir Söz'e sarılmasıdır. Yeni Promise 2 noktadan oluşan bir dizi ile çözülüyor. İlk nokta çözme değerini (varsa) tutar ve ikinci nokta hatayı (sarılmış Promise reddederse) tutar.

Son adım executeAllPromisesolarak, kaydırılanın tüm değerlerini toplar ve son nesneyi için bir dizi resultsve için bir dizi ile döndürür errors.

İşte kod:

function executeAllPromises(promises) {
  // Wrap all Promises in a Promise that will always "resolve"
  var resolvingPromises = promises.map(function(promise) {
    return new Promise(function(resolve) {
      var payload = new Array(2);
      promise.then(function(result) {
          payload[0] = result;
        })
        .catch(function(error) {
          payload[1] = error;
        })
        .then(function() {
          /* 
           * The wrapped Promise returns an array:
           * The first position in the array holds the result (if any)
           * The second position in the array holds the error (if any)
           */
          resolve(payload);
        });
    });
  });

  var errors = [];
  var results = [];

  // Execute all wrapped Promises
  return Promise.all(resolvingPromises)
    .then(function(items) {
      items.forEach(function(payload) {
        if (payload[1]) {
          errors.push(payload[1]);
        } else {
          results.push(payload[0]);
        }
      });

      return {
        errors: errors,
        results: results
      };
    });
}

var myPromises = [
  Promise.resolve(1),
  Promise.resolve(2),
  Promise.reject(new Error('3')),
  Promise.resolve(4),
  Promise.reject(new Error('5'))
];

executeAllPromises(myPromises).then(function(items) {
  // Result
  var errors = items.errors.map(function(error) {
    return error.message
  }).join(',');
  var results = items.results.join(',');
  
  console.log(`Executed all ${myPromises.length} Promises:`);
  console.log(`— ${items.results.length} Promises were successful: ${results}`);
  console.log(`— ${items.errors.length} Promises failed: ${errors}`);
});

ES2020 , Promise türü için yeni bir yöntem sunar : Promise.allSettled()
Promise.allSettled, tüm giriş vaatleri yerine getirildiğinde size bir sinyal verir, yani ya yerine getirilir ya da reddedilir. Bu, sözün durumunu umursamadığınız durumlarda, başarılı olup olmadığına bakılmaksızın, işin ne zaman yapıldığını bilmek istediğinizde yararlıdır.

const promises = [
  fetch('/api-call-1'),
  fetch('/api-call-2'),
  fetch('/api-call-3'),
];
// Imagine some of these requests fail, and some succeed.

const result = await Promise.allSettled(promises);
console.log(result.map(x=>s.status));
// ['fulfilled', 'fulfilled', 'rejected']

Daha fazla bilgi için v8 blog yazısında https://v8.dev/features/promise-combinators

@ Jib'in dediği gibi,

Promise.all ya hep ya hiç.

Yine de, başarısız olmasına izin verilen belirli sözleri kontrol edebilirsiniz ve devam etmek istiyoruz .then.

Örneğin.

  Promise.all([
    doMustAsyncTask1,
    doMustAsyncTask2,
    doOptionalAsyncTask
    .catch(err => {
      if( /* err non-critical */) {
        return
      }
      // if critical then fail
      throw err
    })
  ])
  .then(([ mustRes1, mustRes2, optionalRes ]) => {
    // proceed to work with results
  })

q kütüphanesini kullanmaya başlarsanız https://github.com/kriskowal/q bu sorunu çözebilecek q.allSettled () yöntemine sahiptir.

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

existingPromiseChain = existingPromiseChain.then(function(arrayResolved) {
//so here you have all your promises the fulfilled and the rejected ones
// you can check the state of each promise
arrayResolved.forEach(function(item){
   if(item.state === 'fulfilled'){ // 'rejected' for rejected promises
     //do somthing
   } else {
     // do something else
   }
})
// do stuff with my array of resolved promises, eventually ending with a res.send();
});

Async'i kullanma bekliyor -

burada bir eşzamansız işlev func1 çözümlenmiş bir değer döndürüyor ve func2 bir hata atıyor ve bu durumda null döndürüyor, bunu nasıl istediğimizi işleyebilir ve buna göre geri dönebiliriz.

const callingFunction  = async () => {
    const manyPromises = await Promise.all([func1(), func2()]);
    console.log(manyPromises);
}


const func1 = async () => {
    return 'func1'
}

const func2 = async () => {
    try {
        let x;
        if (!x) throw "x value not present"
    } catch(err) {
       return null
    }
}

callingFunction();

Çıktı - ['func1', boş]

Burada rastlanan ES8'i kullananlar için, zaman uyumsuz işlevleri kullanarak aşağıdakine benzer bir şey yapabilirsiniz :

var arrayOfPromises = state.routes.map(async function(route){
  try {
    return await route.handler.promiseHandler();
  } catch(e) {
    // Do something to handle the error.
    // Errored promises will return whatever you return here (undefined if you don't return anything).
  }
});

var resolvedPromises = await Promise.all(arrayOfPromises);

Reddetmeyi bireysel vaatler düzeyinde halledebiliriz, bu nedenle sonuç dizimizde sonuçları aldığımızda reddedilen dizi dizini olur undefined. Bu durumu gerektiği gibi halledebilir ve kalan sonuçları kullanabiliriz.

Burada ilk sözü reddettim, bu yüzden tanımsız olarak geliyor, ancak dizin 1'deki ikinci vaatın sonucunu kullanabiliriz.

const manyPromises = Promise.all([func1(), func2()]).then(result => {
    console.log(result[0]);  // undefined
    console.log(result[1]);  // func2
});

function func1() {
    return new Promise( (res, rej) => rej('func1')).catch(err => {
        console.log('error handled', err);
    });
}

function func2() {
    return new Promise( (res, rej) => setTimeout(() => res('func2'), 500) );
}

Düşündün mü Promise.prototype.finally()?

Tam olarak ne istediğinizi yapacak şekilde tasarlanmış gibi görünüyor - bazı vaatler yerine getirildikten (çözüldükten / reddedildikten sonra), bazı vaatlerin reddedilmesine bakılmaksızın bir işlevi yerine getirmek.

Gönderen MDN belgelerinde :

finally()Eğer olursa olsun sonucu, söz yerleşmiş bir kez bazı işlenmesini veya temizlik yapmak istiyorsanız yöntem yararlı olabilir.

finally()Yöntem çağırarak çok benzer .then(onFinally, onFinally)ancak farklılıkların birkaç nokta vardır:

Satır içi bir işlev oluştururken, işlevi iki kez bildirmek veya işlev için bir değişken oluşturmak yerine bir kez geçirebilirsiniz.

Sonunda geri arama herhangi bir argüman almayacaktır, çünkü sözün yerine getirilip getirilmediğini belirlemenin güvenilir bir yolu yoktur. Bu kullanım durumu, reddedilme nedenini veya yerine getirme değerini umursamadığınız zaman içindir ve bu nedenle bunu sağlamaya gerek yoktur.

Bunun aksine Promise.resolve(2).then(() => {}, () => {})(undefined ile çözülecek), Promise.resolve(2).finally(() => {})2 ile çözülecektir. Benzer şekilde, Promise.reject(3).then(() => {}, () => {})(undefined ile yerine getirilecek) aksine Promise.reject(3).finally(() => {}), 3 ile reddedilecektir.

== Yedek ==

JavaScript sürümünüz desteklemiyorsa Jake Archibald'ınPromise.prototype.finally() bu geçici çözümünü kullanabilirsiniz :Promise.all(promises.map(p => p.catch(() => undefined)));

Alternatif olarak, bir başarısızlık olduğunda çözülmüş vaatlerin değerlerini özellikle önemsemediğiniz bir durumunuz varsa, ancak yine de çalışmasını istiyorsanız, böyle bir şeyi normalde olduğu gibi çözecek bir şey yapabilirsiniz. hepsi başarısız olur ve başarısız sözler ile reddedilir.

function promiseNoReallyAll (promises) {
  return new Promise(
    async (resolve, reject) => {
      const failedPromises = []

      const successfulPromises = await Promise.all(
        promises.map(
          promise => promise.catch(error => {
            failedPromises.push(error)
          })
        )
      )

      if (failedPromises.length) {
        reject(failedPromises)
      } else {
        resolve(successfulPromises)
      }
    }
  )
}

Vaat döndürme işlevlerinizi her zaman başarısızlık yakalayacak ve bunun yerine kabul edilen bir değer (ör. Error.message) döndürecek şekilde sarabilirsiniz, böylece istisna Promise.all işlevine kadar yuvarlanamaz ve devre dışı bırakılmaz.

async function resetCache(ip) {

    try {

        const response = await axios.get(`http://${ip}/resetcache`);
        return response;

    }catch (e) {

        return {status: 'failure', reason: 'e.message'};
    }

}

Senkronize etmeden bunu yapmanın bir yolunu (geçici çözüm) buldum.

Yani daha önce de belirtildiği gibi Promise.allhiçbiri değil.

yani ... Çözümü yakalamak ve zorlamak için bir kapalı söz kullanın.

      let safePromises = originalPrmises.map((imageObject) => {
            return new Promise((resolve) => {
              // Do something error friendly
              promise.then(_res => resolve(res)).catch(_err => resolve(err))
            })
        })
    })

    // safe
    return Promise.all(safePromises)

Sonuçlarınızdaki bir hatayı nasıl tanımlayacağınızı bilmeniz gerekir. Beklenen standart bir hatanız yoksa, catch bloğundaki her hatada, sonuçlarınızda tanımlanabilir olmasını sağlayan bir dönüşüm çalıştırmanızı öneririz.

try {
  let resArray = await Promise.all(
    state.routes.map(route => route.handler.promiseHandler().catch(e => e))
  );

  // in catch(e => e) you can transform your error to a type or object
  // that makes it easier for you to identify whats an error in resArray
  // e.g. if you expect your err objects to have e.type, you can filter
  // all errors in the array eg
  // let errResponse = resArray.filter(d => d && d.type === '<expected type>')
  // let notNullResponse = resArray.filter(d => d)

  } catch (err) {
    // code related errors
  }

Hata günlüğünün en iyi yolu değildir, ancak her zaman promiseAll için her şeyi bir diziye ayarlayabilir ve elde edilen sonuçları yeni değişkenlere depolayabilirsiniz.

GraphQL kullanırsanız, yanıtı ne olursa olsun yanıt sonrası işlemek gerekir ve doğru başvuruyu bulamazsa, uygulamanın çökmesine neden olarak sorunun bulunduğu yerde daraltılır.

const results = await Promise.all([
  this.props.client.query({
    query: GET_SPECIAL_DATES,
  }),
  this.props.client.query({
    query: GET_SPECIAL_DATE_TYPES,
  }),
  this.props.client.query({
    query: GET_ORDER_DATES,
  }),
]).catch(e=>console.log(e,"error"));
const specialDates = results[0].data.specialDates;
const specialDateTypes = results[1].data.specialDateTypes;
const orderDates = results[2].data.orders;

Bu Promise.allşekilde çalışmak üzere tasarlanmıştır. Tek bir söz varsa reject(), tüm yöntem hemen başarısız olur.

Birinin Promise.allvaatlerin başarısız olmasına izin vermek isteyebileceği kullanım durumları vardır . Bunun gerçekleşmesi reject()için vaat ettiğiniz ifadeleri kullanmayın . Ancak, herhangi bir temel sözün asla yanıt almaması durumunda uygulamanızın / komut dosyanızın donmadığından emin olmak için üzerine bir zaman aşımı koymanız gerekir.

function getThing(uid,branch){
    return new Promise(function (resolve, reject) {
        xhr.get().then(function(res) {
            if (res) {
                resolve(res);
            } 
            else {
                resolve(null);
            }
            setTimeout(function(){reject('timeout')},10000)
        }).catch(function(error) {
            resolve(null);
        });
    });
}

Bu problemle daha güzel başa çıkmak için bir npm kütüphanesi yazdım. https://github.com/wenshin/promiseallend

Yüklemek

npm i --save promiseallend

2017-02-25 yeni api, söz verme ilkelerini kırmıyor

const promiseAllEnd = require('promiseallend');

const promises = [Promise.resolve(1), Promise.reject('error'), Promise.resolve(2)];
const promisesObj = {k1: Promise.resolve(1), k2: Promise.reject('error'), k3: Promise.resolve(2)};

// input promises with array
promiseAllEnd(promises, {
    unhandledRejection(error, index) {
        // error is the original error which is 'error'.
        // index is the index of array, it's a number.
        console.log(error, index);
    }
})
    // will call, data is `[1, undefined, 2]`
    .then(data => console.log(data))
    // won't call
    .catch(error => console.log(error.detail))

// input promises with object
promiseAllEnd(promisesObj, {
    unhandledRejection(error, prop) {
        // error is the original error.
        // key is the property of object.
        console.log(error, prop);
    }
})
    // will call, data is `{k1: 1, k3: 2}`
    .then(data => console.log(data))
    // won't call
    .catch(error => console.log(error.detail))

// the same to `Promise.all`
promiseAllEnd(promises, {requireConfig: true})
    // will call, `error.detail` is 'error', `error.key` is number 1.
    .catch(error => console.log(error.detail))

// requireConfig is Array
promiseAllEnd(promises, {requireConfig: [false, true, false]})
    // won't call
    .then(data => console.log(data))
    // will call, `error.detail` is 'error', `error.key` is number 1.
    .catch(error => console.log(error.detail))

// requireConfig is Array
promiseAllEnd(promises, {requireConfig: [true, false, false]})
    // will call, data is `[1, undefined, 2]`.
    .then(data => console.log(data))
    // won't call
    .catch(error => console.log(error.detail))

--------------------------------

Eski kötü api, kullanmayın!

let promiseAllEnd = require('promiseallend');

// input promises with array
promiseAllEnd([Promise.resolve(1), Promise.reject('error'), Promise.resolve(2)])
    .then(data => console.log(data)) // [1, undefined, 2]
    .catch(error => console.log(error.errorsByKey)) // {1: 'error'}

// input promises with object
promiseAllEnd({k1: Promise.resolve(1), k2: Promise.reject('error'), k3: Promise.resolve(2)})
    .then(data => console.log(data)) // {k1: 1, k3: 2}
    .catch(error => console.log(error.errorsByKey)) // {k2: 'error'}