Anonyme Callback-Funktion Klärung

Ich bin Bürsten bis auf callback-Funktionen, und bin dabei auf die folgende passage aus http://javascriptissexy.com/understand-javascript-callback-functions-and-use-them/#

"Wenn wir an eine callback-Funktion als argument an eine andere Funktion, wir sind nur vorbei die definition der Funktion. Wir sind nicht die Ausführung der Funktion im parameter. In anderen Worten, wir sind nicht vorbei die Funktion mit dem hinteren paar in der Ausführung von Klammern (), wie wir tun, wenn wir eine Funktion auszuführen.

Und da die die Funktion hat die callback-Funktion im parameter wie die definition einer Funktion, die es ausführen kann, wird die callback-jederzeit."

Kann sich das jemand erklären? Hier sind zwei Beispiele, die Sie zur Verfügung gestellt.

//The item is a callback function
$("#btn_1").click(function() {
  alert("Btn 1 Clicked");
});

Hier ist ein weiteres Beispiel:

var friends = ["Mike", "Stacy", "Andy", "Rick"];

friends.forEach(function (eachName, index){
console.log(index + 1 + ". " + eachName); //1. Mike, 2. Stacy, 3. Andy, 4. Rick
});

"Beachten Sie, dass die callback-Funktion nicht sofort ausgeführt wird. Es ist "zurück gerufen" (daher der name) an einen bestimmten Punkt innerhalb der die Funktion des Körpers. Also, auch wenn der erste jQuery-Beispiel sah so aus:

//The anonymous function is not being executed there in the parameter. 
//The item is a callback function
   $("#btn_1").click(function() {
     alert("Btn 1 Clicked");
   });

die anonyme Funktion aufgerufen wird, werden später innerhalb der Funktion Körper. Noch ohne Namen, es kann immer noch zugegriffen werden, die später über das arguments-Objekt von der mit-Funktion".

Für das erste Beispiel mit jquery, was Sie sagen, genau. Wenn die #btn_1 element geklickt wird, wird die anonyme Funktion ausgeführt werden? Ich gehe davon aus, dass es ausgeführt wird, wenn die Schaltfläche geklickt wird, aber die Formulierung aus der passage war verwirrend?

Ebenso für das zweite Beispiel, tun Sie nicht brauchen, um die Funktion aufzurufen, die Sie als argument übergeben bc seine anonym?

InformationsquelleAutor djfkdjfkd39939 | 2015-04-29

9

In beiden Beispielen, übergeben Sie eine anonyme Funktion als parameter.
```
$("#btn_1").click(function() {
  alert("Btn 1 Clicked");
});
```
jQuery-click-Methode nimmt eine Funktion als ersten parameter. So vorstellen, dass auf die Funktion definition ist diese:
```
function click(fn) {
    //fn will contain a reference to any 
    //function passed as the first parameter to click
    //merely calling fn does nothing, because you are just 'calling' 
    //the reference.
    fn;
    //Since what is inside of fn is a function, you can execute it 
    //with the () syntax
    fn();
}
//Now, you have many ways to pass a function as the first parameter to the function

//1. As an anonymous function:
click(function() {
    console.log("Hi");
});

//2. As a named function:
click(function hello() {
    console.log("Hi");
});

//3. As a reference to a function declaration
function hiThere() {
    console.log("Hi");
}
click(hiThere);

//4. As a variable that holds an anonymous function inside
var howdy = function () {
    console.log("howdy");
};
click(howdy);
```
Nur vorstellen, dass die Funktionen wie Variablen, aber Sie haben Inhalt, die ausgeführt werden können mit () am Ende.
```
function hi() {
    console.log('bye');
}

hi; //Calls the reference, but does not execute it. This does nothing.
hi.toString(); //Returns the function as a string
hi(); //Executes the code within the function
```
Wann deklarieren Sie eine benannte Funktion, die Sie tun können, Dinge nach Ihren Namen, wie Sie tun würden, mit Variablen. Natürlich, im Gegensatz zu Variablen, halten Sie ausführbaren code innen, und nicht von Werten.

