jQuery.extend({
    // 全局缓存对象
    cache: {},

    // 页面中每个jquery副本的唯一标识
    expando:"..",

    noData: {},

    // 是否有关联的数据
    hasData: function( elem ) {},

    // 设置,读取自定义数据
    data: function( elem, name, data ) {},

    // 移除自定义数据
    removeData: function( elem, name ) {},

    // 设置或读取内部数据
    _data: function( elem, name, data ) {},

    // 是否可以设置数据
    acceptData: function( elem ) {}
});
jQuery.fn.extend({
    // 设置,读取自定义数据,解析html5属性 data-
    data: function( key, value ){},

    // 移除自定义数据
    removeData: function( key ){}
});
// 解析html5属性 data-
function dataAttr( elem, key, data ){}

// 检查数据缓存对象是否为空
function isEmptyDataObject( obj ) {}

jQuery.extend({
    // 清空数据缓存对象
    cleanData: function(elems, acceptData){}
})

<div></div>
<script>
     var div = $("div")[0];
     jQuery.data(div, "test", { first: 16, last: "pizza!" });
     console.log(jQuery.data(div, "test").first);
     console.log(jQuery.data(div, "test").last);  // pizza
</script>

$("body").data("foo", 52);
$("body").data("bar", { myType: "test", count: 40 });
$("body").data({ baz: [ 1, 2, 3 ] });

console.log($("body").data("foo"));
console.log($("body").data()); // { foo: 52, bar: { myType: "test", count: 40 }, baz: [ 1, 2, 3 ] }

// 获取data中的某一个对象的值
console.log($("body").data("bar").myType); // test

<div data-role="page" data-last-value="43" data-hidden="true" data-options='{"name":"John"}'></div>
      var role = $("div").data("role");
      var lastValue = $("div").data("lastValue");
      var hidden = $("div").data("hidden");
      var options = $("div").data("options").name;
      console.log(role === "page");  // true
      console.log(lastValue === 43); // true
      console.log(hidden === true);  // true
      console.log(options === "John");  // true

 <p>Results: </p>
      <script>
          var $p = jQuery("p"), p = $p[0];

          console.log(jQuery.hasData(p)+" "); // false

          $.data(p, "testing", 123);
          console.log(jQuery.hasData(p)+" "); // true

          $.removeData(p, "testing");
          console.log(jQuery.hasData(p)+" "); // false

          // 使用jQuery数据 存储事件处理程序 绑定事件到一个元素上的时候，也会在那个元素上关联一个 data 对象
          $p.on('click', function() {});
          console.log(jQuery.hasData(p)+" "); // true

          $p.off('click');
          console.log(jQuery.hasData(p)+" "); // false
      </script>

     <div>value1 before creation: <span></span></div>
     <div>value1 after creation: <span></span></div>
     <div>value1 after removal: <span></span></div>
     <div>value2 after removal: <span></span></div>
     <script>
         var div = $("div")[0];
         $("span:eq(0)").text("" + $("div").data("test1")); // value1 before creation: undefined
         jQuery.data(div, "test1", "VALUE-1");
         jQuery.data(div, "test2", "VALUE-2");
         $("span:eq(1)").text("" + jQuery.data(div, "test1")); // value1 after creation: VALUE-1
         jQuery.removeData(div, "test1");
         $("span:eq(2)").text("" + jQuery.data(div, "test1")); // value1 after removal: undefined
         $("span:eq(3)").text("" + jQuery.data(div, "test2")); // value2 after removal: VALUE-2
     </script>

<div>value1 before creation: <span></span></div>
<div>value1 after creation: <span></span></div>
<div>value1 after removal: <span></span></div>
<div>value2 after removal: <span></span></div>
<script>
         var div = $("div")[0];
         $("span:eq(0)").text("" + $("div").data("test1")); // value1 before creation: undefined
         jQuery.data(div, "test1", "VALUE-1");
         jQuery.data(div, "test2", "VALUE-2");
         $("span:eq(1)").text("" + $("div").data("test1")); // value1 after creation: VALUE-1
         $("div").removeData("test1");
         $("span:eq(2)").text("" + $("div").data("test1")); // value1 after removal: undefined
         $("span:eq(3)").text("" + $("div").data("test2")); // value2 after removal: VALUE-2
 </script>

