为什么这些嵌套的承诺不起作用？

Question

我正在编写一个进程以在节点环境中的cron作业上运行。

该进程从两个外部服务中提取两个用户列表，写入文件并进行一些比较。

用户的其中一个来源是Discourse论坛，不幸的是，要获取完整的用户列表，我们必须获取多个trust_level列表并将它们连接起来。

我使用各种嵌套的promise和Promise.all来构造它。但是，下面的函数是太早调用其then回调，之前forumList.json和databaseList.json甚至存在...我在这里做错了什么？

import superagent from 'superagent' 
import { writeFileSync } from 'fs' 

export default function fetchData() { 

    const process = [] 

    const databaseFetch = new Promise((resolve, reject) => { 

    superagent.get('https://our-api.com/api/1/databases/our-db/collections/users') 
     .end((error, response) => { 

     if (error) { 
      reject(error) 
     } else { 
      writeFileSync('temp/databaseList.json', JSON.stringify(response.body)) 
      resolve() 
     } 

     }) 

    }) 

    const forumFetch = new Promise((resolve, reject) => { 

    // For reference, see https://meta.discourse.org/t/how-do-i-get-a-list-of-all-users-from-the-api/24261/8 
    // We have to do this because of the way the discourse API is built 
    const discourseApiList = [ 
     'trust_level_0', 
     'trust_level_1', 
     'trust_level_2', 
     'trust_level_3', 
     'trust_level_4', 
    ] 

    let forumList = [] 

    const discoursePromises = discourseApiList.map((trustLevel) => { 

     return new Promise((resolveInner, rejectInner) => { 
     superagent.get(`https://our-website.com/forum/groups/${trustLevel}/members.json`) 
      .end((error, response) => { 

      if (error) { 
       rejectInner(error) 
       reject() 
      } else { 
       forumList = forumList.concat(response.body.members) 
       resolveInner() 
      } 

      }) 
     }) 

    }) 

    Promise.all(discoursePromises).then(() => { 
     writeFileSync('temp/forumList.json', JSON.stringify(forumList)) 
     resolve() 
    }) 

    }) 

    process.push(databaseFetch) 
    process.push(forumFetch) 

    return Promise.all(process) 

} 

Answer 1

Promise代码对我来说看起来很好，问题一定是其他地方。

function fetchData() { 
 

 
    const process = [] 
 

 
    const databaseFetch = new Promise((resolve, reject) => { 
 
    setTimeout(function() { 
 
     console.log('resolving databaseFetch'); 
 
     resolve(); 
 
    }, Math.round(Math.random() * 10000)); 
 
    }) 
 

 
    const forumFetch = new Promise((resolve, reject) => { 
 

 
    const discourseApiList = [ 
 
     'trust_level_0', 
 
     'trust_level_1', 
 
     'trust_level_2', 
 
     'trust_level_3', 
 
     'trust_level_4', 
 
    ] 
 

 
    let forumList = [] 
 

 
    const discoursePromises = discourseApiList.map((trustLevel) => { 
 

 
     return new Promise((resolveInner, rejectInner) => { 
 

 
     setTimeout(function() { 
 
      console.log('resolving ' + trustLevel); 
 
      resolveInner(); 
 
     }, Math.round(Math.random() * 10000)); 
 

 
     }) 
 

 
    }) 
 

 
    Promise.all(discoursePromises).then(() => { 
 
     setTimeout(function() { 
 
     console.log('resolving discoursePromises'); 
 
     resolve(); 
 
     }, Math.round(Math.random() * 1000)); 
 
    }) 
 

 
    }) 
 

 
    process.push(databaseFetch) 
 
    process.push(forumFetch) 
 

 
    return Promise.all(process) 
 
} 
 

 
fetchData().then(() => console.log('finished!'));

Answer 2

您不应该嵌套Promise s，因为它们的唯一目的是创建线性代码。我建议这样的行为：

1-创建discoursePromises与Promise.all

2-解决这些问题的话，创建forumFetch和databaseFetch与Promise.all

解决这些问题，我认为你可能会感兴趣async这是一个伟大的流量控制库。尤其要看parallel。 希望这有助于。

Answer 3

不嵌套的承诺，如果你不希望使用异步库，也不promise.all，U可以只写你的承诺，然后把它们连控制自己的流：

确定承诺：

const promise1Fun =() => { 
return new Promise((resolve, reject) => { 
//do stuff 
}) 
} 


const promise2Fun =() => { 
return new Promise((resolve, reject) => { 
//do stuff 
}) 
} 

链接承诺：

promise1Fun.then(promise2Fun).catch((err) => console.error(err))