jQuery memory&unique&stopOnfalse

memory:保持以前的值,将添加到这个列表的后面的最新的值立即执行调用任何回调 (像一个递延 Deferred)。

回调函数是从异步队列Deferred分离出来的,所以很多的接口设计都是为了契合Deferred接口,memory用的很多,这个缓存的设计这里提及一下

主要是用来实现deferred的异步收集与pipe管道风格的数据传递的,具体在Deferred有详解,这里大概了解下作用范围。

memory这个有点不好理解,我们还是通过列子说明下,看下面的代码:

function fn1(val) {
        console.log(‘fn1 says:‘ + val);
    }

    function fn2(val) {
        console.log(‘fn2 says ‘ + val);
    }
    function fn3(val){
        console.log("fn3 says " + val);
    }

     /* var cbs = $.Callbacks("memory");
    cbs.add(fn1);
    cbs.fire(‘foo‘);
    console.log(‘..........‘);
    cbs.add(fn2);
    cbs.fire(‘bar‘);
    console.log(‘..........‘);
    cbs.add(fn3);
    cbs.fire(‘aaron‘);*/
    function callbacks(options){
        var list = [];
        var self;
        var memory;
        var firingStart;
        function _fire(data){
            memory = options === ‘memory‘ && data;//===>&&>=
            firingIndex = firingStart || 0;
            firingStart = 0;//改变firingStart,之后的fire还是从0开始。
            firingLength = list.length;
            for(; list && firingIndex < firingLength; firingIndex++){
                list[firingIndex](data);
            }
        };
        self = {
            add: function(fn){
                var start = list.length;
                list.push(fn);
                if(memory){
                    firingStart = start;//改变firingStart
                    _fire(memory);
                }
            },
            fire: function(args){
                if(list){
                    _fire(args);
                    if(options === "once"){
                        list = undefined;
                    }
                }
            }
        };
        return self;
    }
    var cc = callbacks("memory");
    cc.add(fn1);
    cc.fire("111");
    console.log("...............");
    cc.add(fn2);
    cc.fire("222");

unique:

function fn1(val) {
        console.log(‘fn1 says:‘ + val);
    }
    function fn2(val) {
        console.log(‘fn2 says ‘ + val);
    }
    function fn3(val){
        console.log("fn3 says " + val);
    }

      /*var cbs = $.Callbacks("unique");
    cbs.add(fn1);
    cbs.add(fn1);
    cbs.add(fn1);
    cbs.fire(‘foo‘);
    console.log(‘..........‘);*/

    /*cbs.add(fn2);
    cbs.fire(‘bar‘);
    console.log(‘..........‘);
    cbs.add(fn3);
    cbs.fire(‘aaron‘);*/
    function callbacks(options){
        var list = [];
        var self;
        var memory;
        var firingStart;
        function _fire(data){
            memory = options === ‘memory‘ && data;//===>&&>=
            firingIndex = firingStart || 0;
            firingStart = 0;//改变firingStart,之后的fire还是从0开始。
            firingLength = list.length;
            for(; list && firingIndex < firingLength; firingIndex++){
                list[firingIndex](data);
            }
        };
        self = {
            add: function(fn){
                var start = list.length;
                if(options === "unique"){
                    if(list.indexOf(fn) === -1){
                        list.push(fn);
                    }
                }else{
                    list.push(fn);
                }

                if(memory){
                    firingStart = start;//改变firingStart
                    _fire(memory);
                }
            },
            fire: function(args){
                if(list){
                    _fire(args);
                    if(options === "once"){
                        list = undefined;
                    }
                }
            }
        };
        return self;
    }
    var cc = callbacks("unique");
    cc.add(fn1);
    cc.add(fn1);
    cc.add(fn1);
    cc.fire("111");

stopOnfalse:

function fn1(val) {
        console.log(‘fn1 says:‘ + val);
        return false;
    }
    function fn2(val) {
        console.log(‘fn2 says ‘ + val);
        return false;
    }
    function fn3(val){
        console.log("fn3 says " + val);
    }

      /*var cbs = $.Callbacks("stopOnFalse");
    cbs.add(fn1);
    cbs.fire(‘foo‘);
    console.log(‘..........‘);
    cbs.add(fn2);
    cbs.fire(‘bar‘);
    console.log(‘..........‘);
    cbs.add(fn3);
    cbs.fire(‘aaron‘);*/
    /*cbs.add(fn2);
    cbs.fire(‘bar‘);
    console.log(‘..........‘);
    ;*/
    function callbacks(options){
        var list = [];
        var self;
        var memory;
        var firingStart;
        function _fire(data){
            memory = options === ‘memory‘ && data;//===>&&>=
            firingIndex = firingStart || 0;
            firingStart = 0;//改变firingStart,之后的fire还是从0开始。
            firingLength = list.length;
            for(; list && firingIndex < firingLength; firingIndex++){
               if(list[firingIndex](data) === false && options === ‘stopOnFalse‘){
                   break;
               };
            }
        };
        self = {
            add: function(fn){
                var start = list.length;
                if(options === "unique"){
                    if(list.indexOf(fn) === -1){
                        list.push(fn);
                    }
                }else{
                    list.push(fn);
                }

                if(memory){
                    firingStart = start;//改变firingStart
                    _fire(memory);
                }
            },
            fire: function(args){
                if(list){
                    _fire(args);
                    if(options === "once"){
                        list = undefined;
                    }
                }
            }
        };
        return self;
    }
    var cc = callbacks("stopOnFalse");
    cc.add(fn1);
    cc.fire("111");
    cc.add(fn2);
    cc.fire("222");

