javascript baixar html - Crie um retorno de chamada personalizado em JavaScript




5 Answers

Na verdade, seu código funcionará como está, apenas declare seu retorno de chamada como um argumento e você poderá chamá-lo diretamente usando o nome do argumento.

O básico

function doSomething(callback) {
    // ...

    // Call the callback
    callback('stuff', 'goes', 'here');
}

function foo(a, b, c) {
    // I'm the callback
    alert(a + " " + b + " " + c);
}

doSomething(foo);

Isso chamará o doSomething , que chamará o foo , que alertará "o que acontece aqui".

Note que é muito importante passar a referência de função ( foo ), em vez de chamar a função e passar seu resultado ( foo() ). Na sua pergunta, você faz isso corretamente, mas vale a pena apontar porque é um erro comum.

Coisas mais avançadas

Às vezes, você quer chamar o retorno de chamada para ver um valor específico para this . Você pode facilmente fazer isso com a função de call JavaScript:

function Thing(name) {
    this.name = name;
}
Thing.prototype.doSomething = function(callback) {
    // Call our callback, but using our own instance as the context
    callback.call(this);
}

function foo() {
    alert(this.name);
}

var t = new Thing('Joe');
t.doSomething(foo);  // Alerts "Joe" via `foo`

Você também pode passar argumentos:

function Thing(name) {
    this.name = name;
}
Thing.prototype.doSomething = function(callback, salutation) {
    // Call our callback, but using our own instance as the context
    callback.call(this, salutation);
}

function foo(salutation) {
    alert(salutation + " " + this.name);
}

var t = new Thing('Joe');
t.doSomething(foo, 'Hi');  // Alerts "Hi Joe" via `foo`

Às vezes, é útil passar os argumentos que você deseja dar ao retorno de chamada como uma matriz, em vez de individualmente. Você pode usar apply para fazer isso:

function Thing(name) {
    this.name = name;
}
Thing.prototype.doSomething = function(callback) {
    // Call our callback, but using our own instance as the context
    callback.apply(this, ['Hi', 3, 2, 1]);
}

function foo(salutation, three, two, one) {
    alert(salutation + " " + this.name + " - " + three + " " + two + " " + one);
}

var t = new Thing('Joe');
t.doSomething(foo);  // Alerts "Hi Joe - 3 2 1" via `foo`
curso download

Tudo o que preciso fazer é executar uma função de retorno de chamada quando a execução da função atual terminar.

function LoadData() 
{
    alert('The data has been loaded');
    //Call my callback with parameters. For example,
    //callback(loadedData , currentObject);
}

Um consumidor para esta função deve ser assim:

object.LoadData(success);

function success(loadedData , currentObject) 
{
  //Todo: some action here 
}

Como faço para implementar isso?




Meus 2 cêntimos Mesmo mas diferente ...

<script>
    dosomething("blaha", function(){
        alert("Yay just like jQuery callbacks!");
    });


    function dosomething(damsg, callback){
        alert(damsg);
        if(typeof callback == "function") 
        callback();
    }
</script>



   function callback(e){
      return e;
   }
    var MyClass = {
       method: function(args, callback){
          console.log(args);
          if(typeof callback == "function")
          callback();
       }    
    }

==============================================

MyClass.method("hello",function(){
    console.log("world !");
});

==============================================

Resultado é:

hello world !



function LoadData(callback) 
{
    alert('the data have been loaded');
    callback(loadedData, currentObject);
}



Experimentar:

function LoadData (callback)
{
    // ... Process whatever data
    callback (loadedData, currentObject);
}

Funções são de primeira classe em JavaScript ; você pode simplesmente passá-los.




Related


Tags

javascript