码迷,mamicode.com
首页 > Web开发 > 详细

jQuery的回调对象Callbacks分析

时间:2015-05-05 12:06:29      阅读:125      评论:0      收藏:0      [点我收藏+]

标签:

Callbacks在jQuery中的地位是Deferred的基础,当然,也对外公开其方法。

Callbacks对象是统一管理多个函数的利器。其核心是参数options中的几个状态码的任意组合,非常灵活。

先来看看options

once: 只触发一次回调

memory: 如果是触发后状态,add后立即触发

unique: 添加相同回到函数,只触发其中一个

stopOnFalse: 回调中遇到return false, 后面都不执行。

首先是:

list = []

我们的工作就是在维护这个list

add: function() {
                if ( list ) {
                    // First, we save the current length
                    var start = list.length;
                    (function add( args ) {
                        jQuery.each( args, function( _, arg ) {
                            var type = jQuery.type( arg );
                            if ( type === "function" ) {
                                if ( !options.unique || !self.has( arg ) ) {
                                    list.push( arg );
                                }
                            } else if ( arg && arg.length && type !== "string" ) {
                                // Inspect recursively
                                add( arg );
                            }
                        });
                    })( arguments );
                    // Do we need to add the callbacks to the
                    // current firing batch?
                    if ( firing ) {
                        firingLength = list.length;
                    // With memory, if we‘re not firing then
                    // we should call right away
                    } else if ( memory ) {
                        firingStart = start;
                        fire( memory );
                    }
                }
                return this;
            },

其核心就是那个push方法。代码为什么这么多? 支持数组方式参数,遇到参数中有memory情况,执行方法。

remove方法:

remove: function() {
                if ( list ) {
                    jQuery.each( arguments, function( _, arg ) {
                        var index;
                        while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
                            list.splice( index, 1 );
                            // Handle firing indexes
                            if ( firing ) {
                                if ( index <= firingLength ) {
                                    firingLength--;
                                }
                                if ( index <= firingIndex ) {
                                    firingIndex--;
                                }
                            }
                        }
                    });
                }
                return this;
            },

其核心也是那个splice方法。

针对这个firing,后面介绍。

fire方法:

fire = function( data ) {
            memory = options.memory && data;
            fired = true;
            firingIndex = firingStart || 0;
            firingStart = 0;
            firingLength = list.length;
            firing = true;
            for ( ; list && firingIndex < firingLength; firingIndex++ ) {
                if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
                    memory = false; // To prevent further calls using add
                    break;
                }
            }
            firing = false;
            if ( list ) {
                if ( stack ) {
                    if ( stack.length ) {
                        fire( stack.shift() );
                    }
                } else if ( memory ) {
                    list = [];
                } else {
                    self.disable();
                }
            }
        }

其核心是哪个循环,拿出来一个个执行。

在这里有个stack

stack = !options.once && []

这是一个数组,干嘛用的呢?这是针对有些函数是延时函数,这种情况fire可能会延时,要先把它放到stack函数中。

这样,以上的firing状态也就可以理解了。

 

这就是Callbacks整体,其核心原理还算是比较简单了。

jQuery的回调对象Callbacks分析

标签:

原文地址:http://www.cnblogs.com/pfzeng/p/4478641.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!