多个Q.all内部函数？

Question

我想向用户发送新书的列表。到目前为止，下面的代码工作正常。问题是我不想多次发送一本书，所以我想过滤它们。

当前的代码工作正常：

function checkActiveBooks(books) { 
    var queue = _(books).map(function(book) { 
    var deferred = Q.defer(); 

    // Get all alerts on given keywords 
    request('http://localhost:5000/books?l=0&q=' + book.name, function(error, response, body) { 
     if (error) { 
     deferred.reject(error); 
     } 

     var books = JSON.parse(body); 
     if (!_.isEmpty(books)) { 

     // Loop through users of current book. 
     var userBooks = _(book.users).map(function(user) { 

      // Save object for this user with name and deals. 
      return { 
       user: user, 
       book: book.name, 
       books: books 
      } 

     }); 

     if (_.isEmpty(userBooks)) { 
      deferred.resolve(null); 
     } else { 
      deferred.resolve(userBooks); 
     } 
     } else { 
     deferred.resolve(null); 
     } 

    }); 

    return deferred.promise; 

    }); 

    return Q.all(queue); 
} 

但现在我想已经过滤发书：

function checkActiveBooks(books) { 
    var queue = _(books).map(function(book) { 
     var deferred = Q.defer(); 
     // Get all alerts on given keywords 
     request('http://localhost:5000/books?l=0&q=' + book.name, function(error, response, body) { 
      if (error) { 
       deferred.reject(error); 
      } 
      var books = JSON.parse(body); 
      if (!_.isEmpty(books)) { 
       // Loop through users of current book. 
       var userBooks = _(book.users).map(function(user) { 
        var defer = Q.defer(); 
        var userBook = user.userBook.dataValues; 
        // Check per given UserBook which books are already sent to the user by mail 
        checkSentBooks(userBook).then(function(sentBooks) { 
         // Filter books which are already sent. 
         var leftBooks = _.reject(books, function(obj) { 
          return sentBooks.indexOf(obj.id) > -1; 
         }); 
         // Save object for this user with name and deals. 
         var result = { 
          user: user, 
          book: book.name, 
          books: leftBooks 
         } 
         return deferred.resolve(result); 
        }); 
        return Q.all(userBooks); 
       } else { 
        deferred.resolve(null); 
       } 
      }); 
      return deferred.promise; 
     }); 
     return Q.all(queue); 
    } 

但上面的代码不起作用。它不停止循环。我认为使用q.all两次是有意义的，因为它包含两个循环。但我想我做错了...

Answer 1

代理上@本杰明的建议，这里是代码会是什么样当checkSentBooks返回一个承诺，如：

var request = Q.nfbind(require("request")); // a promised version. 
function checkActiveBooks(books) { 
    return Q.all(_(books).map(function(book) { 
     // a callback with multiple arguments will resolve the promise with 
     // an array, so we use `spread` here 
     return request('http://localhost:5000/books?l=0&q=' + book.name).spread(function(response, body) { 
      var books = JSON.parse(body); 
      if (_.isEmpty(books)) return null; 
      return Q.all(_(book.users).map(function(user) { 
       return checkSentBooks(user.userBook.dataValues).then(function(sentBooks) { 
//    ^^^^^^ return a promise to the array for `Q.all` 
        return { 
         user: user, 
         book: book.name, 
         books: _.reject(books, function(obj) { 
          return sentBooks.indexOf(obj.id) > -1; 
         }) 
        }; 
       }); 
      })); 
     }); 
    })); 
} 

Answer 2

首先，你应该总是在最低级别promisify。你在这里复杂化并且有多个延期。通常，只有在将API转换为承诺时才会有延迟。承诺链和撰写所以让我们做到这一点:)

var request = Q.nfbind(require("request")); // a promised version. 

这可以使你的代码在顶部变成：

function checkActiveBooks(books) { 
    return Q.all(books.map(function(book){ 
     return request('http://.../books?l=0&q=' + book.name) 
       .get(1) // body 
       .then(JSON.parse) // parse body as json 
       .then(function(book){ 
        if(_.isEmpty(book.users)) return null; 
        return book.users.map(function(user){ 
         return {user: user, book: book.name, books: books }; 
        }); 
       }); 
    }); 
} 

这在我看来，很多更优雅。

现在，如果我们想通过谓词来过滤他们，我们可以这样做：

function checkActiveBooksThatWereNotSent(books) { 
     return checkActiveBooks(books).then(function(books){ 
      return books.filter(function(book){ 
        return checkSentBooks(book.book); 
       }); 
     }); 
} 

值得一提的是，蓝鸟库中有实用方法这一切就像Promise#filter和Promise#map那将会使代码更短。

注意，如果checkSentBook是异步你需要稍微修改代码：

function checkActiveBooksThatWereNotSent(books) { 
     return checkActiveBooks(books).then(function(books){ 
      return Q.all(books.map(function(book){ // note the Q.all 
        return Q.all([book, checkSentBooks(book.book)]); 
       })).then(function(results){ 
        return results.filter(function(x){ return x[1]; }) 
            .map(function(x){ return x[0]; }); 
       }); 
     }); 
} 

就像我说的，有不同的库这看起来要好很多。以下是代码在Bluebird中的样子，它的速度也快两个数量级，并且具有良好的堆栈跟踪和检测未处理的拒绝。为了娱乐和荣耀，我扔了ES6箭头和速记属性：

var request = Promise.promisify(require("request")); 

var checkActiveBooks = (books) => 
    Promise. 
    map(books, book => request("...&q=" + book.name).get(1)). 
    map(JSON.parse). 
    map(book => book.users.length ? 
     book.users.map(user => {user, books, book: book.name) : null)) 

var checkActiveBooksThatWereNotSent = (books) => 
    checkActiveBooks(books).filter(checkBookSent) 

我发现好多了。