现实生活中的例子

这里有一个真实的例子，嗯，我自己的生活。

当我下午5点结束我的工作时，我的待办事项清单上有很多事情:

打电话给兽医要我的狗的检查结果。 遛狗。 处理我的税务问题。 洗碗。 回复私人邮件。 洗衣服。

当我打电话给兽医时，我接到了一个接待员的电话。接待员告诉我，我需要等待兽医，这样兽医就可以向我解释测试结果。接待员想让我等一下，直到兽医准备好。

你对此有什么反应?我知道我的工作多么低效!所以我向接待员提议，当兽医准备好谈话时，他让兽医给我回个电话。这样，我就不用等电话了，我可以做其他的事情。等兽医准备好了，我就可以把其他的事情暂时搁置，和她谈谈。

它和软件有什么关系

我是单螺纹的。我一次只能做一件事。如果我是多线程的，我将能够并行处理多个任务，但不幸的是，我不能这样做。

如果回调不是一个东西，当我遇到异步任务时，它会阻塞。如。当我打电话给兽医时，兽医需要大约15分钟来完成她正在做的事情，然后她才能和我说话。如果没有回调，我在这15分钟内就会被屏蔽。我就只能坐着等，而不能做其他的工作。

下面是没有回调的代码的样子:

function main() {
  callVet();
  // blocked for 15 minutes
  walkDog();
  doTaxes();
  doDishes();
  answerPeronalEmails();
  doLaundry();
}

现在用回调:

function main() {
  callVet(function vetCallback(vetOnThePhoneReadyToSpeakWithMe) {
    talkToVetAboutTestResults(vetOnThePhoneReadyToSpeakWithMe);
  });
  walkDog();
  doTaxes();
  doDishes();
  answerPeronalEmails();
  doLaundry();
}

更一般地说，当您处于单线程执行环境中，并且有某种异步任务时，您可以使用回调以更合乎逻辑的顺序执行事情，而不是让该任务阻塞您的单线程。

一个很好的例子是，如果您有一些前端代码需要发出ajax请求。如。如果您有一个显示用户信息的仪表板。下面是它如何在没有回调的情况下工作。用户将立即看到导航栏，但他们必须等待一段时间才能看到边栏和页脚，因为ajax请求getUser需要一段时间(作为经验法则，网络被认为是很慢的)。

function main() {
  displayNavbar();
  const user = getUser();
  // wait a few seconds for response...
  displayUserDashboard(user);
  displaySidebar();
  displayFooter();
}

现在用回调:

function main() {
  displayNavbar();
  getUser(function (user) {
    displayUserDashboard(user);
  });
  displaySidebar();
  displayFooter();
}

通过利用回调，我们现在可以在ajax请求的响应返回给我们之前显示边栏和页脚。这就好比我对接待员说:“我不想在电话上等15分钟。兽医准备好和我谈谈的时候给我回电话，与此同时，我会继续做我待办事项清单上的其他事情。”在现实生活中，你可能应该更优雅一些，但在编写软件时，你可以对CPU非常粗鲁。

假设你需要一个函数返回10的平方，那么你写一个函数:

function tenSquared() {return 10*10;}

之后你需要9的平方，所以你写了另一个函数:

function nineSquared() {return 9*9;}

最终你将用一个泛型函数替换所有这些:

function square(x) {return x*x;}

同样的想法也适用于回调。你有一个函数，它做一些事情，当完成时调用doA:

function computeA(){
    ...
    doA(result);
}

之后你想要完全相同的函数调用doB，而不是你可以复制整个函数:

function computeB(){
    ...
    doB(result);
}

或者你可以将回调函数作为变量传递，并且只需要使用该函数一次:

function compute(callback){
    ...
    callback(result);
}

然后你只需要调用compute(doA)和compute(doB)。

除了简化代码之外，它还让异步代码通过在完成时调用任意函数来让您知道它已经完成，这与打电话给某人并留下回调号码类似。

说白了，回调就是承诺。乔、简、大卫和萨曼莎拼车去上班。乔今天开车。简，大卫和萨曼莎有几个选择:

