jQuery实际上就是一个js函数库，对象jQuery作为window对象的一个属性封装了大量具有特定功能的函数。jQuery的代码很长，它是一个历史积累的过程，因此分析jQuery源代码就需要从其历史发展的过程来看，从简到繁，从少到多，去分析就容易得多了。
1.使用函数来封装用户代码
(function () {} )();这段代码定义了一个匿名函数，并在js加载完毕之后执行一次。这样编写代码的目的就是使用函数作用域来隔离自己与他人的代码，防止污染到函数之外的代码。
2.对象继承
js中的对象分为function、object两种。系统会自动为构造函数对象创建一个原型对象，并由由成员porototype指向，同时原型对象也有一个成员constructor指向构造对象。
js内置的对象有：Object、Array、Boolean、Number、String、Function、Argument、Math、Date、RegExp、Error。
(1)普通对象（object）
proto:指向构造自己的构造函数对象的原型对象
(2)构造对象（function）
proto:指向构造自己的构造函数对象的原型对象
prototype:指向自己的原型对象
(3)原型对象（object）
proto:指向构造自己的构造函数对象的原型对象
constructor:指向自己的构造函数对象
通过模拟类的特性，我们可实现继承和复用。实现继承的方式主要有一下4种：
构造继承
原型继承
实例继承
拷贝继承
下面展示的是构造继承，通过一个工厂类来实现
(function () {
// 定义一个工厂类 factory
// 工厂类构造函数
var factory = function () {}
// 私有成员定义，子类无法继承此成员
factory.wheels = 4;
// 公共成员定义，子类可以继承此成员
factory.prototype.add = function(){}
// 工厂方法创建一个对象
var o = new factory();
// o可以调用factory.prototype.add
// o.__proto__ -> factory.prototype
o.add();//o自身不存在add方法时系统会通过o.__proto__即原型链不断去查找，如果找不到就报错。
} )();分析jQuery源码最基本结构，就是这么实现的
(function (window, undefined ) {
var
rootjQuery,
jQuery = function( selector, context ) {
return new jQuery.fn.init( selector, context, rootjQuery);
}
jQuery.fn = jQuery.prototype = {
constructor: jQuery,
init: function( selector, context, rootjQuery ) {
return this;
}
}
jQuery.fn.init.prototype = jQuery.fn;
/////////////////////////////////////////
// jQuery私有成员区开始
jQuery.merge = function () {}
// jQuery私有成员区结束
/////////////////////////////////////////
/////////////////////////////////////////
// jQuery公共成员区开始
jQuery.fn.merge = function () {}
// jQuery公共成员区结束
/////////////////////////////////////////
window.jQuery = window.$ = jQuery;
})(window);首先，定义了构造函数jQuery
var jQuery = function ( selector, context ) {}这与下面的实现方式是一样的：
function jQuery ( selector, context ) {}参数selector为选择字符串（类似于CSS选择器），context用于保存上下文环境。
紧接着：
window.jQuery = window.$ = jQuery;
这段代码用于将jQuery注册为window下的成员，即全局成员，同时用$替换jQuery，所以就有了我们经常使用的$("div")就可以直接返回一个jQuery对象，显得更为方便简洁。
每次调用$()都会返回一个新的jQuery对象，避免使用同一个对象产生干扰和修改。它采用的思路是：
return new jQuery.fn.init( selector, context, rootjQuery);
每次调用$()，都会new一个jQuery.fn.init对象，这里解释一下jQuery.fn，从后面代码
jQuery.fn = jQuery.prototype = {}可以看出，jQuery就是和jQuery.prototype一样对同一个原型对象的引用，定义为fn也是function的简写，一方面是为了书写方便，另一方面我们从命名可以看出fn主要是用来为jQuery的原型对象增加公共方法，用于子对象的继承。
作者为jQuery.prototype新创建了一个自定义对象，因此在匿名对象内部需要增加这部分代码，确保原型对象指回jQuery这个构造对象本身，确保完整。：
constructor: jQuery
通过jQuery.fn.init构造出一个对象，然后将其引用返回，也就是说，我们通过$()返回的是指向jQuery.fn.init构造的对象的一个引用。那么这个对象的proto应该就是指向jQuery.fn.init.prototype，也就是说
$().__proto__ = jQuery.fn.init.prototype;
我们都知道，jQuery有个连缀操作，也就是说可以下面代码这样一直写下去：
$("div").eq(0).css("color","red");但是$().proto 指向了 jQuery.fn.init.prototype，要想实现连缀操作，我们就必须让jQuery.fn.init.prototype指向jQuery.prototype，因此才有了后面这段代码：
jQuery.fn.init.prototype = jQuery.fn;
这样一来的话，通过$()构造出来的对象，其原型对象就是jQuery的原型对象，即：
$().__proto__ = jQuery.prototype;
$()就可以连缀操作jQuery的公共方法。
3.jQuery.extend 和 jQuery.fn.extend
之前我们分析了jQuery源码的基本结构，了解了如何为jQuery添加公共方法和私有方法。
//私有方法定义 jQuery.merge = function () {}
//公共方法定义 jQuery.fn.merge = function () {}(1)实现自己的添加函数
jQuery.extend = function () {
var
copy,
options = arguments[0] || {};
if ( typeof options === "object" && typeof options === "function" ) {
for ( key in options) {
copy = options[key];
if ( this === copy ) { continue; }
if ( copy !== undefined ) {
this[key] = copy;
}
}
}
return this;//实现连缀操作 }
jQuery.fn.extend = function () {
var
copy,
key,
options = arguments[0] || {};
if ( typeof options === "object" && typeof options === "function" ) {
for ( key in options) {
copy = options[key];
if ( this === copy ) { continue; }
if ( copy !== undefined ) {
this[key] = copy;
}
}
}
return this;//实现连缀操作 }jQuery.extend 和 jQuery.fn.extend 实现的代码完全一致，现在考虑一下是否可以将其合并。
当我们调用jQuery.extend的时候，this是jQuery，即为jQuery进行扩展；当调用jQuery.fn.extend的时候，this是jQuery.fn，即为jQuery.fn（jQuery.prototype进行扩展）。因此，我们可以将其进行合并，即：
`
jQuery.extend = jQuery.fn.extend = function () {
var
copy,
key,
options = arguments[0] || {};
if ( typeof options === "object" && typeof options === "function" ) {
for ( key in options ) {
copy = options[key];
if ( this === copy ) { continue; }
if ( copy !== undefined ) {
this[key] = copy;
}
}
}
return this;
}(2)实现对象的合并
obj1 = {id:1,address:"China",owner:{age:30}}
obj2={age:25,owner:{name:"liebert"}}
objcombine = {id:1,address:"China",age:25,owner:{name:"liebert",age:30}}循环遍历被合并对象成员，设每次循环得到的成员为copy，同时取出接收合并对象的相同key的成员，记为src。对象obj1的成员不能指向对象A本身，因此，首先检测待合并对象成员
if ( obj1 === copy ) { continue; }如果对象合并采取浅拷贝的方式，直接进行赋值操作即可
obj1[key] = copy;
如果对象合并采取深拷贝的方式，需要进行递归拷贝，不是所有的变量都需要进行深拷贝，普通的变量是不需要进行深拷贝的，也就是存储在栈空间的变量。深拷贝针对的是object
jQuery.extend = function () { var
key,
src,
copy,
isDeep,
copyIsArray,
i = 1,
length = arguments.length;
target = arguments[0] || {}; if ( typeof target === "boolean" ) { //isDeep参数存在，并获取
isDeep = target; //如果isDeep参数存在，需要调整接收合并对象为第二个参数
target = arguments[1] || {}; //待合并的对象为第三个参数，即索引为3-1=2
i = 2;
} for ( ; i < length; i++ ) { if ( (options = arguments[i]) != null) {} for( key in options ) {
src = target[key];
copy = options[key]; if ( target === copy ) { continue; } if ( isDeep && copy && (typeof copy === "object" || copyIsArray = Array.isArray(copy) ) ) { if ( copyIsArray ) {
clone = src && Array.isArray(src) ? src : [] ;
copyIsArray = false;
} else {
clone = src && typeof src ? src : {} ;
}
target[key] = jQuery.extend( isDeep, clone, copy );
} else {
target[key] = copy;
}
}
} return target;
}(3)对比jQuery中extend的实现
为了方便jQuery方法的添加，jQuery定义了jQuery.extend和jQuery.fn.extend两个方法。
jQuery.extend = jQuery.fn.extend = function () { var
//对待合并对象的临时引用
options,
//键名
key, //接收拷贝的变量
src, //待拷贝的变量
copy, //接收拷贝的临时变量
clone, //待复制的变量是否为数组
copyIsArray, //默认为将取第i+1=2个参数
i = 1,
isDeep = false,
target = arguments[0] || {},
length = arguments.length; // 处理深拷贝情况
if ( typeof target === "boolean" ) {
isDeep = target;
target = arguments[1] || {};
i = 2;
} //处理字符串情况
if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
target = {};
} //如果只有一个参数，就是扩展jQuery自己，修改索引i = 0，target指向jQuery或者jQuery.fn
//当调用jQuery.extend时，this为jQuery；当调用jQuery.fn.extend时，this为jQuery.fn
if ( length === i) {
target = this;
--i;
} for ( ; i < length; i++ ) { //处理非null和undefined类型的变量
if ( (options = arguments[i]) != null ) { for ( key in options ) {
src = target[key];
copy = options[key]; if ( target === copy ) {continue;} //指定了要进行深拷贝
//待拷贝的变量有效
//待拷贝的变量为对象或数组，只有对象或数组才可以做深拷贝的
if ( isDeep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) { //处理数组
if( copyIsArray ) {
copyIsArray = false;
clone = src && jQuery.isArray(src) ? src : []; //处理对象
} else {
clone = src && jQuery.isPlainObject(src) ? src : {};
} //递归处理
target[key] = jQuery.extend( isDeep, clone, copy);
} else if ( copy !== undefined ) {
target[key] = copy;
}
}
}
}// end for
return target;
}先对函数的入口参数进行说明：
jQuery.extend( [isDeep], target[,object1,..., objectN] )
isDeep：用于指定是否进行深拷贝，是一个可选参数，默认为false，即不进行深拷贝
target：接收拷贝对象，如果不指定object1以及后续的对象，则是对jQuery本身进行扩展
object1：待合并到target中的对象
再来谈一谈具体的处理思路：
首先，对参数的第一个入口参数arguments[0]进行判断，如果为布尔类型就说明指定了isDeep这个参数；
var target = arguments[0] || {};
if ( typeof target === "boolean" ) {
//获取参数中的isDeep值
isDeep = target;
//获取接收拷贝的对象引用
target = arguments[1] || {};
//设定拷贝的起始索引，从函数的第三参数开始，跳过isDeep和target
i = 2;
}其次，检测target对象类型，如果不是object或function，则需要创建一个新的对象用于接收
if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
target = {};
}再者，检测一个参数存在的情况，如果是，则视为对jQuery或jQuery.fn本身进行扩展
if ( length === i ) {
target = this,
--i;
}接着，开始进行对象的合并。待合并的对象总共有length个，因此需要循环length-i次
for ( ; i < length; i++ ) { //处理非null和undefined类型的变量
if ( (options = arguments[i]) != null ) { for ( key in options ) {
src = target[key]; copy = options[key]; if ( target === copy ) {continue;} //指定了要进行深拷贝 (isDeep === true)
//待拷贝的变量有效 (copy !== null || copy !==undefined)
//待拷贝的变量为对象或数组，只有对象或数组才可以做深拷贝的
if ( isDeep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) { //处理数组
if( copyIsArray ) {
copyIsArray = false;
clone = src && jQuery.isArray(src) ? src : []; //处理对象
} else {
clone = src && jQuery.isPlainObject(src) ? src : {};
} //递归处理
target[key] = jQuery.extend( isDeep, clone, copy);
} else if ( copy !== undefined ) {
target[key] = copy;
}
}
}
}// end for最后，返回合并后的对象
return target;
4.实现CSS选择器功能
js为我们提供了如下三个函数，用于实现DOM节点的选择：
getElementById();
getElementsByClassName();
getElementsByTagName();
但是这三个函数的名字太长了，不容易记忆，使用过程中也容易出错，更重要的是不能够向CSS选择器那样，通过一连串的选择符实现节点的选择，因此我们想到通过js现有的函数去模拟CSS选择器。
function ( window ) { var
rquickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
jQuery = function ( selector ) { return new jQuery.fn.init( selector );
} /////////////////////////////////////////////////////
// jQuery private defination
// jQuery私有成员区开始
jQuery.type = function ( obj ) { return obj == null ? String(obj) : obj.toString();
}
jQuery.isWindow = function () {
}
jQuery.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;
}
jQuery.makeArray = function( arr, results ) { var type,
ret = results || []; if ( arr != null ) {
type = jQuery.type( arr ); if ( arr.length == null || type === "string" || type === "function" || type === "regxp" || jQuery.isWindow( arr ) ) {
} else {
jQuery.merge( ret, arr );
}
} return ret;
}// end of jQuery.makeArray
jQuery.find = function ( selector ) { if ( typeof selector !== "string" ) {}
} // jQuery私有成员区结束
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
// jQuery public defination
// jQuery公共成员区开始
jQuery.fn = jQuery.prototype = { constructor: jQuery, length:0, selector:"", init:function ( selector, context ) { var match, elem; // 规避$(""), $(null), $(undefined), $(false)
if ( !selector ) { return this;
} // 处理HTML节点选择字符串
if ( typeof selector === "string" ) { // 如果为html标签比如"<p>html</p>"
if ( selector.charAt(0) ==="<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >=3 ) {
match = [null, selector, null];
} else {
match = rquickExpr.exec( selector );
}
} // 处理匹配了html标签
if ( match && (match[1] || !context) ) { if( match[1] ) { if ( match[1] ) {
context = context instanceof jQuery ? context[0] : context;
doc = ( context && context.nodeType ? context.ownerDocument || context : document );
}
} else {
elem = document.getElementById( match[2] ); if ( elem && elem.parentNode ) { //return rootjQuery.find( selector );
this.length = 1; this[0] = elem;
}
this.context = document; this.selector = selector; return this;
}
} else if ( !context || context.jquery) { return ( context || rootjQuery ).find( selector );
} else { return this.constructor( context ).find( selector );
} return jQuery.makeArray( selector, this );
}, eq: function( i ){
i = +i; return i === -1 ? this.slice( i ) : this.slice( i, i+1 );
}, slice: function() { return this.pushStack(Array.prototype.slice.apply( this, arguments ), "slice", Array.prototype.slice.call(arguments).join(","));
}, pushStack: function( elems, name, selector ) { // Build a new jQuery matched element set
var ret = jQuery.merge( this.constructor(), elems );
ret.context = this.context; if ( name === "find" ) {
ret.selector = this.selector + ( this.selector ? " " : "") + selector;
} else if ( name ) {
ret.selector = this.selector + "." + name + "(" + selector + ")";
} return ret;
}
}// end of jQuery.prototype
// jQuery公共成员区结束
/////////////////////////////////////////////////////
jQuery.fn.init.prototype = jQuery.fn; //Expose jQuery to the global
window.jQuery = window.$ = jQuery;
} )(window);5.each函数分析
(1)apply和call区别
// obj：这个对象将替代Function类里的this对象// args：必须是数组变量，只能接受数组格式的参数Function.apply( obj, args )
call对参数没有要求
(2)each函数参数分析
obj：待遍历的对象列表
callback：回调函数，由obj列表中的对象进行调用
args：可选的回调函数参数
(3)each函数功能分析
each函数用于遍历对象列表中对象，每一次遍历都执行一个过程（也称为函数）,这个过程作用于当前遍历到的对象，也就是说这个过程中的this为当前对象。
jQuery.extend({ each: function ( obj, callback, args ) { var name,
i = 0,
length = obj.length,
isObj = length === undefined; if ( args ) { if ( isObj ) { for ( key in obj ) { if ( callback.apply( obj[key], args) === false ) { break;
}
}
} else { for ( ; i < length; i++ ) { if ( callback.apply( obj[key], args ) === false ) { break;
}
}
}
} else { if ( isObj ) { for ( key in obj ) { if ( callback.call( obj[key], key, obj[key] ) === false ) { break;
}
}
} else { for ( ; i < length; i++ ) { if ( callback.call( obj[i], i, obj[i] ) === false ) { break;
}
}
}
}
}
});
jQuery.fn.extend({ each: function ( callback, args ) { return jQuery.each( this, callback, args );
}
});6.parseXML函数分析
(1)功能分析
parseXML函数主要用于对XML文件进行解析，因为IE和其他浏览器对XML文件提供了不同方法进行解析，jQuery对XML文件进行了封装，兼容各个浏览器差异性，对用户提供统一的操作接口。
(2)代码分析
jQuery.extend( { error: function ( msg ) { throw new Error( msg );//报错
}, parseXML: function ( data ) { var domParser, xml; // 首先对参数进行校验，必须为字符串类型
if ( !data || typeof data !== "string" ) { return null;
} try { //检测浏览器window对象是否提供DOM节点解析对象，IE是不提供的，针对不同浏览器提供的方法对XML字符串进行解析，生成XML对象
if ( window.DOMParser ) {
domParser = new DOMParser();
xml = domParser.parseFromString( data, "text/xml" );
} else {
xml = new ActiveXObject( "Microsoft.XMLDOM" );
xml.async = "false";
xml.loadXML( data );
}
} catch (e) {
xml = undefined;
} //检测xml合法性，报告错误
if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
jQuery.error( "Invalid XML: " + data );
} return xml;
}
} );8.find函数分析
jQuery.find = Sizzle;function Sizzle( selector, context, results,seed ) { //参数过滤
results = results || [];
context = context || document; var
nodeType = context.nodeType; if ( !selector || typeof selector !== "string" ) { return results;
} if ( nodeType != 1 && nodeType != 9 ) { return [];
}
}9.data函数
jQuery.fn.extend({ data: function ( key, value ) { var
elem = this[0]; //获取全部值
if ( key === undefined ) { if ( this.length ) {
data = jQuery.data( elem ); if ( elem.nodeType === 1 && !jQuery._data(elem, "parsedAttrs") ) {
attr = elem.attributes; for ( ; i < attr.length; i++ ) {
name = attr[i].name; if ( !name.indexOf( "data-" ) ) {
name = jQuery.camelCase( name.substring(5) );
dataAttr( elem, name, data[name] );
}
}
jQuery._data( elem, "parsedAttrs", true );
}
} return data;
} if ( typeof key === "object" ) { return this.each(function(){
jQuery.data( this, key );
});
}
parts = key.split( ".", 2 );
parts[1] = parts[1] ? "." + parts[1] : "";
part = parts[1] + "!"; return jQuery.access();
}
});
jQuery.extend({ data: function( elem, name, value ) {
}
});10.词法分析器
词法分析匹配正则对象集合
whitespace = "[\\x20\\t\\r\\n\\f]";
characterEncoding = "(?:\\\\.|[-\\w]|[^\\x00-\\xa0])+";
identifier = characterEncoding.replace( "w", "w#" );
attributes = "\\[" + whitespace + "*(" + characterEncoding + ")" + whitespace + "*(?:" + operators + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]";
matchExpr = { "ID": new RegExp( "^#(" + characterEncoding + ")" ), "CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ), "NAME": new RegExp( "^\\[name=['\"]?(" + characterEncoding + ")['\"]?\\]" ), "TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ), "ATTR": new RegExp( "^" + attributes ), "PSEUDO": new RegExp( "^" + pseudos ), "POS": new RegExp( pos, "i" ), "CHILD": new RegExp( "^:(only|nth|first|last)-child(?:\\(" + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), // For use in libraries implementing .is()
"needsContext": new RegExp( "^" + whitespace + "*[>+~]|" + pos, "i" )
}Token格式
{ value:'匹配到的字符串',
type:'对应的Token类型',
matches:'正则匹配到的一个结构'}function tokenize( selector, parseOnly ) { // soFar:目前为止还未分析的字符串
// groups:目前已经匹配到的规则组
var matched, match, tokens, type,
soFar, groups, preFilters,
cached = tokenCache[ expando ][ selector + " " ]; if ( cached ) { return parseOnly ? 0 : cached.slice( 0 );
}
soFar = selector;
groups = [];
preFilters = Expr.preFilter; while ( soFar ) { // Comma and first run
if ( !matched || (match = rcomma.exec( soFar )) ) { if ( match ) { // Don't consume trailing commas as valid
soFar = soFar.slice( match[0].length ) || soFar;
}
groups.push( tokens = [] );
}
matched = false; // Combinators
// 关系选择符
if ( (match = rcombinators.exec( soFar )) ) {
tokens.push( matched = new Token( match.shift() ) );
soFar = soFar.slice( matched.length ); // Cast descendant combinators to space
matched.type = match[0].replace( rtrim, " " );
} // Filters
// 正则过滤
for ( type in Expr.filter ) { if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
(match = preFilters[ type ]( match ))) ) {
tokens.push( matched = new Token( match.shift() ) );
soFar = soFar.slice( matched.length );
matched.type = type;
matched.matches = match;
}
} if ( !matched ) { break;
}
} // Return the length of the invalid excess
// if we're just parsing
// Otherwise, throw an error or return tokens
return parseOnly ?
soFar.length :
soFar ?
Sizzle.error( selector ) : // Cache the tokens
tokenCache( selector, groups ).slice( 0 );
}11.select
function select( selector, context, results, seed, xml ) { var i, tokens, token, type, find, // 解析词法格式
match = tokenize( selector ),
j = match.length; if ( !seed ) { // Try to minimize operations if there is only one group
// 没有多分组，只是个单选则器，也就是selector中没有逗号，可以进行一些优化操作
if ( match.length === 1 ) { // Take a shortcut and set the context if the root selector is an ID
// 取出Token序列
tokens = match[0] = match[0].slice( 0 ); // 如果选择器selector第一部分为ID选择器
if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
context.nodeType === 9 && !xml &&
Expr.relative[ tokens[1].type ] ) {
context = Expr.find["ID"]( token.matches[0].replace( rbackslash, "" ), context, xml )[0]; // 如果查询结果为空（selector第一个ID选择器查询为空），就不用再查找了
if ( !context ) { return results;
} // 去掉第一个ID选择器
selector = selector.slice( tokens.shift().length );
} // Fetch a seed set for right-to-left matching
// 没有结构性伪类的话，从右至左进行扫描tokens中选择器序列（从数组后往前）匹配
for ( i = matchExpr["POS"].test( selector ) ? -1 : tokens.length - 1; i >= 0; i-- ) { // 获取一个规则
token = tokens[i]; // Abort if we hit a combinator
// 遇到关系选择符( > + ~ 空 )终止循环
if ( Expr.relative[ (type = token.type) ] ) { break;
} // 如果搜索器中支持此种类型查找
if ( (find = Expr.find[ type ]) ) { // Search, expanding context for leading sibling combinators
if ( (seed = find(
token.matches[0].replace( rbackslash, "" ),
rsibling.test( tokens[0].type ) && context.parentNode || context,
xml
)) ) { // If seed is empty or no tokens remain, we can return early
tokens.splice( i, 1 );
selector = seed.length && tokens.join(""); if ( !selector ) {
push.apply( results, slice.call( seed, 0 ) ); return results;
} break;
}//end if ( (seed = find
}// end if ( (find = Expr.find[ type ]) )
}//end for ( i = matchExpr["POS"].test( selector )
}
} // Compile and execute a filtering function
// Provide `match` to avoid retokenization if we modified the selector above
compile( selector, match )(
seed,
context,
xml,
results,
rsibling.test( selector )
); return results;
}关于jQuery的源码暂时分析到这里，后面还会继续分析。
作者：李伯特
链接：https://www.jianshu.com/p/2c6056449b3d
随时随地看视频
