回调函数的二三事

坐在椅子上睡着了，烦来刷知乎看到关于回调函数的讨论，有点豁然开朗的感觉，总结出来做个备份。
     明确一点：调用者提供函数指针名称和参数列表，由实现者完成内部的算法或逻辑过程。实现者只需要将这个函数注册一下（与调用者的联系接口），实现者是不负责函数的调用过程，也无法控制函数的调用。
引用的链接，源自知乎http://www.zhihu.com/question/19801131，桥头堡大神
    举个栗子，
    下面这段Python写成的回调的简单示例：命名为图1.

   

    

                                        图1 
在起始函数中调用getOddNumber()函数，getOddNumber()不知道getEvenNumber()是什么，返回去调用double()和quadruple()两函数，这种行为就是callback，double()和quadruple()就是callback function。

 

                        图2

可以看到，回调函数通常和应用处于同一抽象层（因为传入什么样的回调函数是在应用级别决定的）。而回调就成了一个高层调用底层，底层再回过头来调用高层的过程。（我认为）这应该是回调最早的应用之处，也是其得名如此的原因。

回调机制的优势

从上面的例子可以看出，回调机制提供了非常大的灵活性。请注意，从现在开始，我们把图2中的库函数改称为中间函数了，这是因为回调并不仅仅用在应用和库之间。任何时候，只要想获得类似于上面情况的灵活性，都可以利用回调。

这种灵活性是怎么实现的呢？乍看起来，回调似乎只是函数间的调用，但仔细一琢磨，可以发现两者之间的一个关键的不同：在回调中，我们利用某种方式，把回调函数像参数一样传入中间函数。可以这么理解，在传入一个回调函数之前，中间函数是不完整的。换句话说，程序可以在运行时，通过登记不同的回调函数，来决定、改变中间函数的行为。这就比简单的函数调用要灵活太多了。 
易被忽略的第三方

通过上面的论述可知，中间函数和回调函数是回调的两个必要部分，不过人们往往忽略了回调里的第三位要角，就是中间函数的调用者。绝大多数情况下，这个调用者可以和程序的主函数等同起来，但为了表示区别，我这里把它称为起始函数（如上面的代码中注释所示）。

之所以特意强调这个第三方，是因为我在网上读相关文章时得到一种印象，很多人把它简单地理解为两个个体之间的来回调用。譬如，很多中文网页在解释“回调”（callback）时，都会提到这么一句话：“If you call me, I will call you back.”我没有查到这句英文的出处。我个人揣测，很多人把起始函数和回调函数看作为一体，大概有两个原因：第一，可能是“回调”这一名字的误导；第二，给中间函数传入什么样的回调函数，是在起始函数里决定的。实际上，回调并不是“你我”两方的互动，而是ABC的三方联动。有了这个清楚的概念，在自己的代码里实现回调时才不容易混淆出错。

另外，回调实际上有两种：阻塞式回调和延迟式回调。两者的区别在于：阻塞式回调里，回调函数的调用一定发生在起始函数返回之前；而延迟式回调里，回调函数的调用有可能是在起始函数返回之后。这里不打算对这两个概率做更深入的讨论，之所以把它们提出来，也是为了说明强调起始函数的重要性。网上的很多文章，提到这两个概念时，只是笼统地说阻塞式回调发生在主调函数返回之前，却没有明确这个主调函数到底是起始函数还是中间函数，不免让人糊涂，所以这里特意说明一下。另外还请注意，本文中所举的示例均为阻塞式回调。延迟式回调通常牵扯到多线程，我自己还没有完全搞明白，所以这里就不多说了。 

引用的链接，源自知乎http://www.zhihu.com/question/19801131，黄姓大神
    首先说明几个概念：
    1.第一类值： 有些语言确实是不区分的，它的function(表示code)跟int, double的地位是一样的。这种语言称为函数是第一类值。
    2.有些语言是不能存储函数，不能动态创建函数，不能动态销毁函数。(这里函数是已经是广义的了，用来表示代码code)。只能存储一个指向函数的指针，这种语言称为函数是第二类值。
    另外有些语言不单可以传递函数，函数里面又用到一些外部信息(包括code, data)。那些语言可以将函数跟函数所用到的信息一起传递存储。这种将函数和它所用的信息作为一个整体，就为闭包。(闭包的概念我第一次是在编译器中遇到的，A*=｛NULL,A,AA,AAA....｝，个人觉得这两个不是一个概念，函数与信息的闭包更像一个集合)。
    3. Data和code是不做区分的，统称为信息。看这篇文章前，我一直把code与data区分开，犯了大错。
   这个是程序上的概念。
  本质上是叫别人做事，传进去的额外信息。
   比如，A叫B做事，根据粒度不同，可以理解成A函数调用B函数，或者A类使用B类，或者A组件使用B组件等等。反正就是A叫B做事。
   当B做这件事情的时候，自身的需要的信息不够，而A又有。就需要A从外面传进来，或者B做着做着主动向外面申请。对于B来说，一种被动得到信息，一种是主动去得到信息，有人给这两种方式术语，叫信息的push，和信息的pull。
