Question

我正在创建一个API，当GET对新闻API进行一系列调用时，新闻文章标题被提取为一个巨大的字符串，并且该字符串被处理成一个对象，以便传递给前面的wordcloud -结束。到目前为止，我已经能够使用下划线_.after和请求 - 承诺让我的应用等待所有API调用完成后再调用processWordBank()获取巨型字符串和把它清理成一个物体。但是，一旦调用processWordBank()，我就无法理解程序的流程。理想情况下，processWordBank()会将obj返回到路由器中的cloudObj，以便obj可以传递给res.json()并作为响应吐出。我相信我对_.after的使用让我处于一种奇怪的境地，但这是我能够在进行下一步所需行动之前完成异步调用的唯一方法。有什么建议吗？

（我试图省略所有不必要的代码，但如果这还不够，请告诉我）

// includes...
var sourceString = ""
// router
export default ({ config }) => {
  let news = Router()
  news.get('/', function(req, res){
    var cloudObj = getSources()
        res.json({ cloudObj })
  })
  return news
}

// create list of words (sourceString) by pulling news data from various sources
function getSources() {
    return getNewsApi()

}
// NEWS API
// GET top 10 news article titles from News API (news sources are determined by the values of newsApiSource array)
function getNewsApi() {
  var finished = _.after(newsApiSource.length, processWordBank)
  for(var i = 0; i < newsApiSource.length; i++) {
    let options = {
      uri: 'https://newsapi.org/v1/articles?source=' + newsApiSource[i] + '&sortBy=' + rank + '&apiKey=' + apiKey,
      json: true
    }
    rp(options)
    .then(function (res) {
      let articles = res.articles // grab article objects from the response
      let articleTitles = " " + _.pluck(articles, 'title') // extract title of each news article
      sourceString += " " + articleTitles // add all titles to the word bank
      finished() // this async task has finished
    })
    .catch(function (err) {
      console.log(err)
    })
    }
}

// analyse word bank for patterns/trends
function processWordBank(){
  var sourceArray = refineSource(sourceString)
  sourceArray = combineCommon(sourceArray)
  sourceArray = getWordFreq(sourceArray)
  var obj = sortToObject(sourceArray[0], sourceArray[1])
  console.log(obj)
  return obj
}

Answer 1

异步流程中的一个大问题是您使用共享变量sourceString来处理结果。当您对getNewsApi()进行多次调用时，您的结果是不可预测的，并且不会始终相同，因为没有预定义的顺序来执行异步调用。不仅如此，你永远不会重置它，因此所有后续调用也将包括先前调用的结果。避免在异步调用中修改共享变量，而是直接使用结果。

我已经能够使用下划线的_.after和请求承诺让我的应用等到所有API调用完成后再调用processWordBank()

虽然可以使用_.after，但这可以通过promises非常好地完成，并且由于您已经在为请求使用promises，因此只需从它们收集结果即可。因此，您希望等到所有API调用完成后，您可以使用Promise.all，它会返回一个承诺，一旦所有承诺的值都满足，它就会解析所有承诺的值数组。让我们看一个非常简单的示例来了解Promise.all的工作原理：

// Promise.resolve() creates a promise that is fulfilled with the given value
const p1 = Promise.resolve('a promise')
// A promise that completes after 1 second
const p2 = new Promise(resolve => setTimeout(() => resolve('after 1 second'), 1000))
const p3 = Promise.resolve('hello').then(s => s + ' world')
const promises = [p1, p2, p3]

console.log('Waiting for all promises')
Promise.all(promises).then(results => console.log('All promises finished', results))
console.log('Promise.all does not block execution')

现在我们可以修改getNewsApi()以使用Promise.all。给Promise.all的promise数组是您在循环中执行的所有API请求。这将使用Array.protoype.map创建。而且不是从_.pluck返回的数组中创建一个字符串，我们可以直接使用该数组，因此您不需要在最后将字符串解析回数组。

function getNewsApi() {
  // Each element is a request promise
  const apiCalls = newsApiSource.map(function (source) {
    let options = {
      uri: 'https://newsapi.org/v1/articles?source=' + source + '&sortBy=' + rank + '&apiKey=' + apiKey,
      json: true
    }
    return rp(options)
      .then(function (res) {
        let articles = res.articles
        let articleTitles = _.pluck(articles, 'title')
        // The promise is fulfilled with the articleTitles
        return articleTitles
      })
      .catch(function (err) {
        console.log(err)
      })
  })
  // Return the promise that is fulfilled with all request values
  return Promise.all(apiCalls)
}

然后我们需要使用路由器中的值。我们知道从getNewsApi()返回的promise会满足所有请求的数组，这些请求本身会返回一系列文章。这是一个二维数组，但可能你想要一个包含processWordBank()函数所有文章的1d数组，所以我们可以先将它展平。

export default ({ config }) => {
  let news = Router()
  new.get('/', (req, res) => {
    const cloudObj = getSources()
    cloudObj.then(function (apiResponses) {
      // Flatten the array
      // From: [['source1article1', 'source1article2'], ['source2article1'], ...]
      // To: ['source1article1', 'source1article2', 'source2article1', ...]
      const articles = [].concat.apply([], apiResponses)
      // Pass the articles as parameter
      const processedArticles = processWordBank(articles)
      // Respond with the processed object
      res.json({ processedArticles })
    })
  })
}

最后需要更改processWordBank()以使用输入参数而不是使用共享变量。不再需要refineSource，因为您已经传递了一个数组（除非您对其进行了其他修改）。

function processWordBank(articles) {
  let sourceArray = combineCommon(articles)
  sourceArray = getWordFreq(sourceArray)
  var obj = sortToObject(sourceArray[0], sourceArray[1])
  console.log(obj)
  return obj
}

作为奖励，路由器和getNewsApi()可以使用一些ES6 features进行清理（不含上述代码段中的注释）：

export default ({ config }) => {
  const news = Router()
  new.get('/', (req, res) => {
    getSources().then(apiResponses => {
      const articles = [].concat(...apiResponses)
      const processedArticles = processWordBank(articles)
      res.json({ processedArticles })
    })
  })
}

function getNewsApi() {
  const apiCalls = newsApiSource.map(source => {
    const options = {
      uri: `https://newsapi.org/v1/articles?source=${source}&sortBy=${rank}&apiKey=${apiKey}`,
      json: true
    }
    return rp(options)
      .then(res => _.pluck(res.articles, 'title'))
      .catch(err => console.log(err))
  })
  return Promise.all(apiCalls)
}

如何使用promises等待异步API调用

1 个答案: