Question

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

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

我如何在功能b中执行此操作？

function b(cb){
//I can't put function c here, because this of c is bound to somewhere and I don't want to mess up.
}

Answer 1

您可以使用Promises或回调。

在这种情况下，我会使用回调（因为它是一个简单的用例，并且承诺需要对浏览器进行检查）。

function A() {
    b(c); // Pass the function 'c'
}

function c() {
    // Do something else
}

function b(callback) {
    // Do something

    // Run callback
    callback(); // This will run whatever method you passed in
}

Answer 2

c()将始终在b()之后调用，因为您将其放在那里。

真正的问题是在c()完成之前是否会调用b()。

如果b() 不是异步功能，那么您的代码就完美了。 c()完成后将调用b()。

function A(){
    b(); // *not* async
    c();
}

但是，如果b()本质上是异步的，则需要提供c()作为回调。 function A（）{ 公元前）; //异步 }

function b(cb){
    // ...
    cb(); // cb() doesn't need "this"
}

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

function A(){
    /* extract and save context, somehow */
    b(c, context); // async
}

function b(cb, context){
    // ...
    cb.call(context); // cb() doesn't need "this"
}

我不想搞砸。

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

function A(){
    b().then(function() {
        // run "c()" only when "b()" is finished and there were no errors
        c();
    });
}

function b(){
    // ...
    // "b()" is *not* async
    return Promise.resolve();
}

function b(){
    // ...
    // "b()" is async
    var whenDone = new Promise(function(resolve, reject) {
        performAsyncTask(resolve);
    })
    return whenDone;
}

但等等，还有更多。

如果您想要前沿技术，您可以随时使用async/await

async function A(){
    await b(); // VOILA! it's that easy
    c();
}

这些是一般的基本策略。当然，您可以尝试将它们混合起来或尝试找出适合您需求的新东西。

Answer 3

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

function a(){
    b(c);
}

Answer 4

您的理解是正确的。回调的概念是函数完成的时候。您将要做的是确保输入类型并确保它是一个功能而不是不同的东西。看一下下面的例子：

＆＃13;

function A()
{
    alert('I am A function');
    b(c);
}

function b(cb)
{
    alert('I am "b" function');
    
    
    /// At the very end, put this code:    
    if (typeof(cb)==='function')
    {
         cb();
    }
}

function c()
{
    alert('I am "c" function');
}



A();

＆＃13;

Answer 5

JavaScript中的回调是作为参数传递给其他函数的函数。这是异步编程的一个非常重要的特性，它使得接收回调的函数在完成一个长任务时调用我们的代码，同时允许我们继续执行代码。

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

setTimeout(callback, 5000);

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

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

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");
});

这几乎是一个闭包，只需稍微调整一下就可以把它变成一个。

Answer 6

你的问题不是很清楚，让我试着破译。

如果你执行

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

如果按同步，c 之后将调用b。

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

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

然而在现代的js中，你宁愿使用诺言：

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

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

6 个答案: