Javascript 这两个js异步回调写的是相同的吗？

假设您有3个异步函数a、b和c。每一个都需要1分钟的时间来运行，并在完成后调用在第一个参数中传递的回调。如果您想告诉节点“开始运行a，然后在a完成后运行b，然后在b完成后运行c”，它将如下所示：

 a(b(c))

function a() {}
function b() {}

...

a(b)

示例代码：

a(function() {
  b(function() {
    c()
  })
})

如果我这样写，会不会是一样的：

 a(b(c))

function a() {}
function b() {}

...

a(b)

有人给了我两个例子：

function a(func){
    setTimeout(function(){
        console.log('a');
        func()
    }, 1000)
}

function b(func){
    setTimeout(function(){
        console.log('b')
        func()
    }, 1000)
}

function c(){
    setTimeout(function(){
        console.log('c')
    }, 1000)
}

a(b(c))  //get error

a(function(){  //work
    b(function(){
        c()
    })
})

---

但是我仍然感到困惑，需要一些解释：D

这对你有用

函数afunc{ setTimeoutfunction{ console.log'a'； func }, 1000 } 函数bfunc{ setTimeoutfunction{ 控制台，日志'b' func }, 1000 } 功能c{ setTimeoutfunction{ 控制台，log'c' }, 1000 }

---

ab.bindnull，c//get error这对您很有用

函数afunc{ setTimeoutfunction{ console.log'a'； func }, 1000 } 函数bfunc{ setTimeoutfunction{ 控制台，日志'b' func }, 1000 } 功能c{ setTimeoutfunction{ 控制台，log'c' }, 1000 }

---

ab.bindnull，c//get error调用abc意味着您使用bc的结果调用a

调用bc意味着调用b的结果是c

因此，您现在计算c以作为参数传递给b，然后计算bc以作为参数传递给a

---

这不是您想要的

调用abc意味着您使用bc的结果调用a

调用bc意味着调用b的结果是c

因此，您现在计算c以作为参数传递给b，然后计算bc以作为参数传递给a

---

这不是您想要的

关键概念是区分函数对象和调用。将函数作为参数传递如下所示：

 a(b(c))

function a() {}
function b() {}

...

a(b)

这相当于：

function a() {}

...

a(function() {...})

但是，当您说abc时，您并不是将函数传递给，而是调用bc的结果。这条线的等价物是：

let partialResult = b(c);
a(partialResult);

第一部分看起来很像我们已经看到的，用参数c调用b，这是一个函数。但是，您不会使用两个函数作为参数来调用a，而是使用计算结果bc

那么，为什么会这样呢

a(function(){  //work
  b(function(){
    c()
  })
})

因为这里你用一个函数作为参数调用a，这个函数既不是b也不是c，而是一个匿名函数，函数{…}，这是一个函数声明，不是调用，所以直到a这样说它才被执行

因此，a被执行，然后它运行它的回调，匿名函数，它用另一个匿名函数作为参数调用b。同样的重复。然后，当b完成时，它调用它的回调，wich然后调用c

该代码与此代码等效：

a(function() {
  b(c)
});

---

它转换为使用匿名函数作为回调执行。a完成后，运行它的回调函数，以c作为回调函数运行b。

关键概念是区分函数对象和调用。将函数作为参数传递如下所示：

 a(b(c))

function a() {}
function b() {}

...

a(b)

[1] typeof(c)    # Function

[2] b(c)         # works because, b expects a function and gets one.

[3] typeof(c())  # undefined

[4] b(c())       # Fails because c doesn't return a function.

[5] b(function(c())) # Works because b expects a function and gets one

[6] typeof(b(c)) # undefined

[7] a(b(c))      # => a(undefined) => error

[8] typeof(function(){c()}) # function

[8] a(function() {   # a expects a function and gets one
      b(function() { # b expects a function and gets one
        c()          
      })
    })

这相当于：

function a() {}

...

a(function() {...})

但是，当您说abc时，您并不是将函数传递给，而是调用bc的结果。这条线的等价物是：

let partialResult = b(c);
a(partialResult);

第一部分看起来很像我们已经看到的，用参数c调用b，这是一个函数。但是，您不会使用两个函数作为参数来调用a，而是使用计算结果bc

那么，为什么会这样呢

a(function(){  //work
  b(function(){
    c()
  })
})

因为这里你用一个函数作为参数调用a，这个函数既不是b也不是c，而是一个匿名函数，函数{…}，这是一个函数声明，不是调用，所以直到a这样说它才被执行

因此，a被执行，然后它运行它的回调，匿名函数，它用另一个匿名函数作为参数调用b。同样的重复。然后，当b完成时，它调用它的回调，wich然后调用c

该代码与此代码等效：

a(function() {
  b(c)
});

---

它转换为使用匿名函数作为回调执行。a完成后，运行其回调函数，该函数运行b，c作为回调函数。

谢谢：D。但后者是如何工作的？A函数{//work B函数{c}}谢谢：D.但是后者是如何工作的呢？函数{//work bfunction{c}}这里的最佳解决方案是使用承诺而不是回调。这里的最佳解决方案是使用承诺而不是回调。您想解释一下后者为什么有效吗？谢谢：D.affunction{//work bfunction{c}后者之所以有效，是因为每个函数都希望得到一个函数作为参数。在您的第一个示例中，情况并非如此，因为函数b被调用，并将返回一个非函数值，然后将该值传递给a。您想解释一下后一种方法的工作原理吗？谢谢：D.affunction{//work bfunction{c}后者之所以有效，是因为每个函数都希望得到一个函数作为参数。你的第一个例子不是这样的

[1] typeof(c)    # Function

[2] b(c)         # works because, b expects a function and gets one.

[3] typeof(c())  # undefined

[4] b(c())       # Fails because c doesn't return a function.

[5] b(function(c())) # Works because b expects a function and gets one

[6] typeof(b(c)) # undefined

[7] a(b(c))      # => a(undefined) => error

[8] typeof(function(){c()}) # function

[8] a(function() {   # a expects a function and gets one
      b(function() { # b expects a function and gets one
        c()          
      })
    })

函数b被调用后，将返回一个非函数值，然后将该值传递给