如何在Node.js或Javascript中将异步函数调用包装到同步函数中？

假设您维护一个公开一个函数的库getData。您的用户调用它来获取实际数据：
var output = getData();
数据被保存在文件中，因此您可以getData使用内置的Node.js来实现fs.readFileSync。两者都很明显，getData并且fs.readFileSync都是同步功能。有一天，您被告知将基础数据源切换到一个仓库，例如只能异步访问的MongoDB。还被告知要避免惹恼您的用户，getDataAPI不能更改为仅返回promise或要求回调参数。您如何满足这两个要求？

使用回调/承诺的异步功能是JavasSript和Node.js的DNA。任何不平凡的JS应用程序都可能会渗透这种编码样式。但是这种做法很容易导致所谓的厄运回响金字塔。更糟糕的是，如果调用链中任何调用方中的任何代码都取决于异步函数的结果，则这些代码也必须包装在回调函数中，从而在调用方上施加编码样式约束。我不时发现有必要将异步功能（通常在第三方库中提供）封装到同步功能中，以避免大规模的全局重构。在这个问题上寻找解决方案通常以节点光纤结束或从中派生的npm软件包。但是，光纤无法解决我面临的问题。甚至Fibers作者提供的示例也说明了这一缺陷：

...
Fiber(function() {
    console.log('wait... ' + new Date);
    sleep(1000);
    console.log('ok... ' + new Date);
}).run();
console.log('back in main');

实际输出：

wait... Fri Jan 21 2011 22:42:04 GMT+0900 (JST)
back in main
ok... Fri Jan 21 2011 22:42:05 GMT+0900 (JST)

如果功能Fiber确实将异步功能睡眠转变为同步，则输出应为：

wait... Fri Jan 21 2011 22:42:04 GMT+0900 (JST)
ok... Fri Jan 21 2011 22:42:05 GMT+0900 (JST)
back in main

我在JSFiddle中创建了另一个简单的示例，并寻找产生预期输出的代码。我将接受仅在Node.js中可用的解决方案，因此，即使在JSFiddle中不起作用，您也可以自由地使用任何npm软件包。

deasync通过在JavaScript层调用Node.js事件循环，通过阻止机制将异步功能转换为同步功能。结果，不同步仅阻止后续代码运行，而不阻止整个线程，也不保证繁忙的等待。使用此模块，这是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。该模块是在发布此问题后创建的，没有找到可行的建议。）

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

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

样例代码

