jQuery（）回调函数。回调队列使用详解

本文给出了jQuery的一个例子。回调（）回调函数队列使用。分享给你供你参考，如下：

1、jQuery。回调

jQuery（）函数。回调，在1.7版中引入的，返回一个多用途的对象，对象，功能，在，

美元的回调函数，（）内用于提供基本功能，，系统的第二部分。

接下来，我们来看四个标准控制标志。

1.1一次

创建回调对象只能用一次（）{注：火（）方法是用外观模式（）}。
var =美元回调。回调（曾经）；
Callbacks.add（function（）{ console.log（F1）；}）；
Callbacks.fire（F1）； / /输出
（回调。火）； / /没有发生的事，源已被禁用（禁用名单。）

1.2记忆

在调用add（）方法，如果回调满足发射发射=假（队列执行内存（真）中指定的构造函数，所以需要）（添加）的回调函数将被立即执行，并调用回调函数的参数存储在内存变量的内存变量是用来存储{上下文参数，参数}，用最后一次通话时称为callbacks.firewith（…）。

如果回调对象是，记忆，创造的旗帜，为记忆。
$（函数（$）{）
var =美元回调。回调（记忆）；
Callbacks.add（function（）{ console.log（F1）；}）；
callbacks.fire（F1）； / /输出，那么函数列表已经完成！
Callbacks.add（function（）{ console.log（F2）；}）； / /记忆在这里，没有火，结果：F2
（回调。火）； / /触发一个F1 F2 output.firingstart = 0
一次使用
回调=美元。回调（曾经的记忆）；
Callbacks.add（function（）{ console.log（F3）；}）；
callbacks.fire（F3）； / /输出，那么函数列表已经完成！
Callbacks.add（功能（{控制台日志）（F4）；}）； / /没有火，结果：F4
（回调。火）； / / 由于一次
}）；

1.3独特的

回调函数列表中的函数可以复制，这与Add（）方法有关。它可以避免在回调函数列表中添加多个回调。
VaR F1 =函数（）{ console.log（F1）；}；
var =美元回调。回调（）；
Callbacks.add（F1）；
Callbacks.add（F1）；
Callbacks.fire（F1）； / /输出
传输参数唯一
回调=美元。回调（独特的）；
Callbacks.add（F1）； / /有效
Callbacks.add（F1）； / /添加。
（回调。火）； / /输出：F1

1.4 stoponfalse

By default, when executing the fireWith () method, all functions in the entire callback function list will be executed sequentially, but if stopOnFalse is set, then when a function returns to false, the function behind it will no longer execute.Even if memory is set, the functions that are added again will not be executed, that is, once a function returns to false, the memory function is disabled.But if once is not set, calling fire again can re trigger the callbacks.
函数（{控制台（log））；
VaR F2 =函数（）{ console.log（F2）；}；
var =美元回调。回调（）；
Callbacks.add（F1）；
Callbacks.add（F2）；
Callbacks.fire（F1，F2）； / /输出
回调=美元。回调（记忆stoponfalse ）；
Callbacks.add（F1）；
Callbacks.add（F2）；
Callbacks.fire（F1）； / /输出
Callbacks.add（功能（{控制台日志）（F3）；}）； / /不输出，记忆已经失去作用。
（回调。火）； / /重新触发输出F1

2。记忆回调队列
var I＝0；
var =函数（{）{
++；
警报（i + $ ）；
}；
var =美元回调。回调（记忆的）；
Callbacks.add（功能通路（）{）
callbacks.add（公司）；
如果（i = 1）{
Callbacks.fire（我）；
}
}）；
Callbacks.fire（我）；
callbacks.add（公司）；
*
列表{ }；
列表= { }；
>火（0），我＝0
1，列表= {，}
2，推（火（0））
3，（0）}（i＝1）
移位（）- >火（0），i＝1
1，列表= IT，公司，}；
2，推（火（1）），
3，++（0）}
4，（0）}（i＝3）
移位（）- >火（1），i＝3
1，列表= IT，公司，公司}；
2，++（1）}
3，++（1）}
4，（1）}（i＝6）
>加（公司），我= 6，内存= {这个，1 }
1，（1）}（i＝7）
* /

3、jquery.callbacks源代码

