注意:这个答案可能不应该在产品代码中使用。这是一个黑客，你应该知道它的含义。

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

注意，这种方法在某种程度上否定了Nodejs的整个目的，即让所有内容都是异步和非阻塞的。此外，它可能会大大增加调用堆栈的深度，因此可能会导致堆栈溢出。如果你递归地运行这样的函数，你肯定会遇到麻烦。

请参阅其他关于如何重新设计代码以使其“正确”的答案。

这里的解决方案可能只在您进行测试时有用，特别是当您想要同步和串行代码时。

注意:这个答案可能不应该在产品代码中使用。这是一个黑客，你应该知道它的含义。

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

注意，这种方法在某种程度上否定了Nodejs的整个目的，即让所有内容都是异步和非阻塞的。此外，它可能会大大增加调用堆栈的深度，因此可能会导致堆栈溢出。如果你递归地运行这样的函数，你肯定会遇到麻烦。

请参阅其他关于如何重新设计代码以使其“正确”的答案。

这里的解决方案可能只在您进行测试时有用，特别是当您想要同步和串行代码时。

从节点4.8.0开始，您可以使用ES6中称为生成器的特性。 您可以通过本文了解更深入的概念。 但基本上你可以使用生成器和承诺来完成这项工作。 我使用蓝鸟承诺和管理发电机。

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

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

如果你想让它非常简单，没有花哨的库，在执行一些其他代码之前，等待回调函数在node中执行，是这样的:

//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();
}

实现这一点的一种方法是将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 + ">");
}

// Next function 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

这违背了非阻塞IO的目的——你在不需要阻塞的时候阻塞了它:)

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

如果您需要强制阻塞，那么很可能您对体系结构的想法是错误的。