Javascript 通过节点异步/等待不需要按预期顺序返回结果-正确的模式是什么？

我使用的是标准的node require模式，它需要一个文件（send.js），并允许访问这些模块导出的函数

如果我在标准回调模式中使用所有必需的模块，我就会得到预期的结果和正确的执行顺序

但是，如果我尝试移动到等待/异步模式，则函数执行是不正确的（随机的）

在send.js中：

var request = require(`request`);
module.exports = {
    message: function message(psid,text,callback) {
        var options = {
            headers: {
                'Content-Type': `application/json`
            },
            url:`https://graph.facebook.com/v4.0/me/messages?access_token=12345`,
            body:JSON.stringify({
                'messaging_type': `RESPONSE`,
                'recipient':{
                    'id':``+psid+``
                },
                'message': {
                    'text': text
                }
            })
        };
        request.post(options, function (err, res, body){
            if(err){
                console.log(err);
                callback(err)
            }
            else{
              callback(null,body)
            }
        });
    },
}

在app.js中：

回调模式-适用于嵌套函数，函数按顺序执行：

send.message(psid,'text'function(err,result){
        send.message(psid,result,function(err,response){
            console.log(response);
        });
    });

异步等待模式-以错误的顺序返回消息，随机执行顺序：

async function test(){
    const one = await send.getUser(psid,'text',function(){});
    const two = await send.message(psid,`1`,function(){});
    const three = await send.message(psid,`2`,function(){});
    const four = await send.message(psid,`3`,function(){});
    const five = await send.message(psid,`4`,function(){});
}
test();

这是因为所需的模块使用回调吗？如果是，我如何转换

send.js

，以便在app.js中使用异步等待模式

多谢各位

只适用于承诺。您需要修改send.js以使用承诺。 一种方法是使用而不是请求模块

var rp = require(`request-promise`);
module.exports = {
    message: function message(psid,text) {
        var options = {
            method: 'POST',
            headers: {
                'Content-Type': `application/json`
            },
            uri:`https://graph.facebook.com/v4.0/me/messages?access_token=12345`,
            body:{
                'messaging_type': `RESPONSE`,
                'recipient':{
                    'id':``+psid+``
                },
                'message': {
                    'text': text
                }
            }
        };
        return rp(options);
    },
}

您需要修改getUser方法以使用请求承诺。

仅适用于承诺。您需要修改send.js以使用承诺。 一种方法是使用而不是请求模块

var rp = require(`request-promise`);
module.exports = {
    message: function message(psid,text) {
        var options = {
            method: 'POST',
            headers: {
                'Content-Type': `application/json`
            },
            uri:`https://graph.facebook.com/v4.0/me/messages?access_token=12345`,
            body:{
                'messaging_type': `RESPONSE`,
                'recipient':{
                    'id':``+psid+``
                },
                'message': {
                    'text': text
                }
            }
        };
        return rp(options);
    },
}

---

您需要修改getUser方法以使用请求承诺。

如果不使用外部库，您可以返回

承诺，而不是使用
回调

您的send.js可以是：

var request = require(`request`);
module.exports = {
    message: function message(psid, text) {
        return new Promise((resolve, reject) => {
            var options = {
                headers: {
                    'Content-Type': `application/json`
                },
                url: `https://graph.facebook.com/v4.0/me/messages?access_token=12345`,
                body: JSON.stringify({
                    'messaging_type': `RESPONSE`,
                    'recipient': {
                        'id': `` + psid + ``
                    },
                    'message': {
                        'text': text
                    }
                })
            };
            request.post(options, function (err, res, body) {
                if (err) {
                    return reject(err)
                }
                else {
                    return resolve(body)
                }
            });
        })
    }
}

然后你可以在@Satvik Daga的回答中使用它：

const firstBody = await send.message(psid,`1`);

不使用外部库，您可以返回
承诺
，而不是使用
回调

您的send.js可以是：

var request = require(`request`);
module.exports = {
    message: function message(psid, text) {
        return new Promise((resolve, reject) => {
            var options = {
                headers: {
                    'Content-Type': `application/json`
                },
                url: `https://graph.facebook.com/v4.0/me/messages?access_token=12345`,
                body: JSON.stringify({
                    'messaging_type': `RESPONSE`,
                    'recipient': {
                        'id': `` + psid + ``
                    },
                    'message': {
                        'text': text
                    }
                })
            };
            request.post(options, function (err, res, body) {
                if (err) {
                    return reject(err)
                }
                else {
                    return resolve(body)
                }
            });
        })
    }
}

然后你可以在@Satvik Daga的回答中使用它：

const firstBody = await send.message(psid,`1`);

send.message
或
send.getUser
是否返回承诺？如果没有，那么
await
将在那里什么也不做。您的函数不是用async声明的，也不会返回承诺。您的消息getUser应该用async关键字声明，并返回promiseIt的回调或promise/async wait。将两者混合（就像您在
wait message（..，function（）{}）中所做的那样）
没有多大意义。
send.message
或
send.getUser
是否返回承诺？如果没有，则
wait
将不起任何作用。您的函数不是用async声明的，也不会返回承诺。您的消息getUser应该用async关键字声明，并返回承诺它的回调或承诺/a同步等待。将两者混合（就像您在
wait message（....，function（）{}）中所做的那样）
没有多大意义。非常感谢@satvik daga。所有工作都按照预期进行，现在完全理解通过本帖从回调/使用承诺转换而来。很棒的社区。非常感谢@satvik daga。所有工作都按照预期进行，现在完全理解通过本pos从回调/使用承诺转换而来t、 非常好的社区。非常感谢@taymer的加入，这意味着我理解ho现在在其他领域的承诺。非常感谢你的投入。非常感谢@taymer的加入，这意味着我理解ho现在在其他领域的承诺。非常感谢你的投入。