Können Sie keine Referenz auf eine anonyme Funktion, denn es ist gut... anonym. , Es sei denn,, halten Sie es im inneren von etwas, das einen Namen hat, wie ein var.
```
var iHoldAFunctionInside = function () {
    console.log('Im not so anonymous now');
};
iHoldAFunctionInside(); //Logs "Im not so anonymous now"
```
Und das ist, warum übergeben Sie eine anonyme Funktion als parameter an eine Funktion, und Sie können ausführen es als Rückruf. Da der parameter nun 'hält' der anonymen Funktion innerhalb der it:
```
function iExecuteYourCallback(callback) {
    //callback contains the anonymous function passed to it
    //Similar to doing:
    //var callback = function () { };
    callback();
}
iExecuteYourCallback(function() {
    console.log('Im a callback function!');
});
```
Hoffe, das hilft, deaktivieren Sie die Dinge ein bit.

Das ist eine sehr schöne Zusammenfassung (ich kann nicht geben mehr scheinbar).
Ja, genau. Die iExecuteYourCallback - Funktion würde nichts tun. Es wäre einfach eine Funktion, die andere Funktion übergeben, jedoch nichts mit ihm, und stirbt so schnell, wie es eingegeben wurde. Aufruf der callback ist das, was ruft die callback (callback()). @FelixKling Haha, danke Recht sehr. (Oh, ich dachte, es war Absicht :p. Danke!)
Hmm, tja, es wird an die Funktion übergeben und die Funktion hat es als argument. Aber es passiert nichts mit Rückruf, bis Sie explizit ausführen es mit callback(). Die Funktion 'stirbt' sehr schnell, und nichts von Bedeutung erreicht in seiner sehr kurzen Lebensdauer.
Genau. Es wird nicht ausgeführt, da Sie nur es als parameter übergeben, aber die Funktion hat nix mit diesem parameter Sie übergeben.
Es ist im Grunde das gleiche, als wenn Sie deklariert eine Funktion als function foo() { console.log('foo'); }, aber nie rufen Sie foo(). Die Funktion existiert für einige Zeit, aber es tut nichts.

InformationsquelleAutor
2

In javascript-Funktionen sind first-class-Mitglieder übergeben Sie einer Funktion als parameter und die aufgerufene Funktion kann akzeptieren, es als ein benanntes argument.

Einem einfachen Beispiel kann, wie unten
```
function testme(callback) {
    //here the argument callback refers to the passed function

    //the timer is used just to delay the execution of the callback
    setTimeout(function () {
        //the passed function is called here
        callback();
    }, 1000)
}

testme(function () {
    alert('x')
})
```
Demo: Fiddle

In Ihre Beispiele, ja der erste Rückruf, der ausgeführt wird, sobald das element mit der id btn_1 geklickt wird.

Ok also in diesem Fall der bc die Funktion nicht anonym, Sie müssen explizit ausführen/aufrufen der Methode?
das ist der Fall bc
Wären Sie damit einverstanden, mit dem, was ich sagte (also bin ich dies richtig interpretieren?)...eine anonyme callback-excuted, ohne dass Sie explizit genannt/rief zurück, während eine benannte Funktion, die ein argument an eine andere Funktion muss explizit aufgerufen / angerufen?
Die Funktion wird aufgerufen mit callback(), ob es anonym ist oder nicht. Die Funktion erhält, dass der Rückruf nicht an, ob die Funktion anonym ist oder nicht. FYI, callbackFunction = function(){alert('x')} noch erzeugt eine anonyme Funktion, die Sie gerade Hinzugefügt haben ihn auf eine variable.
Es wird ausgeführt, wenn jemand Klicks auf das element. "Nirgends wird das Wesen genannt werden explizit" Auch der eigentliche Aufruf geschieht in irgendwo intern im browser. Theoretisch. In der Realität, jQuery nennen könnte. Sie können sich die source-code.

InformationsquelleAutor Arun P Johny

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.