时间: 2024-09-30 04:19:30

jQuery memory&unique&stopOnfalse的相关文章

jquery源码 Callback

工具方法.对函数的统一管理. jquery2.0.3版本$.Callback()部分的源码如下: // String to Object options format cache var optionsCache = {}; // Convert String-formatted options into Object-formatted ones and store in cache function createOptions( options ) { var object = option

jquery源码01---(2880 , 3042) Callbacks : 回调对象 : 对函数的统一管理

// optionsCache : { 'once memory' : { once : true , memory : true } } var optionsCache = {}; // once memory,options.match( core_rnotwhite )=[once, memory],function( _, flag )={once:true,memory:true} function createOptions( options ) { var object = op

深入jQuery中的Callback()

引入 初看Callback函数很不起眼,但仔细一瞅,发现Callback函数是构建jQuery大厦的无比重要的一个基石.jQuery中几乎所有有关异步的操作都会用到Callback函数. 为什么搞了个Callback函数? 1  在 js 开发中,经常会遇到同步和异步这两个概念. 2  在javascript中神马是同步?神马是异步? 听我讲一个相亲的故事(本故事并不准确,仅供参考): 1 藤篮是一个漂亮姑娘,明年就要30岁了可现在还没有对象,于是,她的母亲给她报名了两家相亲机构,一家名叫同步相

jQuery源码解读第5章---对Callbacks的解读

jQuery.Callbacks() 是一个多用途的回调函数列表对象 提供了一种强大的方法来管理回调函数队列 先来看看Callbacks的常见的用法 1-------不带参数 先看看不用回调函数的例子 eq function a1(){ console.log('a1') } (function(){ function a2(){ console.log('a2') } })() a1() // a1 a2() //就不行了 这时候我们就可以使用回调函数Callbacks 了 var dfd1

jquery源码解析:jQuery工具方法Callbacks详解

我们首先来讲下Callbacks是如何使用的:第一个例子 function a(){} function b(){} var cb = $.Callbacks(); cb.add(a); cb.add(b); cb.fire();      //就会先执行a方法,再执行b方法 上面大概的意思是:add方法,就是把方法添加到数组list中,每执行一次,就添加一个方法.而fire方法,就是把list数组中的方法按顺序执行. 使用场景:第二个例子 function a(n){ } (function(

jquery Callbacks方法实现

版本:1.7.1 jQuery.Callbacks(flags) 调用Callbacks方法后,返回一个用于处理回调函数队列的对象,对象包含有add,remove,fire,fireWith,fired,lock,locked,disable, disabled,has,empty方法用于管理和操作回调函数队列,回调函数队列以数组的形式存储在函数Callbacks作用域内,通过闭包机制返回的回调对象操作回调函数队列. 参数flags 取值:once memory unique stopOnFal

jQuery Callbacks应用关键点

Callbacks是jQuery 1.7引入的方法,用于管理一系列使用相同参数的回调函数.所有回调函数(以下简称回调)保存在一个数组中,可以重复调用.其本质相当于一个回调函数列(List),因此可以做添加.删除.清空回调函数等操作. 生成回调列(Callbacks) var callbacks = $.Callbacks(); 回调执行顺序 回调保存在数组中,然后通过for循环遍历,所以列中的回调按照被添加的顺序依次执行,最后添加的一般最后执行. // Fire the items on the

jquery callback

用处:http://blog.csdn.net/tjcyjd/article/details/6741882 $('.scroll').on('click', function(){ $(this).hide('slow'); alert('先alert,再隐藏'); }) $('.scroll').on('click', function(){ $(this).hide('slow', function(){ alert('先隐藏再alert'); }); 1.callbacks.add()

jquery09--Callbacks : 回调对象

<!DOCTYPE HTML> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> <title>无标题文档</title> <script src="jquery-2.0.3.js"></script> <script> //C