jQuery.extend({

         noData: {
             "embed": true,
             // Ban all objects except for Flash (which handle expandos)
             "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
             "applet": true
         },

         // 是否可以设置数据
         acceptData: function( elem ) {
             // Do not set data on non-element because it will not be cleared (#8335).
             if ( elem.nodeType && elem.nodeType !== 1 && elem.nodeType !== 9 ) {
                 return false;
             }

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

             // nodes accept data unless otherwise specified; rejection can be conditional
             return !noData || noData !== true && elem.getAttribute("classid") === noData;
         }
     });

jQuery.extend({
        data: function( elem, name, data ) {
            return internalData( elem, name, data );
        }
})

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

        var i, l, thisCache,
            isNode = elem.nodeType,

            // See jQuery.data for more information
            cache = isNode ? jQuery.cache : elem,
            id = isNode ? elem[ jQuery.expando ] : jQuery.expando;

        // If there is already no cache entry for this object, there is no
        // purpose in continuing
        if ( !cache[ id ] ) {
            return;
        }

        if ( name ) {

            thisCache = pvt ? cache[ id ] : cache[ id ].data;

            if ( thisCache ) {

                // Support array or space separated string names for data keys
                if ( !jQuery.isArray( name ) ) {

                    // try the string as a key before any manipulation
                    if ( name in thisCache ) {
                        name = [ name ];
                    } else {

                        // split the camel cased version by spaces unless a key with the spaces exists
                        name = jQuery.camelCase( name );
                        if ( name in thisCache ) {
                            name = [ name ];
                        } else {
                            name = name.split(" ");
                        }
                    }
                } else {
                    // If "name" is an array of keys...
                    // When data is initially created, via ("key", "val") signature,
                    // keys will be converted to camelCase.
                    // Since there is no way to tell _how_ a key was added, remove
                    // both plain key and camelCase key. #12786
                    // This will only penalize the array argument path.
                    name = name.concat( jQuery.map( name, jQuery.camelCase ) );
                }

                for ( i = 0, l = name.length; i < l; i++ ) {
                    delete thisCache[ name[i] ];
                }

                // If there is no data left in the cache, we want to continue
                // and let the cache object itself get destroyed
                if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
                    return;
                }
            }
        }

        // See jQuery.data for more information
        if ( !pvt ) {
            delete cache[ id ].data;

            // Don't destroy the parent cache unless the internal data object
            // had been the only thing left in it
            if ( !isEmptyDataObject( cache[ id ] ) ) {
                return;
            }
        }

        // Destroy the cache
        if ( isNode ) {
            jQuery.cleanData( [ elem ], true );

        // Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
        } else if ( jQuery.support.deleteExpando || cache != cache.window ) {
            delete cache[ id ];

        // When all else fails, null
        } else {
            cache[ id ] = null;
        }
     }

if ( name ) {

       thisCache = pvt ? cache[ id ] : cache[ id ].data;

       if ( thisCache ) {

           // Support array or space separated string names for data keys
           if ( !jQuery.isArray( name ) ) {

               // try the string as a key before any manipulation
               if ( name in thisCache ) {
                   name = [ name ];
               } else {

                   // split the camel cased version by spaces unless a key with the spaces exists
                   name = jQuery.camelCase( name );
                   if ( name in thisCache ) {
                       name = [ name ];
                   } else {
                       name = name.split(" ");
                   }
               }
           } else {
               // If "name" is an array of keys...
               // When data is initially created, via ("key", "val") signature,
               // keys will be converted to camelCase.
               // Since there is no way to tell _how_ a key was added, remove
               // both plain key and camelCase key. #12786
               // This will only penalize the array argument path.
               name = name.concat( jQuery.map( name, jQuery.camelCase ) );
           }

           for ( i = 0, l = name.length; i < l; i++ ) {
               delete thisCache[ name[i] ];
           }

           // If there is no data left in the cache, we want to continue
           // and let the cache object itself get destroyed
           if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
               return;
           }
       }
   }

// split the camel cased version by spaces unless a key with the spaces exists
   name = jQuery.camelCase( name );
   if ( name in thisCache ) {
       name = [ name ];
   } else {
       name = name.split(" ");
   }

