Sagen Sie mir, was die Rückruffunktion von Javascript ist_Grundkenntnisse

　Funktionen sind auch Objekte

Wenn Sie die Rückruffunktion verstehen möchten, müssen Sie zunächst die Regeln der Funktion klar verstehen. In JavaScript sind Funktionen seltsam, aber sie sind tatsächlich Objekte. Genauer gesagt ist eine Funktion ein Funktionsobjekt, das mit dem Function()-Konstruktor erstellt wurde. Das Function-Objekt enthält eine Zeichenfolge, die den JavaScript-Code der Funktion enthält. Wenn Sie von C oder Java kommen, mag das seltsam erscheinen. Wie kann der Code eine Zeichenfolge sein? Bei Javascript ist dies jedoch an der Tagesordnung. Die Unterscheidung zwischen Daten und Code ist fließend.

//可以这样创建函数
var fn = new Function("arg1", "arg2", "return arg1 * arg2;");
fn(2, 3); //6 

Ein Vorteil dieser Vorgehensweise besteht darin, dass Sie Code an andere Funktionen oder reguläre Variablen oder Objekte übergeben können (da Code buchstäblich nur ein Objekt ist).

　Funktion als Rückruf übergeben

Es ist einfach, eine Funktion als Parameter zu übergeben.

function fn(arg1, arg2, callback){
 var num = Math.ceil(Math.random() * (arg1 - arg2) + arg2);
 callback(num);　　//传递结果
}

fn(10, 20, function(num){
 console.log("Callback called! Num: " + num); 
});　　　　//结果为10和20之间的随机数 

Vielleicht erscheint das umständlich oder sogar etwas dumm. Warum geben Sie die Ergebnisse nicht normal zurück? Aber wenn Sie eine Rückruffunktion verwenden müssen, denken Sie vielleicht nicht daran!

Gehen Sie uns aus dem Weg

Herkömmliche Funktionen geben Daten in Form von Parametern ein und verwenden Rückgabeanweisungen, um Werte zurückzugeben. Theoretisch gibt es am Ende der Funktion eine Return-Anweisung, die strukturell aus einem Eingabepunkt und einem Ausgabepunkt besteht. Dies ist einfacher zu verstehen. Eine Funktion ist im Wesentlichen eine Abbildung des Implementierungsprozesses zwischen Eingabe und Ausgabe.

Wenn der Funktionsimplementierungsprozess jedoch sehr lang ist, möchten Sie dann warten, bis die Funktion die Verarbeitung abgeschlossen hat, oder eine Rückruffunktion für die asynchrone Verarbeitung verwenden? In diesem Fall ist es wichtig, Callback-Funktionen zu verwenden, zum Beispiel: AJAX-Anfragen. Wenn Sie zur Verarbeitung eine Callback-Funktion verwenden, kann der Code weiterhin andere Aufgaben ausführen, ohne vergeblich warten zu müssen. In der tatsächlichen Entwicklung werden in JavaScript häufig asynchrone Aufrufe verwendet, und dies wird hier sogar dringend empfohlen!

Nachfolgend finden Sie ein umfassenderes Beispiel für die Verwendung von AJAX zum Laden einer XML-Datei und die Verwendung der Funktion call() zum Aufrufen der Rückruffunktion im Kontext des angeforderten Objekts.

function fn(url, callback){
 var httpRequest;　　　　//创建XHR
 httpRequest = window.XMLHttpRequest ? new XMLHttpRequest() :　　　//针对IE进行功能性检测
　　　　window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : undefined;
 
 httpRequest.onreadystatechange = function(){
  if(httpRequest.readystate === 4 && httpRequest.status === 200){　　//状态判断
   callback.call(httpRequest.responseXML); 
  }
 };
 httpRequest.open("GET", url);
 httpRequest.send();
}

fn("text.xml", function(){　　　　//调用函数
 console.log(this); 　　//此语句后输出
});

console.log("this will run before the above callback.");　　//此语句先输出 

Wir fordern eine asynchrone Verarbeitung an. Das heißt, wenn wir die Anfrage starten, weisen wir sie an, unsere Funktion aufzurufen, wenn sie abgeschlossen ist. In tatsächlichen Situationen muss der Ereignishandler onreadystatechange auch die Situation eines Anforderungsfehlers berücksichtigen. Hier gehen wir davon aus, dass die XML-Datei vorhanden ist und vom Browser erfolgreich geladen werden kann. In diesem Beispiel ist die asynchrone Funktion dem Ereignis onreadystatechange zugewiesen und wird daher nicht sofort ausgeführt.

