递归等待的承诺在解决后什么都不做

Question

我正在向 Twitter API 发出一些请求，为了检索推文，我需要执行一些递归方法调用，因为每个请求最多只能返回 100 条推文。

所以这个过程很简单。

1. 调用函数并等待它
2. 执行 http 请求，等待
3. 如果响应的元数据包含 next_token，则缓存结果并使用下一个令牌执行另一个 http 请求。
4. 重复直到 next_token 未定义，此时使用所有推文列表解决承诺。

然而这并没有按预期工作，递归 http 工作，但是当递归函数的 else 块满足并且 promise 被解决时，什么也没有发生。执行不会回到第一个函数。一切似乎都在旋转，什么也不做。我在每一行都添加了断点，但没有任何东西会触发断点。

我哪里错了？

public async getTweetList(ticker: string): Promise<string[]>{
        let tweets: string[] = [];

        tweets = await this.getAllTweetsRecursively(ticker, null, tweets);
        return tweets;
    }

    public async getAllTweetsRecursively(ticker: string, nextToken: string, tweetList: string[]): Promise<string[]>{
        return new Promise(async (resolve, reject) => {
            let query = `?query=(${ticker})`
            query += this.extraQuery;

            if(nextToken){
                query += this.nextTokenQuery + nextToken
            }

            let res = await axios.default.get(this.url + query, {
                headers: this.headers
            })

            let newNextToken = res.data.meta.next_token;
            if(res.data.data.length > 0 && newNextToken){
                res.data.data.forEach(tweet => {
                    tweetList.push(tweet.text);
                })
                this.getAllTweetsRecursively(ticker, newNextToken, tweetList);
            }
            else {
                resolve(cleanedTweets)
            }
        })
    }

替代实现 - 相同问题

public async getTweetList(ticker: string): Promise<string[]>{
        return new Promise(async (resolve) => {
            let tweets: string[] = [];

            tweets = await this.getAllTweetsRecursively(ticker, null, tweets);
            resolve(tweets);
        })

    }

    public async getAllTweetsRecursively(ticker: string, nextToken: string, tweetList: string[]): Promise<string[]>{
        return new Promise(async (resolve, reject) => {
            let query = `?query=(${ticker})`
            query += this.extraQuery;

            if(nextToken){
                query += this.nextTokenQuery + nextToken
            }

            let res = await axios.default.get(this.url + query, {
                headers: this.headers
            })

            let newNextToken = res.data.meta.next_token;
            if(res.data.data.length > 0 && newNextToken){
                res.data.data.forEach(tweet => {
                    tweetList.push(tweet.text);
                })
                await this.getAllTweetsRecursively(ticker, newNextToken, tweetList);
            }
            else {
                let cleanedTweets: string[] = [];
                tweetList.forEach(tweet => {
                    if(tweet.startsWith("RT")){
                        return;
                    }
                    if(!tweet.toLowerCase().includes("$" + ticker)){
                        return;
                    }
                    cleanedTweets.push(tweet);
                });
                resolve(cleanedTweets)
            }
        })
    }

Answer 1

请记住，async function() {} 已经定义了一个返回 Promise 的函数，因为这就是 async 关键字为您所做的。它通过将函数体包装在 Promise 中来使您的函数体异步，而无需您自己编写 Promise 代码。然后为方便起见，await 关键字等价于 Promise.then()，无需自己编写提取代码。

因此，以下两个函数相同：

function() {
  return new Promise(resolve, reject => {
    resolve(4);
  });
}

async function() {
  return 4;
}

两者都返回一个 Promise，两者都可以是 awaited 在另一个 async 函数中，并且两者都可以是 .then() 链式的，因为它们实际上是同一个东西。所以对于你的代码，如果你想使用async/await，你不应该也构建Promises：

public async getTweetList(ticker: string): Promise<string[]> {
  return await this.getAllTweetsRecursively(ticker, null, []);
}

public async getAllTweetsRecursively(ticker: string, nextToken: string, tweetList: string[]): Promise<string[]>{
    let query = `?query=(${ticker})${this.extraQuery}`;

    if(nextToken){
      query = `${query}${this.nextTokenQuery}${nextToken}`;
    }

    let res = await axios.default.get(this.url + query, {
      headers: this.headers
    })

    let newNextToken = res.data.meta.next_token;
    if(res.data.data.length > 0 && newNextToken){
      res.data.data.forEach(tweet => tweetList.push(tweet.text))
      return await this.getAllTweetsRecursively(ticker, newNextToken, tweetList));
    }

    // no need for "else": the "if" already returns.

    res.data.data.forEach(tweet => tweetList.push(tweet.text))
    let cleanedTweets: string[] = [];
    tweetList.forEach(tweet => {
      if(tweet.startsWith("RT")) return;
      if(!tweet.toLowerCase().includes("$" + ticker)) return;
      cleanedTweets.push(tweet);
    });

    return cleanedTweets
  })
}

您的代码包含 async getAllTweetsRecursively(...) { return new Promise(async (resolve, reject) => { ... })) 现在将返回三个嵌套的承诺，因为这些 async 关键字使得：

getAllTweetsRecursively(...) {
  return new Promise(resolve, reject => {
    return new Promise(async (resolve, reject) => {
      ...
    }))
  });
}

因此async 进一步展开为：

getAllTweetsRecursively(...) {
  return new Promise(resolve, reject => {
    return new Promise((resolve, reject) => {
      return new Promise(resolve, reject => {
        resolve(...)
      })
    }))
  });
}

这种方式是疯狂的=）

Answer 2

问题是内部承诺在递归的情况下没有解决 称自己。

添加resolve(await this.getAllTweetsRecursively(ticker, newNextToken, tweetList)); 解决了这个问题。

public async getTweetList(ticker: string): Promise<string[]> {
  let tweets: string[] = [];
  return await this.getAllTweetsRecursively(ticker, null, tweets);
}

public async getAllTweetsRecursively(ticker: string, nextToken: string, tweetList: string[]): Promise<string[]>{
  return new Promise(async (resolve, reject) => {
    let query = `?query=(${ticker})`
    query += this.extraQuery;

    if(nextToken){
      query += this.nextTokenQuery + nextToken
    }

    let res = await axios.default.get(this.url + query, {
      headers: this.headers
    })

    let newNextToken = res.data.meta.next_token;
    if(res.data.data.length > 0 && newNextToken){
      res.data.data.forEach(tweet => {
        tweetList.push(tweet.text);
      })
      resolve(await this.getAllTweetsRecursively(ticker, newNextToken, tweetList));
    }
    else {
      res.data.data.forEach(tweet => {
        tweetList.push(tweet.text);
      })
      let cleanedTweets: string[] = [];
      tweetList.forEach(tweet => {
        if(tweet.startsWith("RT")){
          return;
        }
        if(!tweet.toLowerCase().includes("$" + ticker)){
          return;
        }
        cleanedTweets.push(tweet);
      });
      resolve(cleanedTweets)
    }
  })
}