javascript - 如何使用 catch 和 finally with when.map

Question

我想使用when.map函数来处理一些数据。处理完数据后，我需要做一些清理(例如，将当前使用的数据库连接释放回连接池)。

我使用 catch 和 finally 的方法的问题是当第一个 reject 发生时调用 finally ，而其他映射仍在进行中。

那么我如何才能等到所有映射 promise 完成，以便可以进行保存清理。

  require('when/monitor/console');
  var when = require('when');

  function testMapper(value) {
    console.log('testMapper called with: '+value);
    return when.promise(function(resolve, reject) {
      setTimeout(function() {
        console.log('reject: '+value);
        reject(new Error('error: '+value));
      },100*value);
    });
  }

  when.map([1,2,3,4],testMapper)
  .then(function() {
    console.log('finished')
  })
  .catch(function(e) {
    console.log(e);
  })
  .finally(function() {
    console.log('finally')
  });

输出

 testMapper called with: 1
 testMapper called with: 2
 testMapper called with: 3
 testMapper called with: 4
 reject: 1
 [Error: error: 1]
 finally
 reject: 2
 [promises] Unhandled rejections: 1
 Error: error: 2
     at null._onTimeout (index.js:9:14)

 reject: 3
 [promises] Unhandled rejections: 2
 Error: error: 2
     at null._onTimeout (index.js:9:14)

 Error: error: 3
     at null._onTimeout (index.js:9:14)

 reject: 4
 [promises] Unhandled rejections: 3
 Error: error: 2
     at null._onTimeout (index.js:9:14)

 Error: error: 3
     at null._onTimeout (index.js:9:14)

 Error: error: 4
     at null._onTimeout (index.js:9:14)  

环境信息:

• whenjs: v3.1.0
• Node :v0.10.26

Answer 1

最好的选择是使用 when.settle，settle 会在所有 promise 解决时返回所有 promise ，而不是在它们履行时返回，这样您就可以手动检查哪些做得好，哪些做得不好。

var arrayOfPromises = array.map(testMapper);
when.settle(arrayOfPromises).then(function(descriptors){
     descriptors.forEach(function(d){
         if(d.state === "rejected"){
             // do cleanup for that promise, you can access its rejection reason here
             // and do any cleanup you want
         } else{
            // successful results accessed here
            console.log("Successful!", d.value);
         }
     })
});

---

注意:

这其实不是一个小问题。当我说不是一个小问题时，我的意思是这是一个很难正确解决的大问题。这里有多种隐含行为和边缘情况。

考虑阅读 this somewhat lengthy discussion .如果您愿意考虑 - Bluebird 有一个实验性的 promise-using 分支，它允许指定处理器，这会让您很容易地做到这一点。

你可以这样做:

using(pool.getConnectionAsync().disposer("close"), function(connection) {
   return connection.queryAsync("SELECT * FROM TABLE");
}).then(function(rows) {
    console.log(rows);
});

或者在多资源的情况下:

var a = Promise.cast(externalPromiseApi.getResource1()).disposer("close");
var b = Promise.cast(externalPromiseApi.getResource2()).disposer("close");
using(a, b, function(resource1, resource2) {
    // once the promise returned here is resolved, we have a deterministic guarantee that 
    // all the resources used here have been closed.
})