函数是第一类对象，这是javascript中的一个重要的概念，意味着函数可以像对象一样按照第一类管理被使用，所以在javascript中的函数：
能"存储"在变量中，能作为函数的实参被传递，能在函数中被创建，能从函数中返回
jquery中回调的设计
异步回调：
事件句柄回调：
$(document).ready(callback);
$(document).on('click',callback);
Ajax异步请求成功失败回调
$.ajax({
url:"",
context:document
}).done(function(){
//成功执行
}).fail(function(){
//失败执行
})；
动画执行完毕回调
$("#a").click(function(){
$("#b").animate({
left:'+=50',
opacity:0.25,
height:'toggle'
},5000,function(){
这里是回调
});
});
同步回调
一个同步(阻塞)中使用回调的例子，目的是在test代码执行完成后执行回调callback
var test1 = function(callback){
//执行长时间操作
callback();
}
test1(function(){
//执行回调中的方法
})；
所以理解回调函数最重要的2点：
1，一个回调函数作为参数传递给另一个函数时，我们仅仅传递了函数定义，我们并没有在参数中执行函数，我们并不传递我们平时执行函数一样带有一对执行小括号的函数。
2，回调函数并不会马上被执行，他会在包含它的函数内的某个特定的时间点被"回调"。
回调的运用
我们经常会这样使用函数回调：
时间触发通知，资源加载通知，定时器延时，ajax，动画通知等等。
例1:
jquery针对Dom的处理提供了append，prepend，before，after等方法的处理，这几个方法的特征：
1，参数的传递可以是html字符串，DOM元素，元素数组或者jquery对象。
2，为了优化性能针对节点的处理需要生成文档碎片。
高层接口
before:function(){
return this.domManip(arguments,function(elem){
if(this.parentNode){
this.parentNode.insertBefore(elem,this);
}
})
},
after:function(){
return this.domManip(arguments,function(elem){
if(this.parentNode){
this.partentNode.insertBefore(elem,this.nextSibling);
}
});
}
底层实现
domMainp:function(args,callback){
args = concat.apply([],args);
if(isFunction || self.doManip(args,callback));
if(l){
//生成文档碎片
fragment = jquery.buildFragment(args,this[0].ownerDocument,false,this);
callback.call(this[i],node,i);
}
return this;
}
例子2
function Aaron(List, callback) {
setTimeout(function() {
var task;
if (task = List.shift()) {
task(); //执行函数
}
if (List.length > 0) { //递归分解
arguments.callee(List)
} else {
callback()
}
}, 25)
}
//调用
Aaron([
function() {
alert('a')
},
function() {
alert('b')
},
function() {
alert('c')
}
], function() {
alert('callback')
})
// 分别弹出 ‘a’ , ‘b’ ,'c',’callback
传入一组函数参数，靠递归解析，分个执行，其实就时靠setTimeout可以把函数加入到队列末尾才执行的原理，聚合对象完全是一个整体，无法再次细分出来，所以我们需要一种方案，用来管理分离每一个独立的对象。
换成jquery提供的方式
var callbacks = $.Callbacks();
callbacks.add(function(){alert(1)}；)；
callbacks.add(function(){alert(2)}；)；
callbacks.fire();//1 2
模式的实际运用
$.ajax({
url:"",
context:document.body
}).done(function(data){
$("").html(data.a);
});
优化
$.ajax({
url:"",
context:document.body
}).done(function(data){
pocessData();
pocessHtml();
pocessOther();
});
function pocessData(){
//处理数据
}
function pocessHtml(){
$().html(data.a);
}
function pocessOther(){
//处理其他逻辑
}
优化的好处是 分离出各种的业务函数，从而降低了代码之间的耦合度， 但是这样代码写法达不到代码复用的作用
用观察者模式
Observable.add(function(){
//pocessdata
});
Observable.add(function(){
$().html(data.a);
})
Observable.add(function(){
//pocessOther
})
$.ajax({
url:"",
context:document.body
}).done(function(data){
Observable.fire(data);
})
jquery回调对象
jquery.Callbacks是在1.7版本后加入的，主要用来进行函数队列的add，remove，fire，lock等操作， 并提供once，momory，unique,stopOnFalse四个option进行一些特殊的控制
$.Callbacks是一个工厂函数，使用函数调用（非new,他不是一个类），他又一个可选参数flags用来设置回调函数的行为，对外的接口也就是self的返回。
callbacks.add()：回调列表中添加一个回调或回调的集合。
callbacks.disable():禁用回调列表中的回调
callbacks.disabled():确定回调列表是否已被禁用
callbacks.empty():从列表中删除所有的回调
callbacks.fire():用给定的参数调用所有的回调
callbacks.fired():访问给定的上下文和参数列表中的所有回调
callbacks.fireWith():访问给定的上下文和参数列表中的所有回调
callbacks.has():确定列表中是否提供一个回调
callbacks.lock():锁定当前状态的回调列表
callbacks.locked():确定回调列表是否已被锁定
callbacks.remove():从回调列表中的删除一个回调或回调集合。
源码结构
jQuery.Callbacks = function(options){
options = typeof options === "string" ? (optionsCache[options] || createOptions(options)): jQuery.extend({},option);
//实现代码
fire = function(){}
self = {
add : function(){},
remove : function(){},
has : function(){},
empty : function(){},
disable : funciton(){},
disabled : function(){},
lock:function(){},
locked:function(){},
fireWith:function(){},
fire:function(){}
};
return self;
};
整个结构要分为三个部分：options参数缓存，内部fire触发器的设计，外部。
参数的缓存设计：Callbacks是可以接受字符串的组合参数，可以使用空格分割
var opts = 'unique memory';
var object = {}
jQuery.each(opts.match(/S+/g) || [], function(_, flag) {
object[flag] = true;
});
这样的操作其实是不需要重复的，所以我们可以设计一个缓存池，用来储存重复的操作：
var optionsCache = {};
function createOptions(options) {
var object = optionsCache[options] = {};
jQuery.each(options.match(rnotwhite) || [], function(_, flag) {
object[flag] = true;
});
return object;
}
所以我们传递参数的时候，如果参数是字符串，我们可以直接从optionsCache缓存中去查找：
options = typeof options === "string" ?
( optionsCache[ options ] || createOptions( options ) ) :
jQuery.extend( {}, options );
默认回调对象设计
function Callbacks(){
var list = [];
var self;
self = {
add:function(fn){
list.push(fn);
},
fire:function(args){
list.foreach(function(fn){
fn(args);
})
}
}
return self;
}
once的设计
once的作用确保回调列表只执行（.fire()）一次（像一个递延Deferrend）
function fn1(val){
console.info(1);
}
var cbs = $.Callbacks("once");
cbs.add(fn1);
cbs.fire("foo");
cbs.fire("foo");
cbs只会执行一次，once定义是很明确的，确保这个回调列表只执行(.fire())一次，所以针对这种once的处理可以有多种不同的途径实现。
1，add的时候抛弃
2，在fire的时候抛弃多个
但是jquery是在执行第一个fire的时候直接给清空list列表了，然后在add的地方给判断下list是否存在，从而达到这样的处理。
function Callbacks(options){
var list = [];
var self;
self = {
add:function(){
list,push(fn);
},
fire:function(args){
if(list){
list.forEach(function(fn){
fn(args);
})
if(options === "once"){
list = undefined;
}
}
}
}
return self;
}
在fire之后，判断参数是否为once，直接把list给清理掉，所以之后的所有fire都被抛弃了，从而到达了once的效果。
jQuery.Callbacks的处理
在fire中调用了self.disable()方法
disable:function(){
list = stack = memory = undefined;
return this;
}
memory的设计
memory：保持以前的值，将添加到这个列表的后面的最新的值立即执行调用任何回调。
unique的设计
unique:确保一次只能添加一个回调
stopOnFalse
stopOnFalse:当一个回调返回false时中断调用。