说明：为了使它更容易理解，一些源代码已经进行了修改，以减少一些函数~
jQuery的回调=功能（可选）{
对象建议：参数不是默认为false，而不是未定义的，很容易读取和控制程序。
选项= optionscache { } createoptions选项（选项）| |；
VaR射击，
内存 / /最后火值{语境，args }（记忆列表）
解雇,
firinglength，
firingindex，
firingstart，
列表{ }，
栈options.once = = = =真假 / /堆火：{ }，可重复的列表调用
火=功能（数据）{ / /数据--> {一}的背景下，
记忆= options.memory！数据； false或{上下文，参数}
开火=真实；
firingindex = firingstart | | 0；
firingstart = 0；
firinglength = list.length；
射击=真；
这里的列表 / /条件是因为回调函数的实现可以改变列表的状态，如this.disable（）。
为（；列表firingindex < firinglength；firingindex ++）{
如果（表{ firingindex }。应用（数据{ 0 }，数据{ 1 }）=假options.stoponfalse = = = true）{
内存= false；禁止内存函数，称为Add（new），这个回调函数不会立即自动调用。
打破；
}
}
射击=假；
如果（列表）{
如果（堆栈）{
输入：开火射击/ false =堆栈，实现递归调用
如果（堆栈，长度）{
火（（堆栈。移））； / / { { context1，arguments1 }，{范围内，arguments2 } }
}
否则如果（内存）{ }
输入：开火射击/假堆栈未定义的内存= = =（仅通过火灾（）函数修改）字段内存变量
在这里，主要用于性能优化，以防对象时间不长、系统内存不足。
列表{ }；
{人}
输入：开火射击/假堆栈= = =未定义的内存字段，需要保留必要的
Self.disable ();
}
}
}，
自我= {
添加：函数（）{
如果（列表）{几乎所有的API都应该绑定到这个条件，因为我们需要排队
无功originlength = list.length；
jquery.each（参数、功能（_，arg）{
如果（jquery.type（Arg）=功能）{
（）！（options.unique self.has（Arg）））独特的场效应
如果（options.unique | |！！self.has（Arg））{
List.push（Arg）；
}
}
}）；
如果（射击= TRUE）{
入口条件是： /执行队列回调函数，以及当前执行激活的Add（）函数的回调函数，维护周期时间边界
firinglength = list.length；
否则如果（内存）{ }
输入内存触发的开火：在火（）完全结束之前显示
firingstart = originlength；
火（记忆）；
}
}
返回此；
}，
删除：函数（）{
如果（列表）{
jquery.each（参数、功能（_，arg）{
VaR lastIndex；
而（（lastIndex = jquery.inarray（Arg，列表，lastIndex））{ > = 0）
list.splice（lastIndex，1）；
如果（开火= TRUE）更新边界条件，就可以实现智能处理。
如果（lastIndex firinglength）{
firinglength --；
}
如果（lastIndex firingindex）{
firingindex --；
}
}
}
}）；
}
返回此；
}，
有：函数（函数）{ / /这个API有两个功能，根据单一职责的角度来看，应该增加（isnotempty）接口（非空）
返回函数jquery.inarray（功能列表）> 1：！! (list list.length);
}，
空：函数（）{
列表{ }；
返回此；
}，
禁用：（函数）完全禁用堆栈内存对象，禁用，禁用
列表=堆栈=内存=未定义；
返回此；
}，
禁用：函数（）{
返回！列表；
}，
锁定：函数（）{
堆栈=未定义；
如果内存没有存储调用，则直接禁用此功能（可能从未调用对象已锁定，或没有内存字段）。
如果（！记忆）{
Self.disable（）；
}
返回此；
}，
锁定：函数（）{
返回！堆栈；
}，
用：功能（上下文，args）{
args =参数| | { }；
VaR数据= {一}的背景下；
如果（列表（解雇=假| |堆栈））{
如果（开火）{
输入条件：当前执行队列回调函数的
Stack.push（数据）； / /堆栈实际上是一个队列结构，其中利用栈的一些困惑
{人}
输入一个条件：开火/假= = = =（火）从未解释过
在两种情况下：至少触发一次调用，但是当前允许多个调用，通过锁（锁）
火（args）；
}
}
返回此；
}，
火：函数（）{
Self.fireWith（这个参数）；
返回此；
}，
开火：函数（）{
返回！发射；
}
}；
回归自我；
}；

4。

jQuery的核心。回调（）方法是火（）方法。火灾（）方法被封装在函数中，不能直接访问，因此，外部环境不改变内存、开火和开火等状态。

它也要注意，如果该对象用于回调函数很重要，这可以直接访问的自我对象的公共API。当然，你也可以用用（）指定的参考对象。

jQuery的核心理念。回调（）是酒吧/子模型，建立了程序之间的松散耦合和有效的沟通。

更多有关jQuery相关内容的感兴趣的读者可以查看主题：jQuery常用用法摘要

希望本文能对jQuery程序设计有所帮助。