接着，A调用B，A向B传参数。int max(int a, int b); 要使用这函数max, 得到两者最大的值, 外面就要传进来a, b。这个好理解。
    代码(code)和数据(data)的统一，这是一个槛，如果不打通这个，很多概念就不清楚。我们常常说计算机程序分成code和data两部分。很多人就会觉得，code是会运行的，是动的，data是给code使用，是静态的，这是两种完全不同的东西。

    其实code只是对行为的一种描述，比如有个机器人可以开灯，关灯，扫地。跟着我要机器人开灯，扫地，关灯。如果跟机器人约定好，0表示开灯，1表示关灯，2表示扫地。我发出指令，0 1 2 1 0。跟着就可以控制机器人开灯，扫地，关灯。再约定用二进制表示，两位一个指令，就有一个数字串，0001110100，这个时候0001110100这串数字就描述了机器人的一系列动作，这个就是从一方面理解是code，可以它可以控制机器人的行为。但另一方面，它可以传递，可以记录，可以修改，也就是数据。只要大家都协商好，code就可以编码成data, 将data解释运行的时候，也变成了code。
   再次声明，将代码和数据打通，统一起来，是一个槛。过了这个槛，很多难以理解的概念就会清晰很多。比如一些修改自身的程序啊，数据驱动啊，先设计数据再写程序等等。 
   来到这里，其实已经没有什么好说的了。回调函数也就是是A让B做事，B做着做着，信息不够，不知道怎么做了，就再让外面处理。
   比如排序，A让B排序，B会做排序，但排序需要知道哪个比哪个大，这点B自己不知道，就需要A告诉它。而这种判断那个大，本身是一种动作，既然C语言中不可以传进第一值的函数，就设计成传递第二值的函数指针，这个函数指针就是A传向B的信息，用来表示一个行为。这里本来A调用B的，结果B又调用了A告诉它的信息，也就叫callback。
    再比如A让B监听系统的某个消息，比如敲了哪个键。跟着B监听到了，但它不知道怎么去处理这个消息，就给外面关心这个消息，又知道怎么去处理这个消息的人去处理，这个处理过程本事是个行为，既然这个语言不可以传递函数，又只能传一个函数指针了。跟着有些人有会引申成，什么注册啊，通知啊等等等。假如B做监听，C, D, E, F, G, H告诉B自己有兴趣知道这消息，那B监听到了就去告诉C,D,E,F,G等人了，这样通知多人了，就叫广播。
    其实你理解了，根本不用去关心术语的。术语是别人要告诉你啊，或者你去告诉人啊，使用的一套约定的词语。本质上就个东西，结果会有很多术语的。
    跟着再将回调的概念进化，比如某人同时关心A,B,C,D,E,F事件，并且这些事件是一组的，比如敲键盘，鼠标移动，鼠标点击等一组。将一组事件结合起来。在有些语言就变成一个接口，接口有N个函数。有些语言就映射成一个结构，里面放着N个函数指针。跟着就不是将单个函数指针传进去，而是将接口，或者函数指针的结构传进去。这些根据不同的用途，有些人叫它为代理啊，监听者啊，观察者啊等等。  



看了太多术语，下面是stackflow排名第一的回答放松以下http://stackoverflow.com/questions/9596276/how-to-explain-callbacks-in-plain-english-how-are-they-different-from-calling-o/9652434#9652434

I am going to try to keep this dead simple. A "callback" is any function that is called by another function which takes the first function as a parameter. A lot of the time, a "callback" is a function that is called when something happens. That something can be called an "event" in programmer-speak.

