JavaScript'te geri arama işlevlerini daha iyi anlama

Bir işlevi geri arama olarak başka bir işleve geçirmeyi ve çalıştırmasını anlıyorum, ancak bunu yapmak için en iyi uygulamayı anlamıyorum. Bunun gibi çok temel bir örnek arıyorum:

var myCallBackExample = {
    myFirstFunction : function( param1, param2, callback ) {
        // Do something with param1 and param2.
        if ( arguments.length == 3 ) {
            // Execute callback function.
            // What is the "best" way to do this?
        }
    },
    mySecondFunction : function() {
        myFirstFunction( false, true, function() {
            // When this anonymous function is called, execute it.
        });
    }
};

MyFirstFunction içinde, yeni geri arama () döndürürsem, o zaman çalışır ve anonim işlevi yürütür, ama bu bana doğru bir yaklaşım gibi görünmüyor.

Sadece söyleyebilirsin

callback();

Alternatif olarak , geri arama içindeki calldeğerini ayarlamak isterseniz yöntemi kullanabilirsiniz this.

callback.call( newValueForThis);

Fonksiyonun thisiçinde ne varsa olurdu newValueForThis.

Geri aramanın var olup olmadığını ve yürütülebilir bir işlev olup olmadığını kontrol etmelisiniz:

if (callback && typeof(callback) === "function") {
    // execute the callback, passing parameters as necessary
    callback();
}

Pek çok kütüphane (jQuery, dojo, vb.), Eşzamansız işlevleri için benzer bir desen ve tüm eşzamansız işlevler için node.js kullanır (düğümler genellikle geçer errorve datageri aramaya ). Kaynak kodlarına bakmak yardımcı olacaktır!

Bir işlevi yerine getirmek için 3 ana olasılık vardır:

var callback = function(x, y) {
    // "this" may be different depending how you call the function
    alert(this);
};

1. geri arama (bağımsız değişken_1, bağımsız değişken_2);
2. callback.call (some_object, argüman_1, argüman_2);
3. callback.apply (some_object, [argument_1, argument_2]);

Seçtiğiniz yöntem şunlara bağlıdır:

1. Array öğesinde veya bağımsız değişkenler olarak depolanan bağımsız değişkenlere sahipsiniz.
2. Bu işlevi bir nesne bağlamında çağırmak istiyorsunuz. Bu durumda, bu geri çağrıda "this" anahtar sözcüğünü kullanmak, call () öğesinde argüman olarak iletilen nesneye veya Apply () öğesine başvuruda bulunur. Nesne içeriğini geçirmek istemiyorsanız, null veya undefined kullanın. İkinci durumda, global nesne "bu" için kullanılır.

Function.call , Function.apply için Dokümanlar

Geri aramalar sinyallerle ilgilidir ve "yeni" nesne örnekleri oluşturmakla ilgilidir.

Bu durumda, sadece "callback ();" "return new callback ()" yerine, geri dönüş değeri olan hiçbir şey yapmıyorsunuz.

(Ve arguments.length == 3 testi gerçekten tıknaz, fwiw, geri arama parametresinin var olduğunu ve bir işlev olduğunu kontrol etmek daha iyidir.)

uygun uygulama:

if( callback ) callback();

bu geri arama parametresini isteğe bağlı yapar.

Kullanabilirsiniz:

if (callback && typeof(callback) === "function") {
    callback();
}

Aşağıdaki örnek biraz daha kapsamlıdır:

function mySandwich(param1, param2, callback) {
  alert('Started eating my sandwich.\n\nIt has: ' + param1 + ', ' + param2);
  var sandwich = {
      toppings: [param1, param2]
    },
    madeCorrectly = (typeof(param1) === "string" && typeof(param2) === "string") ? true : false;
  if (callback && typeof(callback) === "function") {
    callback.apply(sandwich, [madeCorrectly]);
  }
}

mySandwich('ham', 'cheese', function(correct) {
  if (correct) {
    alert("Finished eating my " + this.toppings[0] + " and " + this.toppings[1] + " sandwich.");
  } else {
    alert("Gross!  Why would I eat a " + this.toppings[0] + " and " + this.toppings[1] + " sandwich?");
  }
});

callback()JavaScript'teki işlevi açıklayan temel bir örnek :

var x = 0;

function testCallBack(param1, param2, callback) {
  alert('param1= ' + param1 + ', param2= ' + param2 + ' X=' + x);
  if (callback && typeof(callback) === "function") {
    x += 1;
    alert("Calla Back x= " + x);
    x += 1;
    callback();
  }
}

testCallBack('ham', 'cheese', function() {
  alert("Function X= " + x);
});

JSFiddle