/*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

如果功能光纤真正将异步功能睡眠转换为同步

是。在光纤内部，该函数在记录之前等待ok。光纤不会使异步函数同步，而是允许编写使用异步函数的看起来类似同步的代码，然后这些代码将在异步运行Fiber。

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

你不能。使异步代码同步是不可能的。您将需要在全局代码中预料到这一点，并从一开始就以异步方式编写它。是否将全局代码包装在光纤中，使用promise，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的侦听器，并在调用回调的位置发出事件。

我找不到使用节点光纤无法解决的情况。您使用节点光纤提供的示例的行为符合预期。关键是在光纤内运行所有相关代码，因此您不必在随机位置启动新光纤。

让我们看一个例子：假设您使用某个框架，这是您应用程序的切入点（您不能修改此框架）。该框架将nodejs模块作为插件加载，并在插件上调用一些方法。可以说，该框架仅接受同步功能，而不是单独使用光纤。

您想在其中一个插件中使用一个库，但是该库是异步的，您也不想修改它。

没有光纤运行时无法产生主线程，但是您仍然可以使用光纤创建插件！只需创建一个包装程序条目即可在光纤内部启动整个框架，因此您可以从插件中获得执行。

缺点：如果框架在内部使用setTimeout或Promise，则它将逃避光纤上下文。这可以通过嘲讽被合作周围setTimeout，Promise.then以及所有事件处理程序。

因此，这是在a Promise问题解决之前可以产生纤维的方法。此代码采用异步（Promise返回）功能，并在解决诺言后恢复光纤：

framework-entry.js

console.log(require("./my-plugin").run());

async-lib.js

exports.getValueAsync = () => {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve("Async Value");
    }, 100);
  });
};

my-plugin.js

const Fiber = require("fibers");

function fiberWaitFor(promiseOrValue) {
  var fiber = Fiber.current, error, value;
  Promise.resolve(promiseOrValue).then(v => {
    error = false;
    value = v;
    fiber.run();
  }, e => {
    error = true;
    value = e;
    fiber.run();
  });
  Fiber.yield();
  if (error) {
    throw value;
  } else {
    return value;
  }
}

const asyncLib = require("./async-lib");

exports.run = () => {
  return fiberWaitFor(asyncLib.getValueAsync());
};

my-entry.js

require("fibers")(() => {
  require("./framework-entry");
}).run();

运行时node framework-entry.js，它将引发错误：Error: yield() called with no fiber running。如果运行，node my-entry.js它将按预期工作。

在某些方面（例如数据库），使Node.js代码同步至关重要。但是Node.js的实际优势在于异步代码。由于它是单线程非阻塞。

我们可以使用重要的功能来同步它Fiber（）使用await（）和defer（）我们使用await（）调用所有方法。然后将回调函数替换为defer（）。

普通的异步代码，使用回调函数。

function add (var a, var b, function(err,res){
       console.log(res);
});

 function sub (var res2, var b, function(err,res1){
           console.log(res);
    });

 function div (var res2, var b, function(err,res3){
           console.log(res3);
    });

使用Fiber（），await（）和defer（）同步上述代码

fiber(function(){
     var obj1 = await(function add(var a, var b,defer()));
     var obj2 = await(function sub(var obj1, var b, defer()));
     var obj3 = await(function sub(var obj2, var b, defer()));

});

我希望这将有所帮助。谢谢

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

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

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

您不应该查看创建光纤的呼叫周围发生的情况，而应该查看光纤内部发生的情况。一旦进入光纤，您就可以同步编程。例如：

函数f1（）{
    console.log（'wait ...'+ new Date）;
    睡眠（1000）;
    console.log（'ok ...'+ new Date）;   
}

函数f2（）{
    f1（）;
    f1（）;
}

纤维（功能（）{
    f2（）;
}）。跑（）;

纤维内部调用f1，f2并sleep就好像它们是同步。

在典型的Web应用程序中，您将在HTTP请求分派器中创建Fiber。一旦完成，就可以以同步样式编写所有请求处理逻辑，即使它调用了异步函数（fs，数据库等）也是如此。

首先，我使用node.js对此感到苦恼，而async.js是我发现可以帮助您解决此问题的最佳库。如果要与节点一起编写同步代码，则采用这种方法。

var async = require('async');

console.log('in main');

doABunchOfThings(function() {
  console.log('back in main');
});

function doABunchOfThings(fnCallback) {
  async.series([
    function(callback) {
      console.log('step 1');
      callback();
    },
    function(callback) {
      setTimeout(callback, 1000);
    },
    function(callback) {
      console.log('step 2');
      callback();
    },
    function(callback) {
      setTimeout(callback, 2000);
    },
    function(callback) {
      console.log('step 3');
      callback();
    },
  ], function(err, results) {
    console.log('done with things');
    fnCallback();
  });
}

该程序将始终产生以下内容...

in main
step 1
step 2
step 3
done with things
back in main

Javascript是一种单线程语言，您不想阻塞整个服务器！异步代码通过明确显示依赖关系来消除竞争条件。

学习爱异步代码！

在promises不创建回调地狱金字塔的情况下查看异步代码。我建议使用node.js的promiseQ库

httpGet(url.parse("http://example.org/")).then(function (res) {
    console.log(res.statusCode);  // maybe 302
    return httpGet(url.parse(res.headers["location"]));
}).then(function (res) {
    console.log(res.statusCode);  // maybe 200
});

http://howtonode.org/promises

编辑：这是迄今为止我最有争议的答案，节点现在具有yield关键字，它使您可以将异步代码视为同步。http://blog.alexmaccaw.com/how-yield-will-transform-node