多个函数之间的javascript回调混淆

函数c必须在函数b之后调用。 我知道JavaScript中有一个叫做回调的概念

如何在函数b中执行此操作

function A(){
   b()
   c()
}

您可以使用或回调

在本例中，我将使用回调（因为这是一个简单的用例&承诺需要交叉浏览器检查）

您可以使用或回调

在本例中，我将使用回调（因为这是一个简单的用例&承诺需要交叉浏览器检查）

---

你的理解是正确的。回调的概念是当函数完成时。你要做的是确保输入的类型，并确保它是一个函数，而不是不同的东西。请看以下示例：

函数A（）
{
警报（“我是一个函数”）；
b（c）；
}
职能b（cb）
{
警报（“我是“b”功能”）；
///最后，请输入以下代码：
if（类型（cb）=“功能”）
{
cb（）；
}
}
函数c（）
{
警报（“我是“c”功能”）；
}
A（）您的理解是正确的。回调的概念是当函数完成时。你要做的是确保输入的类型，并确保它是一个函数，而不是不同的东西。请看以下示例：


函数A（）
{
警报（“我是一个函数”）；
b（c）；
}
职能b（cb）
{
警报（“我是“b”功能”）；
///最后，请输入以下代码：
if（类型（cb）=“功能”）
{
cb（）；
}
}
函数c（）
{
警报（“我是“c”功能”）；
}
A（）JavaScript中的回调函数是作为参数传递给其他函数的函数。这是异步编程的一个非常重要的特性，它允许接收回调的函数在完成长任务时调用我们的代码，同时允许我们继续执行代码

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

function a(){
    b(c);
}

如您所见，setTimeout接收一个函数作为参数，这是一个回调

在您的情况下，您可以执行以下操作：

var callback = function() {
    console.log("Done!");
}

setTimeout(callback, 5000);

这几乎是一个闭包，只需稍微调整一下，您就可以将其转换为一个闭包。
JavaScript中的回调函数是作为参数传递给其他函数的函数。这是异步编程的一个非常重要的特性，它允许接收回调的函数在完成长任务时调用我们的代码，同时允许我们继续执行代码

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

function a(){
    b(c);
}

如您所见，setTimeout接收一个函数作为参数，这是一个回调

在您的情况下，您可以执行以下操作：

var callback = function() {
    console.log("Done!");
}

setTimeout(callback, 5000);

这几乎是一个结束，只要再稍微调整一下，你就可以把它变成一个结束。
你的问题不是很清楚，让我试着解释一下

如果你执行

function b(c) {
    c();
}

// calling function b and sending as a parameter an anonymous function
// that will be replaced by the "c" parameter in the "b" function
b(function() {
    console.log("inside c");
});

如果by是同步的，则将在
b
之后调用
c

如果b是异步的，则在
b
完成之前将调用
c
。
那么您确实需要一个回调作为
b
的参数：

function A() { b(); c() }
function b() { /* b work */ }
function c() { /* c work */}

但在现代js中，您更愿意使用承诺：

function A() { b(c) }
function b(callback) { /* b work */ ; callback() }
function c() { /* c work */ }

你的问题不太清楚，让我试着解释一下

如果你执行

function b(c) {
    c();
}

// calling function b and sending as a parameter an anonymous function
// that will be replaced by the "c" parameter in the "b" function
b(function() {
    console.log("inside c");
});

如果by是同步的，则将在
b
之后调用
c

如果b是异步的，则在
b
完成之前将调用
c
。
那么您确实需要一个回调作为
b
的参数：

function A() { b(); c() }
function b() { /* b work */ }
function c() { /* c work */}

但在现代js中，您更愿意使用承诺：

function A() { b(c) }
function b(callback) { /* b work */ ; callback() }
function c() { /* c work */ }

c（）
将始终在
b（）之后调用，因为您将其放置在那里

真正的问题是在
b（）
完成之前是否调用
c（）

function A() {
  b().then( function() {
    c()
  } )
}
function b() {
  return new Promise( function(resolve, reject) {
    /* b work */
  } )
}
function c() { /* c work */ }

如果
b（）
不是一个异步函数，那么您的代码就是完美的<一旦
b（）
完成，就会调用code>c（）

function A() {
  b().then( function() {
    c()
  } )
}
function b() {
  return new Promise( function(resolve, reject) {
    /* b work */
  } )
}
function c() { /* c work */ }

但是，如果
b（）
本质上是异步的，则需要提供
c（）
作为回调。
函数A（）{
b（c）；//异步
}

由于
c（）
是绑定方法，因此还需要将上下文（
this
）传递到
b（）

我不想把事情搞砸

如果不想使用上下文传递，可以使用

但是等等，还有更多

如果你想要尖端技术，你可以随时使用


这些是一般的基本策略。当然，你可以试着把它们混在一起，或者试着找出适合你需要的新东西。
c（）
总是在
b（）
之后调用，因为你把它放在那里了

真正的问题是在
b（）
完成之前是否调用
c（）

function A() {
  b().then( function() {
    c()
  } )
}
function b() {
  return new Promise( function(resolve, reject) {
    /* b work */
  } )
}
function c() { /* c work */ }

如果
b（）
不是一个异步函数，那么您的代码就是完美的<一旦
b（）
完成，就会调用code>c（）

function A() {
  b().then( function() {
    c()
  } )
}
function b() {
  return new Promise( function(resolve, reject) {
    /* b work */
  } )
}
function c() { /* c work */ }

但是，如果
b（）
本质上是异步的，则需要提供
c（）
作为回调。
函数A（）{
b（c）；//异步
}

由于
c（）
是绑定方法，因此还需要将上下文（
this
）传递到
b（）

我不想把事情搞砸

如果不想使用上下文传递，可以使用

但是等等，还有更多

如果你想要尖端技术，你可以随时使用


这些是一般的基本策略。当然，您可以尝试将它们混搭起来，或者尝试找出适合您需要的新功能。
woah异步函数非常优雅。woah异步函数非常优雅。尝试解释示例尝试解释示例