deasync将异步函数变为同步函数，通过在 JavaScript 层调用 Node.js 事件循环来实现阻塞机制。因此，deasync 只会阻止后续代码运行，而不会阻止整个线程，也不会导致忙等待。有了这个module，这里是 jsFiddle 挑战的答案：

function AnticipatedSyncFunction(){
  var ret;
  setTimeout(function(){
      ret = "hello";
  },3000);
  while(ret === undefined) {
    require('deasync').runLoopOnce();
  }
  return ret;    
}


var output = AnticipatedSyncFunction();
//expected: output=hello (after waiting for 3 sec)
console.log("output="+output);
//actual: output=hello (after waiting for 3 sec)

（免责声明：我是 的共同作者deasync。该module是在发布此问题后创建的，但没有找到可行的建议。）

还有一个 npm 同步module。用于同步执行查询的过程。

当您想以同步方式运行并行查询时，节点会限制这样做，因为它从不等待响应。和同步module非常适合这种解决方案。

示例代码

/*require sync module*/
var Sync = require('sync');
    app.get('/',function(req,res,next){
      story.find().exec(function(err,data){
        var sync_function_data = find_user.sync(null, {name: "sanjeev"});
          res.send({story:data,user:sync_function_data});
        });
    });


    /*****sync function defined here *******/
    function find_user(req_json, callback) {
        process.nextTick(function () {

            users.find(req_json,function (err,data)
            {
                if (!err) {
                    callback(null, data);
                } else {
                    callback(null, err);
                }
            });
        });
    }

参考链接：https : //www.npmjs.com/package/sync

你必须使用Promise：

const asyncOperation = () => {
    return new Promise((resolve, reject) => {
        setTimeout(()=>{resolve("hi")}, 3000)
    })
}

const asyncFunction = async () => {
    return await asyncOperation();
}

const topDog = () => {
    asyncFunction().then((res) => {
        console.log(res);
    });
}

我更喜欢箭头函数定义。但是任何形式为“() => {...}”的字符串也可以写成“function () {...}”

所以尽管调用了异步函数，topDog 并不是异步的。

编辑：我意识到很多时候你需要将异步函数包装在一个同步函数中是在一个控制器中。对于这些情况，这里有一个派对技巧：

const getDemSweetDataz = (req, res) => {
    (async () => {
        try{
            res.status(200).json(
                await asyncOperation()
            );
        }
        catch(e){
            res.status(500).json(serviceResponse); //or whatever
        }
    })() //So we defined and immediately called this async function.
}

将此与回调一起使用，您可以进行不使用Promise的包装：

const asyncOperation = () => {
    return new Promise((resolve, reject) => {
        setTimeout(()=>{resolve("hi")}, 3000)
    })
}

const asyncFunction = async (callback) => {
    let res = await asyncOperation();
    callback(res);
}

const topDog = () => {
    let callback = (res) => {
        console.log(res);
    };

    (async () => {
        await asyncFunction(callback)
    })()
}

通过将此技巧应用于 EventEmitter，您可以获得相同的结果。在我定义回调的地方定义 EventEmitter 的侦听器，并在我调用回调的地方发出事件。

如果函数 Fiber 真的将异步函数 sleep 变成了同步

是的。在光纤内部，函数在记录之前等待ok。Fibers 不会使异步函数同步，但允许编写使用异步函数的同步代码，然后将在Fiber.

我不时发现需要将异步函数封装到同步函数中，以避免大规模的全局重构。

你不能。使异步代码同步是不可能的。您需要在全局代码中预测到这一点，并从一开始就以异步风格编写它。是否将全局代码封装在一个 Fiber 中，使用 promise、promise 生成器还是简单的回调取决于您的偏好。

我的目标是将数据获取方法从同步更改为异步时对调用方的影响最小化

Promise和纤维都可以做到这一点。

如今，这种生成器模式可以成为许多情况下的解决方案。

这是 nodejs 中使用 async readline.question 函数的顺序控制台提示示例：

var main = (function* () {

  // just import and initialize 'readline' in nodejs
  var r = require('readline')
  var rl = r.createInterface({input: process.stdin, output: process.stdout })

  // magic here, the callback is the iterator.next
  var answerA = yield rl.question('do you want this? ', r=>main.next(r))    

  // and again, in a sync fashion
  var answerB = yield rl.question('are you sure? ', r=>main.next(r))        

  // readline boilerplate
  rl.close()

  console.log(answerA, answerB)

})()  // <-- executed: iterator created from generator
main.next()     // kick off the iterator, 
                // runs until the first 'yield', including rightmost code
                // and waits until another main.next() happens