爲什麼這些嵌套的承諾不起作用？

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))