jq源码解析之绑在$,jQuery上面的方法

1.当我们用$符号直接调用的方法。在jQuery内部是如何封装的呢?有没有好奇心？

// jQuery.extend 的方法 是绑定在 $ 上面的。
jQuery.extend( {

    //expando 用于决定当前页面的唯一性。 /\D/ 非数字。其实就是去掉小数点。
    expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),

    // Assume jQuery is ready without the ready module
    isReady: true,

    // 报错的情况
    error: function( msg ) {
        throw new Error( msg );
    },

    // 空函数
    noop: function() {},

    // 判断是不是一个函数
    isFunction: function( obj ) {
        return jQuery.type( obj ) === "function";
    },

    //判断当前对象是不是window对象。
    isWindow: function( obj ) {
        return obj != null && obj === obj.window;
    },

    //判断obj是不是一个数字 当为一个数字字符串的时候页可以的哦 比如 "3.2"
    isNumeric: function( obj ) {

        var type = jQuery.type( obj );
        return ( type === "number" || type === "string" ) &&

            // 这个话的意思就是要限制 "3afc 这个类型的 字符串"
            !isNaN( obj - parseFloat( obj ) );
    },

    //判断obj 是不是一个对象
    isPlainObject: function( obj ) {
        var proto, Ctor;

        // obj 存在且 toString.call(obj) !== "[object object]"; 就肯定不是一个对象了。
        if ( !obj || toString.call( obj ) !== "[object Object]" ) {
            return false;
        }

        //getProto获取原型链上的对象。 getProto = Object.getPrototypeOf(); 获取原型链上的属性
        proto = getProto( obj );

        // getProto(Object.create(null)) -> proto == null  这种情况也是对象 obj = Object.create(null);
        if ( !proto ) {
            return true;
        }

        // obj 原型上的属性。 proto  上面有 constructor hasOwn = hasOwnPrototypeOf('name') 判断某个对象自身是否有 这个属性
        // Ctor： 当 proto 自身有constructor的时候， 取得constructor 这个属性的value 值。 其实就是 obj的构造函数。 type -> function
        Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
        //Ctor 类型为“function” 且 为构造函数类型吧。 这个时候 obj 也是对象。 我的理解 这个时候，obj = new O(); 其实就是某个构造函数的实列
        return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
    },
    //判断obj是不是一个空对象
    isEmptyObject: function( obj ) {
        //var o = {}
        var name;

        for ( name in obj ) {
            return false;
        }
        return true;
    },
    //获取js的数据类型。 其实方法就是 Object.prototype.toString.call(xx);  xx 就是要检测的某个变量。 得到的结果是 "[object object]" "[object array]" ...
    type: function( obj ) {

        //除去null   和undefined 的情况。 返回本身。 也就是 null  或者 undefined. 因为  undefined == null   ->  true。
        if ( obj == null ) {
            return obj + "";
        }
        //  这个跟typeof xx(某个变量 ) ->  undefined object,number,string,function,boolean(typeof 一个变量只能得到6中数据类型)
        /**
         * 1. obj 是一个对象 或者  obj 是一个 function  那么 直接class2type[toString.call(obj)] 这个话其实是在class2type 中根据key值找到对应的value。
         * class2type = {
         *     [object object]: "object",
         *     [object array]:"array"  ...
         *
         * }
         * 这样类似的值。
         * class2type[toString.call(obj)] || "object" 连起来读就是，在class2type 中找不到类型的值，就直接返回 object
         *
         * 2.或者返回 typeof obj。的数据类型。  -> number, string,boolean  基本数据了类型吧。 (js 中有5中基本数据类型。 null ,undefined,number,string,boolean)
         */
        return typeof obj === "object" || typeof obj === "function" ?
            class2type[ toString.call( obj ) ] || "object" :
            typeof obj;
    },

    // 翻译为：全局的Eval函数。 说句实话。没有看懂这个是拿来干嘛的。 DOMval();
    /**
     *
     * @param code
     * function DOMEval( code, doc ) {
        doc = doc || document;

        var script = doc.createElement( "script" );

        script.text = code;
        doc.head.appendChild( script ).parentNode.removeChild( script );
    }
     创建一个 script标签， 或remove 这个标签。 目前没有搞懂拿来干嘛用。
     */
    globalEval: function( code ) {
        DOMEval( code );
    },

    // 这个是用来转为 驼峰的用函数吧。 ms-  前缀转为驼峰的吧。
    camelCase: function( string ) {
        return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
    },

    // each 方法。 $.each(obj,function(){}); 用于循环数组和对象的方法。
    each: function( obj, callback ) {
        var length, i = 0;

        if ( isArrayLike( obj ) ) { // 当obj 是一个数组的时候执行这个方法
            length = obj.length;
            for ( ; i < length; i++ ) {

                /*当$.each(obj,function(i,item){
                        if( i = 2){
                            return false。
                        }
                  })
                    当$.each(obj,function(){}) 中的匿名函数中纯在 return false； 的时候跳出循环。
                */
                if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
                    break;
                }
            }
        } else {  // for in  循环对象。 callback.call(obj[i],i,obj,[i]) === false 跟数组循环是一道理
            for ( i in obj ) {
                if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
                    break;
                }
            }
        }

        return obj;
    },

    // 去掉 text 两边的空白字符 $("input").val().trim() 一个道理吧。  text + ""  其实是为了把 text 转成一个字符串。 类型这种情况 123.replace(rtrim,"") 是会报错的。
    // 如果 123 + "" 其实变成了 "123"
    trim: function( text ) {
        return text == null ?
            "" :
            ( text + "" ).replace( rtrim, "" );
    },

    // $.makeArray 其实是将类数组转换成数组 对象。
    /**
     *
     *
     * @param arr
     * @param results
     * @returns {*|Array}
     * 比如： var b = document.getElementsByTagName("div"); b.reverse() 。 用b 来调reserver() 方法会直接报错的。因为这个时候b是类数组对象。
     * var a = $.makeArray(document.getElementsByTagName("div")); a.reverser()。 这样就不会报错了。
     *
     */
    makeArray: function( arr, results ) {
        var ret = results || [];

        if ( arr != null ) {
            if ( isArrayLike( Object( arr ) ) ) {
                jQuery.merge( ret,
                    typeof arr === "string" ?
                    [ arr ] : arr
                );
            } else {
                push.call( ret, arr );
            }
        }

        return ret;
    },

    /**
     *
     * @param elem   要检测的值
     * @param arr  待处理的数组
     * @param i   从待处理的数组的第几位开始查询. 默认是0
     * @returns {number}   返回 -1 。表示arr 中没有该value值， 或者该值的下表
     * $.inArray()。
     *
     */
    inArray: function( elem, arr, i ) {

        //如果arr 为 null 直接返回 -1 。
        /**
         *  对indxOf.call(arr,elem,i);方法的解释
         *  var s = new String();
         *  eg: var indexOf = s.indexOf;   用indexOf 变量来存字符串中的 indexOf的方法。
         *  indexOf.call(arr,elem,i) ; 其实就是把字符串的indexOf 继承给数组，并且传递 elem  和 i 参数。
         *  更简单一点其实可以理解为: arr.indexOf(elem,i);
         */
        return arr == null ? -1 : indexOf.call( arr, elem, i );
    },

    // 合并数组
    /**
     *
     * @param first  第一个数组
     * @param second 第二个数组
     * @returns {*}
     */
    merge: function( first, second ) {
        var len = +second.length,  //第二个数组的长度
            j = 0,   //j 从0 开始
            i = first.length; //第一个数组的长度

        for ( ; j < len; j++ ) {
            first[ i++ ] = second[ j ];
        }
        // 其实用push 应该可以吧。

        first.length = i;

        return first;
    },
    /**
     *
     * @param elems  带过滤的函数
     * @param callback  过滤的添加函数
     * @param invert   来决定 $.grep(arr,callback) 返回来的数组，是满足条件的还是不满足条件的。  true 是满足条件的。 false 是不满足条件的。
     * @returns {Array}
     *
     * 返回一个数组。
     */
    grep: function( elems, callback, invert ) {
        var callbackInverse,
            matches = [],
            i = 0,
            length = elems.length,
            callbackExpect = !invert;

        // Go through the array, only saving the items
        // that pass the validator function
        for ( ; i < length; i++ ) {
            callbackInverse = !callback( elems[ i ], i );
            if ( callbackInverse !== callbackExpect ) {
                matches.push( elems[ i ] );
            }
        }

        return matches;
    },

    /**
     *
     * @param elems   带处理的数组
     * @param callback  回调函数
     * @param arg   这参数用在callback回调函数的。
     * callback(elems[i],i,arg)
     * @returns {*}
     *
     * $.map(arr,function(item,i,arg){},arg)
     * 将一个数组，通过callback 转换成另一个数组。
     * eg: var b = [2,3,4];
     * var a = $.map(b,function(item,i,arg){
     *         return item + arg;
     * },1)
     * console.log(a)  [3,4,5]
     */
    map: function( elems, callback, arg ) {
        var length, value,
            i = 0,
            ret = [];

        // Go through the array, translating each of the items to their new values
        if ( isArrayLike( elems ) ) {
            length = elems.length;
            for ( ; i < length; i++ ) {
                value = callback( elems[ i ], i, arg );

                if ( value != null ) {
                    ret.push( value );
                }
            }

        // Go through every key on the object,
        } else {
            for ( i in elems ) {
                value = callback( elems[ i ], i, arg );

                if ( value != null ) {
                    ret.push( value );
                }
            }
        }

        // Flatten any nested arrays
        return concat.apply( [], ret );
    },

    // 对对象的一个全局标志量吧。 没搞懂具体用处
    guid: 1,

    // Bind a function to a context, optionally partially applying any
    // arguments.
    /**
     *
     * @param fn
     * @param context
     * @returns {*}
     *
     * es6也提供了 new Proxy() 。对象。
     */
    proxy: function( fn, context ) {
        var tmp, args, proxy;
        //当content是字符串的时候 
        if ( typeof context === "string" ) {
            tmp = fn[ context ];
            context = fn;
            fn = tmp;
        }

        // Quick check to determine if target is callable, in the spec
        // this throws a TypeError, but we will just return undefined.
        if ( !jQuery.isFunction( fn ) ) {
            return undefined;
        }

        // Simulated bind
        args = slice.call( arguments, 2 );
        proxy = function() {
            return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
        };

        // Set the guid of unique handler to the same of original handler, so it can be removed
        proxy.guid = fn.guid = fn.guid || jQuery.guid++;

        return proxy;
    },
    //$.now 当前时间搓
    now: Date.now,

    // jQuery.support is not used in Core but other projects attach their
    // properties to it so it needs to exist.
    /**
     * 检测浏览器是否支持某个属性
     * $.support.style
     */
    support: support
} );