如何使函数等到使用node.js调用回调后

2020/10/08 04:41 · javascript ·  · 0评论

我有一个简化的函数,看起来像这样:

function(query) {
  myApi.exec('SomeCommand', function(response) {
    return response;
  });
}

基本上,我希望它调用myApi.exec,并返回在回调lambda中给出的响应。但是,以上代码不起作用,只是立即返回。

只是出于非常骇人的尝试,我尝试了以下无效的方法,但至少您了解了我要实现的目标:

function(query) {
  var r;
  myApi.exec('SomeCommand', function(response) {
    r = response;
  });
  while (!r) {}
  return r;
}

基本上,实现此目的的一种好“ node.js /事件驱动”方式是什么?我希望我的函数等待,直到回调被调用,然后返回传递给它的值。

做到这一点的“良好的node.js /事件驱动”方式是不等待

与使用节点等事件驱动系统一样,几乎所有其他内容一样,您的函数应接受一个回调参数,该参数将在计算完成后被调用。调用者不应等待正常意义上的“返回”值,而应发送将处理结果值的例程:

function(query, callback) {
  myApi.exec('SomeCommand', function(response) {
    // other stuff here...
    // bla bla..
    callback(response); // this will "return" your value to the original caller
  });
}

所以你不要这样使用它:

var returnValue = myFunction(query);

但是像这样:

myFunction(query, function(returnValue) {
  // use the return value here instead of like a regular (non-evented) return value
});

实现此目的的一种方法是将API调用包装为Promise,然后用于await等待结果。

// let's say this is the API function with two callbacks,
// one for success and the other for error
function apiFunction(query, successCallback, errorCallback) {
    if (query == "bad query") {
        errorCallback("problem with the query");
    }
    successCallback("Your query was <" + query + ">");
}

// myFunction wraps the above API call into a Promise
// and handles the callbacks with resolve and reject
function apiFunctionWrapper(query) {
    return new Promise((resolve, reject) => {
        apiFunction(query,(successResponse) => {
            resolve(successResponse);
        }, (errorResponse) => {
            reject(errorResponse)
        });
    });
}

// now you can use await to get the result from the wrapped api function
// and you can use standard try-catch to handle the errors
async function businessLogic() {
    try {
        const result = await apiFunctionWrapper("query all users");
        console.log(result);

        // the next line will fail
        const result2 = await apiFunctionWrapper("bad query");
    } catch(error) {
        console.error("ERROR:" + error);
    }
}

// call the main function
businessLogic();

输出:

Your query was <query all users>
ERROR:problem with the query

检查一下:https :
//github.com/luciotato/waitfor-ES6

您的代码与wait.for:(需要生成器,--harmony标志)

function* (query) {
  var r = yield wait.for( myApi.exec, 'SomeCommand');
  return r;
}

如果您不想使用回叫,则可以使用“ Q”模块。

例如:

function getdb() {
    var deferred = Q.defer();
    MongoClient.connect(databaseUrl, function(err, db) {
        if (err) {
            console.log("Problem connecting database");
            deferred.reject(new Error(err));
        } else {
            var collection = db.collection("url");
            deferred.resolve(collection);
        }
    });
    return deferred.promise;
}


getdb().then(function(collection) {
   // This function will be called afte getdb() will be executed. 

}).fail(function(err){
    // If Error accrued. 

});

有关更多信息,请参考:https : //github.com/kriskowal/q

如果您希望它非常简单,容易,不需要花哨的库,就可以在节点上执行回调函数,然后再执行其他代码,就像这样:

//initialize a global var to control the callback state
var callbackCount = 0;
//call the function that has a callback
someObj.executeCallback(function () {
    callbackCount++;
    runOtherCode();
});
someObj2.executeCallback(function () {
    callbackCount++;
    runOtherCode();
});

//call function that has to wait
continueExec();

function continueExec() {
    //here is the trick, wait until var callbackCount is set number of callback functions
    if (callbackCount < 2) {
        setTimeout(continueExec, 1000);
        return;
    }
    //Finally, do what you need
    doSomeThing();
}

注意:此答案可能不应该在生产代码中使用。这是一个hack,您应该了解其中的含义。

uvrun模块(在此处更新为更新的Nodejs版本),您可以其中执行libuv主事件循环(即Nodejs主循环)的单循环。

您的代码如下所示:

function(query) {
  var r;
  myApi.exec('SomeCommand', function(response) {
    r = response;
  });
  var uvrun = require("uvrun");
  while (!r)
    uvrun.runOnce();
  return r;
}

(您可以替代使用uvrun.runNoWait()。这可以避免某些阻塞问题,但会占用100%的CPU。)

请注意,这种方法使Node.js的全部目的无效,即使所有内容异步和无阻塞。另外,它可能会大大增加您的调用堆栈深度,因此您可能最终会遇到堆栈溢出的情况。如果递归运行这样的功能,肯定会遇到麻烦。

请参阅有关如何重新设计代码以“正确”完成操作的其他答案。

此解决方案仅在进行测试和esp时才有用。想要同步和串行代码。

从节点4.8.0开始,您可以使用称为生成器的ES6功能。您可以阅读本文以了解更深的概念。但基本上,您可以使用生成器并承诺完成这项工作。我正在使用bluebird来管理和管理生成器。

您的代码应该像下面的示例一样正常。

const Promise = require('bluebird');

function* getResponse(query) {
  const r = yield new Promise(resolve => myApi.exec('SomeCommand', resolve);
  return r;
}

Promise.coroutine(getResponse)()
  .then(response => console.log(response));

假设您有一个功能:

var fetchPage(page, callback) {
   ....
   request(uri, function (error, response, body) {
        ....
        if (something_good) {
          callback(true, page+1);
        } else {
          callback(false);
        }
        .....
   });


};

您可以像这样使用回调:

fetchPage(1, x = function(next, page) {
if (next) {
    console.log("^^^ CALLBACK -->  fetchPage: " + page);
    fetchPage(page, x);
}
});

这违反了非阻塞IO的目的-您在不需要阻塞时就将其阻塞 :)

您应该嵌套您的回调,而不是强制node.js等待,或者在需要结果的回调中调用另一个回调r

如果您需要强制阻塞,则很可能是在考虑架构错误。

使用异步并等待它要容易得多。

router.post('/login',async (req, res, next) => {
i = await queries.checkUser(req.body);
console.log('i: '+JSON.stringify(i));
});

//User Available Check
async function checkUser(request) {
try {
    let response = await sql.query('select * from login where email = ?', 
    [request.email]);
    return response[0];

    } catch (err) {
    console.log(err);

  }

}
本文地址:http://javascript.askforanswer.com/ruheshihanshudengdaoshiyongnode-jsdiaoyonghuidiaohou.html
文章标签: ,   ,   ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!