Imagine this scenario: You are expecting a package in a couple of days. The package is a gift for your neighbor. Therefore, once you get the package, you want it brought over the the neighbors. You are out of town, and so you leave instructions for your spouse.

You could tell her to get the package and bring it to the neighbors. If your spouse was as stupid as a computer, she would sit at the door and wait for the package until it came (NOT DOING ANYTHING ELSE) and then once it came she would bring it over to the neighbors. But there's a better way. Tell your wife that ONCE she receives the package, she should bring it over the neighbors. Then, she can go about life normally UNTIL she receives the package.

In our example, the receiving of the package is the "event" and the bringing it to the neighbors is the "callback". Your wife "runs" your instructions to bring the package over only when the package arrives. Much better!

This kind of thinking is obvious in daily life, but computers don't have the same kind of common sense. Consider how programmers normally write to a file:

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

Here, we WAIT for the file to open, before we write to it. This "blocks" the flow of execution, and our program cannot do any of the other things it might need to do! What if we could do this instead:

# we pass writeToFile (A CALLBACK FUNCTION!) to the open functionfileObject = 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!

It turns out we do this with some languages and frameworks. It's pretty cool! Check out Node.js to get some real practice with this kind of thinking.


用途：http://zh.wikipedia.org/wiki/%E5%9B%9E%E8%B0%83%E5%87%BD%E6%95%B0
回调的用途十分广泛。例如，假设有一个函数，其功能为读取配置文件并由文件内容设置对应的选项。若这些选项由散列值所标记，则让这个函数接受一个回调会使得程序设计更加灵活：函数的调用者可以使用所希望的散列算法，该算法由一个将选项名转变为散列值的回调函数实现；因此，回调允许函数调用者在运行时调整原始函数的行为。

回调的另一种用途在于处理信号或者类似物。例如一个POSIX程序可能在收到SIGTERM信号时不愿立即终止；为了保证一切运行良好，该程序可以将清理函数注册为SIGTERM信号对应的回调。

回调亦可以用于控制一个函数是否作为：Xlib允许自定义的谓词用于决定程序是否希望处理特定的事件。 

下列C语言代码描述了利用回调处理POSIX风格的信号（在本示例中为SIGUSR1）的过程。值得注意的是，在处理信号的过程中，调用printf(3)是不安全的。
 

系统调用pause(3)会导致这个例子不做任何有意义的事，但这样做可以给你充分的时间来给这个进程发送信号。（在类Unix系统上，可以调用kill -USR1 <pid>，其中<pid>代表该程序的进程号。运行之后，该程序应当会有反应。）

注意，如果利用循环代替pause()会导致CPU占用率攀升到100%。 

实现[编辑]

回调的形式因程序设计语言的不同而不同。

• C、C++和Pascal允许将函数指针作为参数传递给其它函数。其它语言，例如JavaScript，Python，Perl[1][2]和PHP，允许简单的将函数名作为参数传递。

• Objective-C中允许利用@selector关键字传递SEL类型的函数名。在实现中，SEL类型被定义为函数名字符串。

• 在类似于C#与VB.NET的运用.NET Framework的语言中，提供了一种型别安全的引用封装，所谓的'委托'，用来定义包含类型的函数指针，可以用于实现回调。

• .NET语言中用到的事件与事件处理函数提供了用于回调的通用语法。

• 函数式编程语言通常支持第一级函数，可以作为回调传递给其它函数，也可以作为数据类型存储或是返回给其它函数。

• 某些语言，比如Algol 68，Perl，新版本的.NET语言以及多数函数式编程语言中，允许使用匿名的代码块（lambda表达式），用以代替在别处定义的独立的回调函数。

• 在Apple或是LLVM的C语言扩展中，包含称为块的语言特性，可以作为函数的参数传递，作为回调的一种实现。

• 在缺少函数类型的参数的面向对象的程序语言中，例如Java，回调可以用传递抽象类或接口来模拟。回调的接收者会调用抽象类或接口的方法，这些方法由调用者提供实现。这样的对象通常是一些回调函数的集合，同时可能包含它所需要的数据。这种方法在实现某些设计模式时比较有用，例如访问者模式，观察者模式与策略模式。

• C++允许对象提供其自己的函数调用操作的实现，即重载operator()。标准模板库和函数指针一样接受这类对象（称为函数对象）作为各种算法的参数。

 最后一句，其实我们有在用callback只是不知道而已。只在此深山，云深不知处。下班！