Javascript 对同步函数的异步调用

假设我有一个同步函数，例如：

var sum = function(x,y){
  return x+y
}

我想异步调用这个函数。这怎么可能？下面的函数是否被视为异步函数？如果这是一个异步函数，那么第二个函数的日志应该在第一个函数之前记录？我知道这是一个非常简单的例子，可能不是异步函数的理想情况。但我只是想弄清楚这一点

function(a, b, c, d, e, f, function(){
  console.log(result);
})
{
   result = sum(a, b);
   result = sum(result, c);
   result = sum(result, d);
   result = sum(result, e);
   result = sum(result, f);
   return
)};


function(a, b, function(){
  console.log(result);
})
{
   result = sum(a, b);
   return
)};

请帮帮我。如果这是不正确的，那么请帮助我如何写

这怎么可能

事实并非如此。它所做的一切都是同步操作

在处理本质上是异步的事情时，使用异步代码。在JS中，这几乎完全限于事件处理

下面的函数是否被视为异步函数

没有。它有一个回调，但它所做的一切都是同步的。

在Javascript中（暂时将节点放在一边），应该通过setTimeout（）调用异步函数。SetTimeout在等待时不会阻止脚本执行：

function someThingThatTakesAWhile() { 
    for (var i = 0; i < someVeryLargeNumber; i++) {
        //...
    };
}
setTimeout(function () {
    someThingThatTakesAWhile();
}, 0);

函数somethingthattakeshove（）{
对于（var i=0；i

（尚未测试，请原谅拼写错误，&c）

---

但如果你想在node中这样做，我不认为这是你真正想要的。

从你对昆汀答案的评论来看

如何创建一个内部有一些操作的函数，这是一个正常的同步函数，但整个流程不会等待此函数完成，而是移动到下一个函数

JavaScript语言没有这样做的功能。因此，您可以查看它运行的环境，以查看该环境是否具有该功能

NodeJS有。事实上，它有几个功能：（这有点像浏览器提供的功能），还有。对于您的用例，

setImmediate

可能是最好的选择，但是

setImmediate

如下所示：

setImmediate(functionToCall);

（这是一个全球性的系统，您不必要求任何东西。）

这正是标题所要求的：对同步函数的异步调用

---

以下是您的评论：

我只需要创建一个异步函数，在其中调用一个普通的同步函数。当我指的是异步函数时，我的意思是当我调用这个函数时，它不会阻塞流，流会进入下一个函数，这个函数可以在完成后做一些事情（比如日志记录）

这与你的问题所问的不完全相同。：-）

首先，没有异步函数（在JavaScript中）。在JavaScript中调用函数时，该函数将同步执行。这意味着你有两个选择：

调用代码可以使用

setImmediate

告诉节点异步调用函数，或者

该函数可以自己完成，可能使用嵌套函数

以下是#1：

哪些产出：

A B C …它也输出

A B C A. B C

---

请注意“C”是如何作为参数传递到

bar

的

bar

除了将回调调度到其嵌套函数

run

之外，什么也不做

run

使用参数。

我不能完全确定我是否理解您需要什么，但我相信您正在寻找的是创建并发的函数调用，这意味着您可能需要运行一个潜在的计算密集型代码，您不希望它在计算运行时阻止其他代码的执行。 Node.js通常用于单线程进程，这意味着在给定时间只能运行一段代码，但仍有一些方法可以做到这一点

正如@T.J.Crowder的回答中所述，一种方法是使用process.nextTick对函数调用进行排队，以便它在事件循环的下一个周期中运行。这有助于将密集的计算分解为迭代，并且每个迭代都将排队以在上一个循环之后的下一个事件循环中运行。这在某些情况下会有所帮助，但并不总是可以将计算分解为相互异步运行的迭代。如果您想要更详细地解释Javascript是如何异步运行的，我建议您阅读

至少还有两种方法（据我所知）可以实现与Node.js的某种并发性，即Workers/Threads和子进程。 简言之，子进程只是主应用程序运行的另一个Node.js进程。如果您想这样做，可以使用Node.js的原生*child_process*模块运行和管理子进程。有关更多信息，请参阅

第三种方法是以与浏览器中使用Web Worker非常相似的方式使用Worker。辅助程序是在与主应用程序不同的操作系统线程中运行的代码片段。对我来说，这似乎是实现并发性的最简单的方法，尽管有些人会认为这不是最健壮的方法，而且创建子进程更好

有一个很好的解释说明了工人是如何在工作中发挥作用的。要在Node.js中使用worker，您需要一个外部模块，例如

下面是从您的示例中创建的代码示例，其中包含文档中的一个片段：

var Worker = require('webworker-threads').Worker;

var worker = new Worker(function(){
    onmessage = function(event) {
        result = sum(event.data.a, event.data.b);
        result = sum(result, event.data.c);
        result = sum(result, event.data.d);
        result = sum(result, event.data.e);
        result = sum(result, event.data.f);
        postMessage(result);
        self.close();
    };
});
worker.onmessage = function(event) {
    console.log("The result is: " + event.data);
};
worker.postMessage({a: 1, b: 2, c: 3, d: 4, e: 5, f: 6});

// Do some other stuff that will happen while your Worker runs...

---

尽管如此，大多数人还是会尽量避免在Node.js中运行并发代码。Javascript的异步特性使编写简单简洁的后端代码变得容易，通常您希望保持这种状态，除非绝对必要，否则不要尝试在应用程序中引入并发性。

您似乎不了解回调和异步编程。你的代码中没有任何异步的东西 A B C

var Worker = require('webworker-threads').Worker;

var worker = new Worker(function(){
    onmessage = function(event) {
        result = sum(event.data.a, event.data.b);
        result = sum(result, event.data.c);
        result = sum(result, event.data.d);
        result = sum(result, event.data.e);
        result = sum(result, event.data.f);
        postMessage(result);
        self.close();
    };
});
worker.onmessage = function(event) {
    console.log("The result is: " + event.data);
};
worker.postMessage({a: 1, b: 2, c: 3, d: 4, e: 5, f: 6});

// Do some other stuff that will happen while your Worker runs...