jQuery1.9.1--data缓存对象源码分析

// 匹配结尾是否有“{...}”或"[...]"
    var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
        // 匹配大写字母
        rmultiDash = /([A-Z])/g;

    /**
     * 内部用来设置/获取元素或对象的缓存方法
     *
     * @param elem DOM元素或者JS对象
     * @param name 缓存的标识符key
     * @param data 缓存数据
     * @param {Boolean} pvt 当为true时表示是私有性的，jq内部使用的
     */

    function internalData(elem, name, data, pvt /* Internal Use Only */ ) {
        // 判断该对象能不能绑定数据
        if (!jQuery.acceptData(elem)) {
            return;
        }

        var thisCache, ret,
            // expando是jQuery生成的随机ID
            internalKey = jQuery.expando,
            getByName = typeof name === 'string',
            // 我们不得不分别处理DOM元素和js对象，
            // 因为ie6/7的垃圾回收不能正确处理对DOM元素的对象引用
            isNode = elem.nodeType,
            // 只有DOM元素才需要全局jQuery.cache对象。
            // js对象数据直接指向该对象，垃圾回收可以自动处理
            cache = isNode ? jQuery.cache : elem,
            // 1. 如果是dom元素，返回dom元素通过expando对应的id（值可能为undefined）
            // 2. 如果是普通js对象，分两种情况：
            //    2.1 如果js对象存在通过expando对应的值，即代表有缓存数据，则立即返回expando作为id
            //    2.2 如果没有对应值，则代表没有缓存数据，此时返回undefined
            // 也就是说如果id不为空，那么肯定是有存储数据过的
            id = isNode ? elem[internalKey] : elem[internalKey] && internalKey;

        // 当一个对象没有data的时候返回，避免多余工作
        if ((!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined) {
            return;
        }

        // 如果没有ID
        if (!id) {
            // 如果是DOM元素，给该节点绑定一个属性ID
            if (isNode) {
                elem[internalKey] = id = core_deletedIds.pop() || jQuery.guid++;
            } else {
                // 否则是对象则通过expando创建一个唯一ID
                id = internalKey;
            }
        }

        // 如果cache对象没有指定id属性
        if (!cache[id]) {
            cache[id] = {};

            // 当为JS对象时，为了避免被JSON.stringify序列化
            // 这里将toJSON方法设为空方法，这样就会返回空值
            if (!isNode) {
                cache[id].toJSON = jQuery.noop;
            }
        }


        // 如果name是对象或函数，当存在pvt将name浅复制给cache[id]，
        // 否则浅复制给cache[id].data
        if (typeof name === 'object' || typeof name === 'function') {
            if (pvt) {
                cache[id] = jQuery.extend(cache[id], name);
            } else {
                cache[id].data = jQuery.extend(cache[id].data, name);
            }
        }

        thisCache = cache[id];

        // 为了防止系统内部数据和用户自定义数据的key发生冲突，才将用户数据包在thisCache.data中，
        // pvt的意思是保持私有性，非私有性时对外提供data属性对象
        // 系统内部数据就是thisCache中
        if (!pvt) {
            if (!thisCache.data) {
                thisCache.data = {};
            }

            // 只对外开放thisCache.data属性值
            thisCache = thisCache.data;
        }

        // 如果data不为undefined，将data赋值给thisCache的通过驼峰式的name属性
        if (data !== undefined) {
            thisCache[jQuery.camelCase(name)] = data;
        }

        // 如果name是字符串
        if (getByName) {
            // 尝试获取thisCache的属性data
            ret = thisCache[name];

            // 如果ret为null或undefined，则尝试获取驼峰式的name属性data值
            if (ret == null) {
                ret = thisCache[jQuery.camelCase(name)];
            }
        } else {
            // 否则name为非字符串时，ret指向thisCache
            ret = thisCache;
        }

        return ret;
    }

    /**
     * 删除对应的缓存数据
     *
     * @param elem
     * @param name
     * @param pvt
     */

    function internalRemoveData(elem, name, pvt) {
        if (!jQuery.acceptData(elem)) {
            return;
        }

        var i, l, thisCache,
            isNode = elem.nodeType,
            cache = isNode ? jQuery.cache : elem,
            id = isNode ? elem[jQuery.expando] : jQuery.expando;

        // 如果没有缓存对象，返回
        if (!cache[id]) {
            return;
        }

        if (name) {
            thisCache = pvt ? cache[id] : cache[id].data;

            if (thisCache) {
                // 支持单个的key
                // 数组，多个key，如：[key1, key2, key3, ...]
                // 字符串，多个key，用空格隔开，如：'key1 key2 key3 ...'

                // 如果name不是数组类型，将name转换为数组类型
                if (!jQuery.isArray(name)) {
                    // 如果name是thisCache的一个属性key
                    if (name in thisCache) {
                        // 用数组保存
                        name = [name];
                    } else {
                        // 将name驼峰化
                        name = jQuery.camelCase(name);
                        // 此时若name是thisCache的一个属性key
                        if (name in thisCache) {
                            // 同样转换成数组
                            name = [name];
                        } else {
                            // 否则name是个多个空白分隔的字符串
                            name = name.split(' ');
                        }
                    }
                    // 如果是数组，将name数组各项驼峰化后追加到name数组里
                } else {
                    name = name.concat(jQuery.map(name, jQuery.camelCase));
                }

                // 遍历删除name数组里的各项key属性
                for (i = 0, l = name.length; i < l; i++) {
                    delete thisCache[name[i]];
                }

                // 如果pvt为true，检查thisCache是否为空的数据对象，如果不是直接退出函数
                // 如果pvt为false，判断thisCache是否为空对象，如果不是也是退出
                // 这里考虑到用户自定义或者其他私有受保护的属性
                if (!(pvt ? isEmptyDataObject : jQuery.isEmptyObject)(thisCache)) {
                    return;
                }
            }
        }

        // 如果pvt为false，即非私有性
        // 删除data属性值
        if (!pvt) {
            delete cache[id].data;

            // 同理，这时cache[id]还存在其他属性，退出
            if (!isEmptyDataObject(cache[id])) {
                return;
            }
        }

        // 如果是DOM元素，清除绑定在elem上的所有数据
        if (isNode) {
            jQuery.cleanData([elem], true);
        } else if (jQuery.support.deleteExpando || cache != cache.window) {
            // 如果支持删除绑定在对象上的expando属性或者cache非window对象
            // 只用delete就可以删除了
            delete cache[id];
        } else {
            // 其他情况就将属性设为null来清空缓存
            cache[id] = null;
        }
    }

    jQuery.extend({
        // 当是DOM元素的时候，使用$.cache来缓存数据
        cache: {},
        // 生成expando字符串
        expando: 'jQuery' + (core_version + Math.random()).replace(/\D/g, ''),
        // 以下情况不需要缓存
        noData: {
            'embed': true,
            'object': 'clsid:D27CDB6E-AE6D-11cf-96B8-444553540000',
            'applet': true
        },
        // 判断是否已有缓存数据
        hasData: function(elem) {
            elem = elem.nodeType ? jQuery.cache[elem[jQuery.expando]] : elem[jQuery.expando];
            return !!elem && !isEmptyDataObject(elem);
        },
        // 适配器模式
        data: function(elem, name, data) {
            return internalData(elem, name, data);
        },
        removeData: function(elem, name) {
            return internalRemoveData(elem, name);
        },
        // 私有方法
        _data: function(elem, name, data) {
            return internalData(elem, name, data, true);
        },
        _removeData: function(elem, name) {
            return internalRemoveData(elem, name, true);
        },
        // 判断元素或对象是否可以缓存
        acceptData: function(elem) {
            if (elem.nodeType && elem.nodeType !== 1 && elem.nodeType !== 9) {
                return false;
            }

            var noData = elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()];

            return !noData || noData !== true && elem.getAttribute('classid') === noData;
        }
    });

    jQuery.fn.extend({
        data: function(key, value) {
            var attrs, name,
                elem = this[0],
                i = 0,
                data = null;

            // 如果key为undefined，说明key和value都为空，获取缓存data
            if (key === undefined) {
                // 如果有DOM元素
                if (this.length) {
                    // 获取以前保存在elem的data
                    data = jQuery.data(elem);

                    // 对于元素节点而言，数据可以来自两个地方：
                    // 1. jQuery.cache缓存中，之前手动存进去的，如：$dom.data('data1', value1);
                    // 2. 来自html标签的以data-开头的属性，之后该属性的数据也会被存储到jQuery.cache缓存中

                    // 如果元素节点的jQuery.cache['parsedAttrs']的值为null | false | undefined
                    // 说明elem的属性节点没有被解析过，下面就进行解析
                    if (elem.nodeType === 1 && !jQuery._data(elem, 'parsedAttrs')) {
                        // 获得elem的属性列表
                        attrs = elem.attributes;
                        for (; i < attrs.length; i++) {
                            // 该属性名称
                            name = attrs[i].name;

                            // 如果name有"data-"字符
                            if (!name.indexOf('data-')) {
                                // 将name驼峰化："dataCustom"
                                name = jQuery.camelCase(name.slice(5));

                                // 如果没有对应的缓存，就将html5的“data-”值（转换后）设置为相应的缓存值
                                dataAttr(elem, name, data[name]);
                            }
                        }
                        // 给缓存对象添加私有缓存，并把缓存值设置为true
                        // 用来标记已经解析过属性
                        jQuery._data(elem, 'parseAttrs', true);
                    }
                }

                return data;
            }

            // 如果key是对象，直接将其拷贝到jQuery.cache.data缓存对象里
            // 用来设置多个值的情况
            if (typeof key === 'object') {
                return this.each(function() {
                    jQuery.data(this, key);
                });
            }

            // 为每个元素执行函数后返回原始的元素集(this)
            return jQuery.access(this, function(value) {
                if (value === undefined) {
                    // 如果value未定义并且在jQuery.cache缓存中没有找到相应key的缓存，
                    // 然后再试图查看HTML5标签的“data-”属性是否被解析过了
                    return elem ? dataAttr(elem, key, jQuery.data(elem, key)) : null;
                }
            }, null, value, arguments.length > 1, null, true);
        },
        removeData: function(key) {
            return this.each(function() {
                jQuery.removeData(this, key);
            });
        }
    });

    // 处理元素节点中使用HTML5的“data-test”属性，并将其转换到相应的类型存储到jQuery.cache对象中

    function dataAttr(elem, key, data) {
        // 如果data为空且elem是元素节点，那么将HTML5的data-属性值转换为相应的类型
        if (data === undefined && elem.nodeType === 1) {
            // 反驼峰化
            var name = 'data-' + key.replace(rmultiDash, '-$1').toLowerCase();

            // 获取data字符串属性值
            data = elem.getAttribute(name);

            if (typeof data === 'string') {
                try {
                    // 布尔型
                    data = data === 'true' ? true :
                        data === 'false' ? false :
                    // null
                    data === 'null' ? null :
                    // +data只会将数字字符转换成数字,再加上""则会转换回字符串
                    // 这里是测试是否为数字
                    +data + '' === data ? +data :
                    // 数组或对象，并转换
                    rbrace.test(data) ? jQuery.parseJSON(data) :
                    // 其他类型
                    data;
                } catch (e) {}

                // 将格式化的数据存在jQuery.cache缓存。
                jQuery.data(elem, key, data);
            } else {
                // 如果该属性不存在，此时data为null，将其转换为undefined
                data = undefined;
            }
        }

        // 返回data-属性值(转换后)的类型
        return data;
    }

    // 检查缓存对象的数据是否为空

    function isEmptyDataObject(obj) {
        var name;
        for (name in obj) {
            // 如果公共data为空，那么私有对象也为空
            if (name === 'data' && jQuery.isEmptyObject(obj[name])) {
                continue;
            }
            if (name !== 'toJSON') {
                return false;
            }
        }

        return true;
    }