每五分钟查看一下窗户，看看乔是否出去了 继续做他们的事，直到乔按门铃。

选项1:这更像是一个轮询示例，Jane将被困在一个“循环”中，检查Joe是否在室外。在此期间简不能做其他事情。

选项2:这是回调示例。简告诉乔当他在外面时按她的门铃。她给了他一个按门铃的“功能”。Joe不需要知道门铃是如何工作的，也不需要知道它在哪里，他只需要调用那个函数，即当他在那里时按门铃。

回调是由“事件”驱动的。在这个例子中，“事件”是乔的到来。例如，在Ajax中，事件可以是异步请求的“成功”或“失败”，并且每个事件都可以有相同或不同的回调。

In terms of JavaScript applications and callbacks. We also need to understand "closures" and application context. What "this" refers to can easily confuse JavaScript developers. In this example within each person's "ring_the_door_bell()" method/callback there might be some other methods that each person need to do based on their morning routine ex. "turn_off_the_tv()". We would want "this" to refer to the "Jane" object or the "David" object so that each can setup whatever else they need done before Joe picks them up. This is where setting up the callback with Joe requires parodying the method so that "this" refers to the right object.

希望有帮助!

通常，我们将变量发送给函数:function1(var1, var2)。

假设，你想在它被作为参数给出之前处理它:

这是一种回调类型，其中function2执行一些代码并将变量返回给初始函数。

编辑:回调这个词最常见的意思是一个函数作为参数传递给另一个函数，并在稍后的时间点被调用。这些思想存在于允许高阶函数的语言中，即将函数视为一等公民，通常用于异步编程中。onready dosomething()。在这里，只有当它准备好了，事情才会发生。

这是关于下载网页的:

Your program runs on a cellphone and is requesting the webpage http://www.google.com. If you write your program synchronously, the function you write to download the data will be running continuously until all the data is download. This means your UI will not refresh and will basically appear frozen. If you write your program using callbacks, you request the data and say "execute this function when you've finished." This allows the UI to still allow user interaction while the file is downloading. Once the webpage has finished downloading, your result function (callback) is called and you can handle the data.

基本上，它允许你请求一些东西，并在等待结果的同时继续执行。一旦结果通过回调函数返回给您，您就可以从它停止的地方开始操作。

我要尽量让这个问题简单化。“回调”是由另一个以第一个函数为参数的函数调用的任何函数。很多时候，“回调”是在发生某些事情时调用的函数。在编程语言中，这可以被称为“事件”。

想象一下这样的场景:你几天后就会收到一个包裹。这个包裹是给邻居的礼物。因此，一旦你得到了包裹，你想把它带到邻居那里。你出城了，所以你给你的配偶留下了指示。

你可以让他们去拿包裹，然后送到邻居那里。如果你的配偶像电脑一样愚蠢，他们会坐在门口等包裹来(什么也不做)，然后一旦它来了，他们就会把它带到邻居那里。但是有一个更好的办法。告诉你的配偶，一旦他们收到包裹，他们应该把它带到邻居那里。然后，他们可以正常生活，直到他们收到包裹。

在我们的例子中，包的接收是“事件”，而把它带给邻居是“回调”。你的配偶“执行”你的指示，只有当包裹到达时才把包裹带过来。更好的!

这种思维在日常生活中很明显，但计算机没有这种常识。考虑程序员通常如何写入文件:

fileObject = open(file)
# now that we have WAITED for the file to open, we can write to it
fileObject.write("We are writing to the file.")
# now we can continue doing the other, totally unrelated things our program does

在这里，我们等待文件打开，然后再写入它。这“阻塞”了执行流，我们的程序不能做它可能需要做的任何其他事情!如果我们可以这样做:

# we pass writeToFile (A CALLBACK FUNCTION!) to the open function
fileObject = open(file, writeToFile)
# execution continues flowing -- we don't wait for the file to be opened
# ONCE the file is opened we write to it, but while we wait WE CAN DO OTHER THINGS!

事实证明，我们可以通过一些语言和框架来实现这一点。太酷了!查看Node.js来获得一些这种思考的实际实践。