c++ - promettre une boucle de mangouste à travers la requête

Question

let result = []; //存放查询结果
model.WithdrawModel.find({status:'processing'}, (err, doc) => {
            if (err) {
                console.log(err);
                res.json({ code: -1, msg: '查询失败'});
                return;
            } else {
                doc.map((item) => {
                    model.UserModel.findOne({phone:item.phone},'name IDcard bank bankCard bank_area bank_name', (err, bankInfo) => {
                        if (err) {
                            console.log(err);
                        } else {
                            let obj = {};
                            Object.assign(obj, JSON.parse(JSON.stringify(item)), JSON.parse(JSON.stringify(bankInfo)));
                            result.push(obj);
                            console.log(result); 
                        }
                    })
                });
                res.json({ code: 0, msg: '查询成功', result: result});
                return;
            }
 });

En parcourant la requête, le résultat ci-dessus renvoie directement une valeur nulle. Comment puis-je m'assurer que toutes les requêtes internes dans doc.map sont terminées avant de retirer la valeur du résultat ?

Answer 1

Posez et répondez à vos propres questions et recevez les conseils des autres.

promise.all est implémenté comme suit :

        let result = []; //存放查询结果
        let doc1 = []; //存放第一次查询的结果
        model.WithdrawModel.find({status:'processing'}).exec().then((doc) => {
            doc1 = doc;
            const promises = doc.map(item => model.UserModel.findOne({phone:item.phone},'name IDcard bank bankCard bank_area bank_name'));
            return Promise.all(promises);
        })
        .then((bankInfoList) => {//promise.all返回的结果是一一对应的
            for(let i=0; i<doc1.length; i++){
                let obj = {};
                
                Object.assign(obj, JSON.parse(JSON.stringify(doc1[i])), JSON.parse(JSON.stringify(bankInfoList[i])));
                result.push(obj);
            }
            return new Promise((resolve, reject) => {
                    resolve(result);
            })           
        })
        .then((result) => {
            return new Promise(() => {
                res.json({ code: 0, msg: '查询成功', result: result});
                return;
            });
        })
        .catch((e) => {
            console.log(e);
            res.json({ code: -1, msg: '查询失败'});
            return;
        });

------------------------------------------------- Supplément ---------- ---------------------------------------

L'idée de compter est toujours réalisable, il suffit d'utiliser le module événementiel :

Answer 2

Puisque Promise est un appel asynchrone, utilisez return，会在还没真正获取到数据之后就返回，所以需要Promise内添加一个计数器count，在所有的Promise下，加一个循环，当所有的doc都循环到了（count == doc.length) après toutes les requêtes pour afficher le retour.

const deasync = require('deasync'); // 引入deasync包
...
let result = []; //存放查询结果
model.WithdrawModel.find({status: 'processing'}, (err, doc) => {
    if(err) {
        console.log(err);
        res.json({code: -1, msg: '查询失败'});
        return;
    } else {
        let count = 0, len = doc.length;

        doc.forEach((item, index) => {
            model.UserModel.findOne({phone: item.phone}, 'name IDcard bank bankCard bank_area bank_name', (err, bankInfo) => {
                if (err) {
                    console.log(err);
                } else {
                    let obj = {};
                    Object.assign(obj, JSON.parse(JSON.stringify(item)), JSON.parse(JSON.stringify(bankInfo)));
                    result.push(obj);
                    console.log(result); 
                }

                count++;
            });
        });

        deasync.loopWhile(() => count < len);

        res.json({code: 0, msg: '查询成功', result: result});
        return;
    }
});