// checks a cache object for emptiness
   function isEmptyDataObject( obj ) {
       var name;
       for ( name in obj ) {

           // if the public data object is empty, the private is still empty
           if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
               continue;
           }
           if ( name !== "toJSON" ) {
               return false;
           }
       }

       return true;
   }
   isEmptyObject 的源码如下:
   isEmptyObject: function( obj ) {
       var name;
       for ( name in obj ) {
           return false;
       }
       return true;
   }

function internalData( elem, name, data, pvt /* Internal Use Only */ ){
        if ( !jQuery.acceptData( elem ) ) {
            return;
        }
        var thisCache, ret,
            internalKey = jQuery.expando,
            getByName = typeof name === "string",

            // We have to handle DOM nodes and JS objects differently because IE6-7
            // can't GC object references properly across the DOM-JS boundary
            isNode = elem.nodeType,

            // Only DOM nodes need the global jQuery cache; JS object data is
            // attached directly to the object so GC can occur automatically
            cache = isNode ? jQuery.cache : elem,

            // Only defining an ID for JS objects if its cache already exists allows
            // the code to shortcut on the same path as a DOM node with no cache
            id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey;

        // Avoid doing any more work than we need to when trying to get data on an
        // object that has no data at all
        if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined ) {
            return;
        }

        if ( !id ) {
            // Only DOM nodes need a new unique ID for each element since their data
            // ends up in the global cache
            if ( isNode ) {
                elem[ internalKey ] = id = core_deletedIds.pop() || jQuery.guid++;
            } else {
                id = internalKey;
            }
        }

        if ( !cache[ id ] ) {
            cache[ id ] = {};

            // Avoids exposing jQuery metadata on plain JS objects when the object
            // is serialized using JSON.stringify
            if ( !isNode ) {
                cache[ id ].toJSON = jQuery.noop;
            }
        }

        // An object can be passed to jQuery.data instead of a key/value pair; this gets
        // shallow copied over onto the existing cache
        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 ];

        // jQuery data() is stored in a separate object inside the object's internal data
        // cache in order to avoid key collisions between internal data and user-defined
        // data.
        if ( !pvt ) {
            if ( !thisCache.data ) {
                thisCache.data = {};
            }

            thisCache = thisCache.data;
        }

        if ( data !== undefined ) {
            thisCache[ jQuery.camelCase( name ) ] = data;
        }

        // Check for both converted-to-camel and non-converted data property names
        // If a data property was specified
        if ( getByName ) {

            // First Try to find as-is property data
            ret = thisCache[ name ];

            // Test for null|undefined property data
            if ( ret == null ) {

                // Try to find the camelCased property
                ret = thisCache[ jQuery.camelCase( name ) ];
            }
        } else {
            ret = thisCache;
        }

        return ret;
     }

var  thisCache, ret,
        internalKey = jQuery.expando,
        getByName = typeof name === "string",

        // We have to handle DOM nodes and JS objects differently because IE6-7
        // can't GC object references properly across the DOM-JS boundary
        isNode = elem.nodeType,

        // Only DOM nodes need the global jQuery cache; JS object data is
        // attached directly to the object so GC can occur automatically
        cache = isNode ? jQuery.cache : elem,

        // Only defining an ID for JS objects if its cache already exists allows
        // the code to shortcut on the same path as a DOM node with no cache
        id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey;

var body = document.body;
   var $body = $(body);

   // 先移除可以存在的缓存数据
   $body.removeData();

   // 设置自定义数据
   $body.data('public-data',1);

   // 设置自定义数据
   $.data(body,'public-data-2',2);

   // 设置内部数据
   $.data(body,'private-data',3,true);

   // 打印关联的id
   console.log('关联id:',$('body')[0][$.expando]); // 关联id: 1

var noop: function() {};
   if ( !cache[ id ] ) {
        cache[ id ] = {};
        // Avoids exposing jQuery metadata on plain JS objects when the object
        // is serialized using JSON.stringify
        if ( !isNode ) {
            cache[ id ].toJSON = jQuery.noop;
        }
   }