Schließlich wird die zweite console.log-Anweisung zuerst ausgeführt, da die Rückruffunktion erst ausgeführt wird, wenn die Anforderung abgeschlossen ist.

Das obige Beispiel ist nicht leicht zu verstehen, schauen Sie sich also das folgende Beispiel an:

 
function foo(){
 var a = 10;
 return function(){
  a *= 2;
  return a;  
 }; 
}
var f = foo();
f(); //return 20.
f(); //return 40. 

　　函数在外部调用，依然可以访问变量a。这都是因为javascript中的作用域是词法性的。函数式运行在定义它们的作用域中（上述例子中的foo内部的作用域），而不是运行此函数的作用域中。只要f被定义在foo中，它就可以访问foo中定义的所有的变量，即便是foo的执行已经结束。因为它的作用域会被保存下来，但也只有返回的那个函数才可以访问这个保存下来的作用域。返回一个内嵌匿名函数是创建闭包最常用的手段。

回调是什么？

看维基的 Callback_(computer_programming) 条目:

In computer programming, a callback is a reference to a piece of executable code that is passed as an argument to other code.

jQuery文档How jQuery Works#Callback_and_Functio...条目：

A callback is a function that is passed as an argument to another function and is executed after its parent function has completed. The special thing about a callback is that functions that appear after the "parent" can execute before the callback executes. Another important thing to know is how to properly pass the callback. This is where I have often forgotten the proper syntax.

百科：回调函数

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

因此，回调本质上是一种设计模式，并且jQuery(包括其他框架)的设计原则遵循了这个模式。

在JavaScript中，回调函数具体的定义为：函数A作为参数(函数引用)传递到另一个函数B中，并且这个函数B执行函数A。我们就说函数A叫做回调函数。如果没有名称(函数表达式)，就叫做匿名回调函数。

因此callback 不一定用于异步，一般同步(阻塞)的场景下也经常用到回调，比如要求执行某些操作后执行回调函数。

例子
一个同步(阻塞)中使用回调的例子，目的是在func1代码执行完成后执行func2。

var func1=function(callback){
  //do something.
  (callback && typeof(callback) === "function") && callback();
}

func1(func2);
  var func2=function(){
}

异步回调的例子：

$(document).ready(callback);

$.ajax({
 url: "test.html",
 context: document.body
}).done(function() { 
 $(this).addClass("done");
}).fail(function() { alert("error");
}).always(function() { alert("complete"); 
});
/**
注意的是，ajax请求确实是异步的,不过这请求是由浏览器新开一个线程请求,当请求的状态变更时,如果先前已设置回调,这异步线程就产生状态变更事件放到 JavaScript引擎的处理队列中等待处理。*/

回调什么时候执行

回调函数，一般在同步情境下是最后执行的，而在异步情境下有可能不执行，因为事件没有被触发或者条件不满足。

回调函数的使用场合

资源加载：动态加载js文件后执行回调，加载iframe后执行回调，ajax操作回调，图片加载完成执行回调，AJAX等等。
DOM事件及Node.js事件基于回调机制(Node.js回调可能会出现多层回调嵌套的问题)。

setTimeout的延迟时间为0，这个hack经常被用到，settimeout调用的函数其实就是一个callback的体现

链式调用：链式调用的时候，在赋值器(setter)方法中(或者本身没有返回值的方法中)很容易实现链式调用，而取值器(getter)相对来说不好实现链式调用，因为你需要取值器返回你需要的数据而不是this指针，如果要实现链式方法，可以用回调函数来实现setTimeout、setInterval的函数调用得到其返回值。由于两个函数都是异步的，即：他们的调用时序和程序的主流程是相对独立的，所以没有办法在主体里面等待它们的返回值，它们被打开的时候程序也不会停下来等待，否则也就失去了setTimeout及setInterval的意义了，所以用return已经没有意义，只能使用callback。callback的意义在于将timer执行的结果通知给代理函数进行及时处理。

回调函数的传递

上面说了，要将函数引用或者函数表达式作为参数传递。

$.get('myhtmlpage.html', myCallBack);//这是对的
$.get('myhtmlpage.html', myCallBack('foo', 'bar'));//这是错的，那么要带参数呢？
$.get('myhtmlpage.html', function(){//带参数的使用函数表达式
myCallBack('foo', 'bar');
});

另外，最好保证回调存在且必须是函数引用或者函数表达式：
(callback && typeof(callback) === "function") && callback();