下面对这些方法进行讲解
each():遍历集合
trim():去前后空格
makeArray():类数组转换真数组
inArray():数组版indexOf
merge()：合并数组
grep():过滤新数组
map():映射新数组
each方法：
each是遍历集合用的方法，也是一个加强版的循环操作。例如：
var arr = { Name: ‘jam‘, Age: 15 };
$.each(arr, function (key, val) {
console.log(key + ":" + val); //Name:jam Age:15
})
each方法不仅可以对数组，类数组进行遍历，还可以对json对象进行遍历。源码：
// args is for internal usage only
each: function( obj, callback, args ) {
var value,
i = 0,
length = obj.length,
isArray = isArraylike( obj );
if ( args ) {
if ( isArray ) {
for ( ; i < length; i++ ) {
value = callback.apply( obj[ i ], args );
if ( value === false ) {
break;
}
}
} else {
for ( i in obj ) {
value = callback.apply( obj[ i ], args );
if ( value === false ) {
break;
}
}
}
// A special, fast, case for the most common use of each
} else {
if ( isArray ) {
for ( ; i < length; i++ ) {
value = callback.call( obj[ i ], i, obj[ i ] );
if ( value === false ) {
break;
}
}
} else {
for ( i in obj ) {
value = callback.call( obj[ i ], i, obj[ i ] );
if ( value === false ) {
break;
}
}
}
}
return obj;
},
可以看到这个方法，实际接收了三个参数，最后一个参数为内部使用，我们在外部使用的时候只需要两个参数就够了。
首先第一个部分是声明内部用到的变量：
var value,
i = 0,
length = obj.length,
isArray = isArraylike( obj );
前三个参数没什么说的，主要看一下isArray这个变量，通过isArraylike这个方法，可以判断是否为数组或类数组，如果是，则返回true。
接下来进行判断args，用来区分是否为内部调用：
if ( args ) {
//源码
} else {
//源码
}
先看一下满足条件里面的源码，也就是内部使用的都做了什么:
if ( isArray ) {
for ( ; i < length; i++ ) {
value = callback.apply( obj[ i ], args );
if ( value === false ) {
break;
}
}
} else {
for ( i in obj ) {
value = callback.apply( obj[ i ], args );
if ( value === false ) {
break;
}
}
}
先看传入的对象是否为数组或类数组，如果是则遍历这个对象，然后将当前项和参数传入回调方法，进行回调。
如果不满足条件，那么就是json对象，所以进行for in遍历，然后执行相同的操作，这里看到回调方法会返回一个值,如果为false，则跳出循环，所以如果想则each方法跳出循环是，直接return false;就可以了
接下来看一下我们平时使用的代码：
if ( isArray ) {
for ( ; i < length; i++ ) {
value = callback.call( obj[ i ], i, obj[ i ] );
if ( value === false ) {
break;
}
}
} else {
for ( i in obj ) {
value = callback.call( obj[ i ], i, obj[ i ] );
if ( value === false ) {
break;
}
}
}
代码和上面内部使用的没有太大的区别，只不过调用回调方法时传入的参数不一样，另外这个方法使用了call，内部方法使用的是apply，也就是说在jQuery内部，传入的参数个数可能不一样，而我们使用时，只需要传入两个就可以了。
trim方法：
trim 方法是对字符串去前后空格的方法,在平时经常使用这个方法，源码：
trim: function( text ) {
return text == null ? "" : core_trim.call( text );
},
源码很简单，如果传入的字符串为null或undefined，则直接返回空字符就可以了，如果有值，则直接调用es5的trim方法就行。这个core_trim指向的是原生的trim方法。
core_trim = core_version.trim,
makeArray方法：
这个方法可以将类数组转换成真正的数组，方法有两个参数，如果传入第二个参数，则返回类数组。
页面中有三个div，分别是1、2、3
window.onload = function () {
var divs = document.getElementsByTagName(‘div‘);
console.log($.makeArray(divs));//[div, div, div]
}
传入第二个参数时：
window.onload = function () {
var divs = document.getElementsByTagName(‘div‘);
console.log($.makeArray(divs, { length: 1 }));//Object {1: div, 2: div, 3: div, length: 4}
}
下面看一下源码：
// results is for internal usage only
makeArray: function( arr, results ) {
var ret = results || [];
if ( arr != null ) {
if ( isArraylike( Object(arr) ) ) {
jQuery.merge( ret,
typeof arr === "string" ?
[ arr ] : arr
);
} else {
core_push.call( ret, arr );
}
}
return ret;
},
首先检查是否传入第二个参数，如果为空，则给一个空数组。然后查看参数是否为数组或类数组。注意这里：
if ( isArraylike( Object(arr) ) ) {
这里将参数外面包一层object，是将参数转换为对象，如果传入数字，则返回false，如果传入的是字符串，那么会返回true，因为字符串被转成对象了，并且有长度。
然后通过merge方法进行附加，把传入的参数合并到ret中。
如果不为数组或类数组，则直接用数组的push将参数附加到数组中即可。
inArray方法：
这个方法和数组的indexof功能一样，返回查找值的索引：
var arr = [‘a,‘, ‘b‘, ‘c‘];
console.log($.inArray(‘c‘,arr,0)); //2
源码如下：
inArray: function( elem, arr, i ) {
return arr == null ? -1 : core_indexOf.call( arr, elem, i );
},
源码很简单，第一个参数是要查找的值，第二个是对象，第三个是从第几项开始查找。然后调用数组的indexOf方法。
merge方法：
这个方法经常用到，可以将两个数组合并成一个。
var arr1 = [‘a‘, ‘b‘];
var arr2 = [‘c‘, ‘d‘];
var arr3 = $.merge(arr1, arr2);
console.log(arr3);//["a", "b", "c", "d"]
另外第二个参数还可以传入一个类数组。
var arr1 = [‘a‘, ‘b‘];
var arr2 = { 0: ‘c‘, 1: ‘d‘};
var arr3 = $.merge(arr1, arr2);
console.log(arr3);//["a", "b", "c", "d"]
当第一个参数为类数组时：
var arr1 = [‘a‘, ‘b‘];
var arr2 = { 0: ‘c‘, 1: ‘d‘ };
var arr3 = $.merge(arr2, arr1);
console.log(arr3);////Object {0: "c", 1: "d", 2: "a", 3: "b", length: 4}
看到，当第一个参数为类数组时，返回的也就类数组的形式。
源码如下：
merge: function( first, second ) {
var l = second.length,
i = first.length,
j = 0;
if ( typeof l === "number" ) {
for ( ; j < l; j++ ) {
first[ i++ ] = second[ j ];
}
} else {
while ( second[j] !== undefined ) {
first[ i++ ] = second[ j++ ];
}
}
first.length = i;
return first;
},
先获取两个参数的长度，如果第二个参数有值，并且是数字类型的话，那么直接遍历第二个数组，附加到第一个上即可。
如果第二个参数没有长度，也就是可能是json对象，那么直接遍历，这里需要注意，即使是json对象，那么里面的属性名也必须是1、2、3。例如：
var arr2 = { 0: ‘c‘, 1: ‘d‘ };
最后更新长度，并返回合并后的对象。
grep方法：
grep方法是对数组进行筛选，只返回满足条件的值。例如：
var arr = [1, 2, 3, 4, 5];
arr=$.grep(arr,function(v,i){
return v>2;
});
console.log(arr);//[3, 4, 5]
另外这个方法还接受第三个参数，如果传入，那么代表筛选条件进行反转。例如上面的例子中，如果传入第三个参数，那么筛选的条件实际业绩刘是v<=2。
源码：
grep: function( elems, callback, inv ) {
var retVal,
ret = [],
i = 0,
length = elems.length;
inv = !!inv;
// Go through the array, only saving the items
// that pass the validator function
for ( ; i < length; i++ ) {
retVal = !!callback( elems[ i ], i );
if ( inv !== retVal ) {
ret.push( elems[ i ] );
}
}
return ret;
},
先对判断第三个参数是否传入，如果没传，那么!!inv则为false。然后遍历传入的对象，并将每项都传入回调方法中，最后利用inv进行控制，当inv为false的时候，也就是没传入第三个参数时，
那么回调函数返回结果为true时，则添加到返回的ret中，这里用到:
if ( inv !== retVal ) {
ret.push( elems[ i ] );
}
这个判断，使代码非常灵活。
map方法，这个方法是返回操作后的一个新数组，例如：
var arr = [1, 2, 3, 4, 5];
arr=$.map(arr,function(v,i){
return v * 2;
});
console.log(arr);//[2, 4, 6, 8, 10]
使用很简单，来看下源码：
// arg is for internal usage only
map: function( elems, callback, arg ) {
var value,
i = 0,
length = elems.length,
isArray = isArraylike( elems ),
ret = [];
// Go through the array, translating each of the items to their
if ( isArray ) {
for ( ; i < length; i++ ) {
value = callback( elems[ i ], i, arg );
if ( value != null ) {
ret[ ret.length ] = value;
}
}
// Go through every key on the object,
} else {
for ( i in elems ) {
value = callback( elems[ i ], i, arg );
if ( value != null ) {
ret[ ret.length ] = value;
}
}
}
// Flatten any nested arrays
return core_concat.apply( [], ret );
},
方法接收三个参数，第三个参数是jQuery内部使用的，平时一般用不到。
接下来判断传入的参数是否为数组或类数组，如果是：
for ( ; i < length; i++ ) {
value = callback( elems[ i ], i, arg );
if ( value != null ) {
ret[ ret.length ] = value;
}
}
遍历这个对象，并将每项传入回调方法中，最后将回调方法的返回值放入定义好的ret中。
如果不是数组或类数组：
for ( i in elems ) {
value = callback( elems[ i ], i, arg );
if ( value != null ) {
ret[ ret.length ] = value;
}
}
利用for in 循环这个对象每项，并将每项传入回调方法中，最后将回调方法的返回值放入定义好的ret中。
最后返回这个新对象：
// Flatten any nested arrays
return core_concat.apply( [], ret );
可以看到这里使用到了数组的concat方法，而不是直接返回ret，这是因为这个方法不想返回嵌套数组的结构，例如：
var arr = [1, 2, 3, 4, 5];
arr=$.map(arr,function(v,i){
return [v * 2];
});
console.log(arr);//[2, 4, 6, 8, 10]
如果回调方法返回的就是数组，那么经过这个处理还是返回一个数组的结构，如果将源码中的最后一句替换掉：
// Flatten any nested arrays
//return core_concat.apply( [], ret );
return ret;
那么返回的是：[[2], [4], [6], [8], [10]]这种形式了。