jQuery 1.7 源码大致结构

迷南。 2022-02-18 09:41 292阅读 0赞

*  link  
    [jQuery源码结构分析][jQuery]
 *  row data  
    619 rows code.

// jQuery JavaScript Library v1.7
    (function(window, undefined) {
    
    // Use the correct document accordingly with window argument (sandbox)
    var document = window.document,
        navigator = window.navigator,
        location = window.location;
    
    // Define a local copy of jQuery
    var jQuery = (function() {
        // Define a local copy of jQuery
        /** 使用var定义了一系列变量，第一个就是jQuery。最后定义完了用;隔开。 */
        var jQuery = function( selector, context ) {
            // The jQuery object is actually just the init constructor 'enhanced'
            return new jQuery.fn.init( selector, context, rootjQuery );
        },
        /** 其他一些成员的定义... */
        class2type = {};    // 使用的是之前的var jQuery的var关键字。
    
        /** 
         * jQuery.fn，我们jQuery对象的方法的命名空间使用，
         * 实际上是jQuery的原型jQuery.prototype 
         */
        jQuery.fn = jQuery.prototype = {
            constructor: jQuery,
            init: function(selector, context, rootjQuery) {
                /** */
            },
            selector: "",   /** Start with an empty selector */
            jQuery: "1.7",  /** The current version of jQuery being used */
            length: 0,      /** The default length of a jQuery object isi 0 */
            size: function() {return this.length;}, /** The number of elements contained in the matched element set */
            toArray: function() {/** */},
            get: function(num) {/** */},
            pushStack: function(elems, name, selector) {/** */},
            each: function(callback, args) {return jQuery.each(this, callback, args)},
            ready: function(fn) {/** */},
            eq: function(i) {/** */},
            first: function() {return this.eq(0);},
            last: function() {return this.eq(-1);},
            slice: function() {/** */},
            map: function(callback) {/** */},
            end: function() {/** */},
    
            /** For internal use only, Behaves like an Array's method, not like a jQuery method. */
            push: push,
            sort: [].sort,
            splice: [].splice
        };
    
        // Give the init function the jQuery prototype for later instantiation
        /** 将jQuery.prototype赋值给jQuery.fn.init.prototype */
        jQuery.fn.init.prototype = jQuery.fn;
    
        jQuery.extend = jQuery.fn.extend = function() {/** */};
    
        // Populate the class2type map
        jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
            class2type[ "[object " + name + "]" ] = name.toLowerCase();
        });
        
        /** 3个if代码块 */
    
        // All jQuery objects should point back to these
        /** window.document对象是jQuery对象的根，所有jQuery对象都应该指回window.document */
        rootjQuery = jQuery(document);
        
        return jQuery;  // 这个自调用函数会执行一次，返回内部创建好的jQuery对象。
    })();
    
    var flagsCache = {};	// String to Object flags format cache
    
    // Convert String-formatted flags into Object-formatted ones and store in cache
    function createFlags( flags ) {/**  */}
    
    // Create a callback list
    jQuery.Callbacks = function( flags ) {/**  */}
    
    var sliceDeferred = [].slice;	// Static reference to slice
    
    jQuery.extend({
        Deferred: function(func) {/**  */},
        when: function(firstParam) {/**  */} /** Deferred helper */
    });
    
    jQuery.support = (function() {/**  */})();	// 赋值为自调用函数的返回值
    
    jQuery.boxModel = jQuery.support.boxModel;	// Keep track of boxModel
    
    var rbrace = /^(?:\{.*\}|\[.*\])$/,
        rmultiDash = /([A-Z])/g;
    
    
    jQuery.extend({/**  */});
    
    
    function dataAttr(elem, key, data) {/**  */}
    function isEmptyDataObject(obj) {/**  */}   // checks a cache object for emptiness
    function handleQueueMarkDefer(elem, type, src) {/**  */}
    
    jQuery.extend({/**  */});
    
    jQuery.fn.extend({/**  */});
    
    // 定义了多个正则表达式变量
    // var xxx = regex;
    
    jQuery.fn.extend({/**  */});
    jQuery.fn.extend({/**  */});
    
    // Add the tabIndex propHook to attrHooks for back-compat (different case is intentional)
    jQuery.attrHooks.tabindex = jQuery.propHooks.tabIndex;
    
    
    // Hook for boolean attributes
    boolHook = {
        get: function(elem, name) {/**  */},
        set: function(elem, value, name) {/**  */}
    };
    
    // IE6/7 do not support getting/setting some attributes with get/setAttribute
    if ( !getSetAttribute ) {
        /** */
    }
    
    // Some attributes require a special call on IE
    if ( !jQuery.support.hrefNormalized ) {
        /** */
    }
    
    if ( !jQuery.support.style ) {
        /** */
    }
    
    
    // Safari mis-reports the default selected property of an option
    // Accessing the parent's selectedIndex property fixes it
    if ( !jQuery.support.optSelected ) {
        /** */
    }
    
    // IE6/7 call enctype encoding
    if ( !jQuery.support.enctype ) {
    	jQuery.propFix.enctype = "encoding";
    }
    
    // Radios and checkboxes getter/setter
    if ( !jQuery.support.checkOn ) {
        /** */
    }
    jQuery.each(["radio", "checkbox"], function() {
        /** */
    });
    
    // 又是一些正则表达式
    
    
    /*
     * Helper functions for managing events -- not part of the public interface.
     * Props to Dean Edwards' addEvent library for many of the ideas.
     */
    jQuery.event = {
        /** 一些成员属性和成员方法 */
    }
    
    // Some plugins are using, but it's undocumented/deprecated and will be removed.
    // The 1.7 special event interface should provide all the hooks needed now.
    jQuery.event.handle = jQuery.event.dispatch;
    
    jQuery.removeEvent = /**  */;
    
    
    jQuery.Event = function(src, props) {
        /** */
    }
    
    function returnFalse() {return false;}
    function returnTrue() {return true;}
    
    // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
    // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
    jQuery.Event.prototype = {
        /** */
    }
    
    // Create mouseenter/leave events using mouseover/out and event-time checks
    jQuery.each({
        mouseenter: "mouseover",
        mouseleave: "mouseout"
    }, function(orig, fix) {
        /** */
    });
    
    
    // IE submit delegation
    if (! jQuery.support.submitBubbles) {
        /** */
    }
    
    // IE change delegation and checkbox/radio fix
    if ( !jQuery.support.changeBubbles ) {
        /** */
    }
    
    // Create "bubbling" focus and blur events
    if ( !jQuery.support.focusinBubbles ) {
        /** */
    }
    
    jQuery.fn.extend({
        on: function(types, selector, data, fn, /** INTERNAL */one) {/** */},
        one: function(types, selector, data, fn) {/** */},
        off: function(types, selector, fn) {/** */},
        bind: function(types, data, fn) {/** */},
        unbind: function(types, fn) {/** */},
        live: function(types, data, fn) {/** */},
        die: function(types, fn) {/** */},
        delegate: function(selector, types, data, fn) {/** */},
        undelegate: function(selector, types, fn) {/** */},
        trigger: function(type, data) {/** */},
        triggerHandler: function(type, data) {/** */},
        toggle: function(fn) {/** */},
        hover: function(fnOver, fnOut) {/** */}
    });
    
    jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
    	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
    	"change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {
    
    	// Handle event binding
    	jQuery.fn[ name ] = function( data, fn ) {
    		if ( fn == null ) {
    			fn = data;
    			data = null;
    		}
    
    		return arguments.length > 0 ?
    			this.bind( name, data, fn ) :
    			this.trigger( name );
    	};
    
    	if ( jQuery.attrFn ) {
    		jQuery.attrFn[ name ] = true;
    	}
    
    	if ( rkeyEvent.test( name ) ) {
    		jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks;
    	}
    
    	if ( rmouseEvent.test( name ) ) {
    		jQuery.event.fixHooks[ name ] = jQuery.event.mouseHooks;
    	}
    });
    
    /**
     * Sizzle CSS Selector Engine, More info: http://sizzlejs.com
     */
    (function() {
        /** 1.5k 行代码 */
    });
    
    /** 又是一些正则表达式和一些变量的声明 */
    
    jQuery.fn.extend({
        find: function(selector) {/** */},
        has: function(target) {/** */},
        not: function(selector) {/** */},
        filter: function(selector) {/** */},
        is: function(selector) {/** */},
        closest: function(selectors, context) {/** */},
        index: function(elem) {/** */},
        add: function(selector, context) {/** */},
        andSelf: function() {/** */}
    });
    
    // A painfully simple check to see if an element is disconnected
    // from a document (should be improved, where feasible).
    function isDisconnected( node ) {
    	return !node || !node.parentNode || node.parentNode.nodeType === 11;
    }
    
    jQuery.each({
        /** */
    }, function(name, fn) {
        /** */
    });
    
    jQuery.extend({
        filter: function(expr, elems, not) {/** */},
        dir: function(elem, diir, until) {/** */},
        nth: function(cur, result, dir, elem) {/** */},
        sibling: function(n, elem) {/** */}
    });
    
    // Implement the identical functionality for filter and not
    function winnow(elements, qualifier, keep) {
        /** */
    }
    
    function createSafeFragment(document) {
        /** */
    }
    
    /** 又是一些正则表达式和变量的定义 */
    
    
    // IE can't serialize <link> and <script> tags normally
    if ( !jQuery.support.htmlSerialize ) {
    	wrapMap._default = [ 1, "div<div>", "</div>" ];
    }
    
    jQuery.fn.extend({
        /** */
    });
    
    function root(elem, cur) {
        /** */
    }
    
    function cloneCopyEvent(src, dest) {
        /** */
    }
    
    function cloneFixAttributes(src, dest) {
        /** */
    }
    
    jQuery.buildFragment = function(Args, nodes, scripts) {
        /** */
    }
    
    jQuery.fragments = {};
    
    jQuery.each({
        /** */
    }, function(name, original) {
        /** */
    });
    
    function getAll(elem) {
        /** */
    }
    
    // Used in clean, fixes the defaultChecked property
    function fixDefaultChecked(elem) {
        /** */
    }
    
    // Finds all inputs and passes them to fixDefaultChecked
    function findInputs(elem) {
        /** */
    }
    
    jQuery.extend({
        clone: function(elem, dataAndEvents, deepDataAndEvents) {/** */},
        clean: function(elems, context, fragment, scripts) {/** */},
        cleanData: function(elems) {/** */}
    });
    
    function evalScripts(i, elem) {
        /** */
    }
    
    /** 又是一些正则表达式和变量的声明 */
    
    jQuery.fn.css = function(name, value) {
        /** */
    }
    
    jQuery.extend({
        cssHooks: {/** */},
        cssNumber: {/** */},
        cssProps: {/** */},
        style: function(elem, name, value, extra) {/** */},
        css: function(elem, name, extra) {/** */},
        swap: function(elem, options, callback) {/** */}
    });
    
    // DEPRECATED, Use jQuery.css() instead
    jQuery.curCSS = jQuery.css;
    
    jQuery.each(["height", "width"], function(i, name) {
        /** */
    });
    
    if (!jQuery.support.opacity) {
        /** */
    }
    
    jQuery(function() {
        /** */
    });
    
    if ( document.defaultView && document.defaultView.getComputedStyle ) {
        /** */
    }
    
    if (document.documentElement.currentStyle) {
        /** */
    }
    
    curCSS = getComputedStyle || currentStyle;
    
    function getWH(elem, name, extra) {
        /** */
    }
    
    if (jQuery.expr && jQuery.expr.filters) {
        /** */
    }
    
    /** 又是一些正则表达式和变量的定义 */
    
    // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
    function addToPrefiltersOrTransports( structure ) {
        /** */
    }
    
    // Base inspection function for prefilters and transports
    function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR,
        dataType /* internal */, inspected /* internal */ ) {
            /** */
    
    }
    
    function ajaxExtend(target, src) {
        /** */
    }
    
    jQuery.fn.extend({
        load: function(url, params, callback) {/** */},
        serialize: function() {/** */},
        serializeArray: function() {/** */}
    });
    
    jQuery.each("ajaxStart ajaxStop ajaxComplete ......".split(" "), function(i, o) {
        /** */
    });
    
    jQuery.each(["get", "set"], function(i, method) {
        /** */
    });
    
    jQuery.extend({
        /** */
    });
    
    function buildParams(prefix, obj, traditional, add) {
        /** */
    }
    
    // This is still on the jQueery object... for now
    // Want to move this to jQuery.ajax some day
    jQuery.extend({
        active: 0,
        lastModified: {},
        etag: {}
    });
    
    
    /* Handles responses to an ajax request:
     * - sets all responseXXX fields accordingly
     * - finds the right dataType (mediates between content-type and expected dataType)
     * - returns the corresponding response
     */
    function ajaxHandleResponses(s, jqXHR, responses) {
        /** */
    }
    
    // Chain conversions given the request and the original response
    function ajaxConvert(s, response) {
        /** */
    }
    
    var jsc = jQuery.now(),
        jsre = /(\=)\?(&|$)|\?\?/i;
    
    // Default jsonp settings
    jQuery.ajaxSetup({
        jsonp: "callback",
        jsonpCallback: function() {
            return jQuery.expando + "_" + (jsc++);
        }
    });
    
    // Detect, normalize options and install callbacks for jsonp requests
    jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
        /** */
    }
    
    // Install script dataType
    jQuery.ajaxSetup({
        accepts: {/** */},
        contents: {/** */},
        converters: {/** */}
    });
    
    // Handle cache's special case and global
    jQuery.ajaxPrefilter("script", function(s) {
        /** */
    });
    
    // Bind script tag hack transport
    jQuery.ajaxTransport("script", function(s) {
        /** */
    });
    
    
    // #5280: Internet Explorer will keep connections alive if we don't abort on unload
    var xhrOnUnloadAbort = /** */;
    
    // Functions to create xhrs
    function createStandardXHR() {
        try {
            return new window.XMLHttpRequest();
        } catch (e) {}
    }
    
    // Create the request object
    // (This is still attached to ajaxSettings for backward compatibility)
    jQuery.ajaxSettings.xhr = /** */;
    
    
    // Create transport if the browser can provide an xhr
    if (jQuery.support.ajax) {
        /** */
    }
    
    /** 又是一些正则表达式和变量的定义 */
    
    jQuery.fn.extend({
        /** */
    });
    
    // Animations created synchronously will run synchronously
    function createFxNoe() {
        setTimeout(clearFxNoe, 0);
        return (fxNow = jQuery.now());
    }
    function clearFxNoe() {
        fxNow = undefined;
    }
    
    // Generate parameters to create a standard animation
    function getFx(type, num) {
        /** */
    }
    
    // Generate shortcuts for custom animations
    jQuery.each({
        /** */
    }, function(name, props) {
        /** */
    });
    
    jQuery.extend({
        /** */
    });
    
    jQuery.fx.prototype = {
        /** */
    }
    
    jQuery.extend(jQuery.fx, {
        /** */
    })
    
    // Adds width/height step functions
    // Do noe set anything below 0
    jQuery.each(["width", "height"], function(i, prop) {
        /** */
    });
    
    if (jQuery.expr && jQuery.expr.filters) {
        /** */
    }
    
    // Try to restore the default display value of an element
    function defaultDisplay(nodeName) {
        /** */
    }
    
    if ("getBoundingClientRect" in document.documentElement) {
        /** */
    } else {
        /** */
    }
    
    jQuery.offset = {
        bodyOffset: function(body) {/** */},
        setOffset: function(elem, options, i) {/** */}
    }
    
    jQuery.fn.extend({
        position: function() {/** */},
        offsetParent: function() {/** */}
    });
    
    
    jQuery.each(["Left", "Top"], function(i, name) {
        /** */
    });
    
    function getWindow(elem) {
        /** */
    }
    
    // Create width, height, innerHeight, innerWidth, outerHeight and outerWidth methods
    jQuery.each(["Height", "Width"], function(i, naame) {
        var type = name.toLowerCase();
        jQuery.fn["inner" + name] = function() {/** */},
        jQuery.fn["outer" + name] = function(margin) {/** */},
        jQuery.fn[type] = function(size) {/** */}
    });
    
    
    window.jQuery = window.$ = jQuery;  // Expose jQuery to the global object
    
    })( window );

[jQuery]: https://blog.csdn.net/wuyujin1997/article/details/89343432