var rmsPrefix = /^-ms-/,
        rdashAlpha = /-([\da-z])/gi;

    var camelCase: function( string ) {
        return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
    };
    var fcamelCase = function( all, letter ) {
        return letter.toUpperCase();
    }

    thisCache = cache[ id ];
    // jQuery data() is stored in a separate object inside the object's internal data
    // cache in order to avoid key collisions between internal data and user-defined
    // data.
    if ( !pvt ) {
        if ( !thisCache.data ) {
            thisCache.data = {};
        }
        thisCache = thisCache.data;
    }
    if ( data !== undefined ) {
        thisCache[ jQuery.camelCase( name ) ] = data;
    }

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

            // Gets all values
            if ( key === undefined ) {
                if ( this.length ) {
                    data = jQuery.data( elem );

                    if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
                        attrs = elem.attributes;
                        for ( ; i < attrs.length; i++ ) {
                            name = attrs[i].name;

                            if ( !name.indexOf( "data-" ) ) {
                                name = jQuery.camelCase( name.slice(5) );

                                dataAttr( elem, name, data[ name ] );
                            }
                        }
                        jQuery._data( elem, "parsedAttrs", true );
                    }
                }

                return data;
            }

            // Sets multiple values
            if ( typeof key === "object" ) {
                return this.each(function() {
                    jQuery.data( this, key );
                });
            }

            return jQuery.access( this, function( value ) {

                if ( value === undefined ) {
                    // Try to fetch any internally stored data first
                    return elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : null;
                }

                this.each(function() {
                    jQuery.data( this, key, value );
                });
            }, null, value, arguments.length > 1, null, true );
        }
     });

if ( key === undefined ) {
       if ( this.length ) {
           data = jQuery.data( elem );

           if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
               attrs = elem.attributes;
               for ( ; i < attrs.length; i++ ) {
                   name = attrs[i].name;

                   if ( !name.indexOf( "data-" ) ) {
                       name = jQuery.camelCase( name.slice(5) );

                       dataAttr( elem, name, data[ name ] );
                   }
               }
               jQuery._data( elem, "parsedAttrs", true );
           }
       }

       return data;
   }

var rmultiDash = /([A-Z])/g;
   var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
   function dataAttr( elem, key, data ) {
       // If nothing was found internally, try to fetch any
       // data from the HTML5 data-* attribute
       if ( data === undefined && elem.nodeType === 1 ) {

           var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();

           data = elem.getAttribute( name );

           if ( typeof data === "string" ) {
               try {
                   data = data === "true" ? true :
                       data === "false" ? false :
                       data === "null" ? null :
                       // Only convert to a number if it doesn't change the string
                       +data + "" === data ? +data :
                       rbrace.test( data ) ? jQuery.parseJSON( data ) :
                           data;
               } catch( e ) {}

               // Make sure we set the data so it isn't changed later
               jQuery.data( elem, key, data );

           } else {
               data = undefined;
           }
       }

       return data;
   }

jQuery.fn.extend({
        removeData: function(key) {
           return this.each(function() {
               jQuery.removeData( this, key );
           });
        }
   });

cleanData: function( elems, /* internal */ acceptData ) {
        var elem, type, id, data,
            i = 0,
            internalKey = jQuery.expando,
            cache = jQuery.cache,
            deleteExpando = jQuery.support.deleteExpando,
            special = jQuery.event.special;

        for ( ; (elem = elems[i]) != null; i++ ) {

            if ( acceptData || jQuery.acceptData( elem ) ) {

                id = elem[ internalKey ];
                data = id && cache[ id ];

                if ( data ) {
                    if ( data.events ) {
                        for ( type in data.events ) {
                            if ( special[ type ] ) {
                                jQuery.event.remove( elem, type );

                            // This is a shortcut to avoid jQuery.event.remove's overhead
                            } else {
                                jQuery.removeEvent( elem, type, data.handle );
                            }
                        }
                    }

                    // Remove cache only if it was not already removed by jQuery.event.remove
                    if ( cache[ id ] ) {

                        delete cache[ id ];

                        // IE does not allow us to delete expando properties from nodes,
                        // nor does it have a removeAttribute function on Document nodes;
                        // we must handle all of these cases
                        if ( deleteExpando ) {
                            delete elem[ internalKey ];

                        } else if ( typeof elem.removeAttribute !== core_strundefined ) {
                            elem.removeAttribute( internalKey );

                        } else {
                            elem[ internalKey ] = null;
                        }

                        core_deletedIds.push( id );
                    }
                }
            }
        }
     }