Sizzle源码

首先使用原生语句查找，其次在context下找到所有节点元素，校验元素是否匹配选择器，进行过滤，获取到待查询的元素。

过滤时分为两种情形，针对选择器是否带:first()等位置关系伪类，若携带，setMatcher函数得到过滤函数，:first()伪类的校验函数也通过引用对象的形式“滤除“未匹配的节点；若不携带，elementMatcher得到校验函数，其中层级关系如“#form > .input”，通过addCombinator函数包装“#form“的校验函数，根据选择器”>”待校验节点和待过滤节elem的位置关系得到待校验节点，同样赋值给elem（以便传递更上层的addCombinator包装后的校验函数）。该addCombinator包装后的校验函数和”.input”校验函数平级，通过elementMatcher函数实现自右向左的校验，为传递elem的方便。

/*!
 * Sizzle CSS Selector Engine v2.3.0
 * https://sizzlejs.com/
 *
 * Copyright jQuery Foundation and other contributors
 * Released under the MIT license
 * http://jquery.org/license
 *
 * Date: 2016-01-04
 */
(function( window ) {

var i,
	support,
	Expr,
	getText,
	isXML,// 文档根节点是否xml
	tokenize,
	compile,
	select,
	outermostContext,
	sortInput,
	hasDuplicate,// 用于判断两元素是否相同

	// Local document vars
	setDocument,
	document,
	docElem,
	documentIsHTML,// 文档根节点是否html
	rbuggyQSA,// 存储querySelectorAll方法不支持的查询字符串
	rbuggyMatches,// 存储matchesSelector方法不支持的查询字符串
	matches,// 存储各浏览器的matchesSelector方法
	contains,

	// Instance-specific data
	expando="sizzle"+1*new Date(),// sizzle标识
	preferredDoc=window.document,
	dirruns=0,
	done=0,
	// 缓存是否匹配样式的函数，[]属性取出，()方法添加缓存
	classCache=createCache(),
	// 将选择器通过正则转化为对象形式(matched匹配字符、type类型、matches拆分匹配字符)存储
	tokenCache=createCache(),
	// compilerCache存储校验函数
	compilerCache=createCache(),
	sortOrder=function(a,b){
		if ( a===b ){
			hasDuplicate=true;
		}
		return 0;
	},

	hasOwn=({}).hasOwnProperty,
	arr=[],
	pop=arr.pop,
	push_native=arr.push,
	push=arr.push,
	slice=arr.slice,
	indexOf=function(list,elem){
		var i=0,
			len=list.length;
		for ( ; i
  
  
  
  
  
  
  
    、+、~起始，*匹配0个或多个 rcombinators=new RegExp("^"+whitespace+"*([>+~]|"+whitespace+")"+whitespace+"*"), // 获取属性的值 rattributeQuotes=new RegExp("="+whitespace+"*([^\\]'\"]*?)"+whitespace+"*\\]","g"), rpseudo=new RegExp(pseudos), ridentifier=new RegExp("^"+identifier+"$"), matchExpr={ "ID":new RegExp("^#("+identifier+")"), "CLASS":new RegExp("^\\.("+identifier+")"), "TAG":new RegExp("^("+identifier+"|[*])"), "ATTR":new RegExp("^"+attributes), "PSEUDO":new RegExp("^"+pseudos), "CHILD":new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+whitespace+ "*(even|odd|(([+-]|)(\\d*)n|)"+whitespace+"*(?:([+-]|)"+whitespace+ "*(\\d+)|))"+whitespace+"*\\)|)","i"),// 参Expr.prefilter.CHILD "bool":new RegExp("^(?:"+booleans+")$","i"), // For use in libraries implementing .is() // We use this for POS matching in `select` "needsContext":new RegExp("^"+whitespace+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+ whitespace+"*((?:-\\d)?\\d*)"+whitespace+"*\\)|)(?=[^-]|$)","i")// 匹配eq(1) }, rinputs=/^(?:input|select|textarea|button)$/i,// 匹配input|select|textarea|button rheader=/^h\d$/i,// 匹配h1、h2等 rnative=/^[^{]+\{\s*\[native \w/,// 判断是否浏览器原生函数 rquickExpr=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,// 匹配id、tag、class选择器 rsibling=/[+~]/, // CSS escapes // 选择器unicode转义 runescape=new RegExp("\\\\([\\da-f]{1,6}"+whitespace+"?|("+whitespace+")|.)","ig"), funescape=function(_,escaped,escapedWhitespace){ var high="0x"+escaped-0x10000; return high!==high || escapedWhitespace ? escaped : high<0 ? String.fromCharCode(high+0x10000) : String.fromCharCode(high>>10 | 0xD800, high & 0x3FF | 0xDC00); }, // CSS string/identifier serialization 转义 // https://drafts.csswg.org/cssom/#common-serializing-idioms rcssescape=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g, fcssescape=function(ch,asCodePoint){ if ( asCodePoint ){ // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER if ( ch==="\0" ){ return "\uFFFD"; } // Control characters and (dependent upon position) numbers get escaped as code points return ch.slice(0,-1)+"\\"+ch.charCodeAt(ch.length-1).toString(16)+" "; } // Other potentially-special ASCII characters get backslash-escaped return "\\"+ch; }, // 用户离开文档时，重新调用setDocument函数设置document为sizzle.js所在文档根节点 unloadHandler=function(){ setDocument(); }, disabledAncestor=addCombinator( function( elem ) { return elem.disabled === true; }, { dir: "parentNode", next: "legend" } ); // push方法拼接两个数组 try{ push.apply( (arr=slice.call(preferredDoc.childNodes)), preferredDoc.childNodes ); arr[preferredDoc.childNodes.length].nodeType; }catch(e){ push={apply:arr.length ? function(target,els){ push_native.apply(target,slice.call(els)); } : function(target,els){ var j=target.length, i=0; while ( (target[j++]=els[i++]) ){} target.length=j-1; } }; } // 参数seed在matchs方法中使用，用以判断元素 function Sizzle(selector,context,results,seed){ var m, i, elem, nid, match, groups, newSelector, newContext=context && context.ownerDocument, nodeType=context ? context.nodeType : 9; results=results || []; // selector不是字符串，或context不是节点时，以results作为返回值 if ( typeof selector!=="string" || !selector || nodeType!==1 && nodeType!==9 && nodeType!==11 ){ return results; } // 调用getElementBy["*"]或querySelectorAll方法快速查找元素 if ( !seed ){ if ( (context ? context.ownerDocument || context : preferredDoc)!==document ){ setDocument(context); } context=context || document; if ( documentIsHTML ){ // nodeType===11，DocumentFragment节点没有getElementBy[*]方法 if ( nodeType!==11 && (match=rquickExpr.exec(selector)) ){ // ID选择器快速查找 if ( (m=match[1]) ){ if ( nodeType===9 ){// 文档节点 if ( (elem=context.getElementById(m)) ){ if ( elem.id === m ){ results.push(elem); return results; } }else{ return results; } }else{// 普通节点 if ( newContext && (elem= newContext.getElementById(m)) && contains(context,elem) && elem.id===m ){ results.push(elem); return results; } } // Tag选择器快速查找 }else if(match[2]){ push.apply(results,context.getElementsByTagName(selector)); return results; // Class选择器快速查找 }else if( (m=match[3]) && support.getElementsByClassName && context.getElementsByClassName ){ push.apply(results,context.getElementsByClassName(m)); return results; } } if ( support.qsa && !compilerCache[selector+" "] && (!rbuggyQSA || !rbuggyQSA.test(selector)) ){ if ( nodeType!==1 ){ newContext=context; newSelector=selector; // Support: IE <=8 qSA方法将在context外查找元素，需重设selector，除了object节点 }else if( context.nodeName.toLowerCase()!=="object" ){ if ( (nid=context.getAttribute("id")) ){ nid=nid.replace(rcssescape,fcssescape); }else{ context.setAttribute("id",(nid=expando)); } // 将selector通过正则表达式拆解成对象形式存储到tokenCache中 groups=tokenize(selector); i=groups.length; while ( i-- ){ // toSelector获取逗号前后分割的单一选择器 groups[i]="#"+nid+" "+toSelector(groups[i]); } newSelector=groups.join(","); // testContext(context.parentNode)返回父节点 newContext=rsibling.test(selector) && testContext(context.parentNode) || context; } if ( newSelector ){ try{ push.apply(results,newContext.querySelectorAll(newSelector)); return results; }catch( qsaError ){ }finally{ if ( nid===expando ){ context.removeAttribute("id"); } } } } } } // 不能调用getElementBy["*"]或querySelectorAll方法的，调用select函数查找 return select(selector.replace(rtrim,"$1"),context,results,seed); } // 创建key-value缓存，存储在创建缓存的cache函数里，keys通过闭包维持存在 function createCache(){ var keys=[]; function cache(key,value){ if ( keys.push(key+" ")>Expr.cacheLength ){// Expr.cacheLength默认50 delete cache[keys.shift()]; } return (cache[key+" "]=value); } return cache; } // 向传参fn函数添加标记，以便sizzle进行移除、修改、查找处理 function markFunction(fn){ fn[expando]=true; return fn; } // 创建fieldset元素，执行fn函数，用来实现浏览器能力检测 function assert(fn){ var el=document.createElement("fieldset"); try{ return !!fn(el); }catch(e){ return false; }finally{ if ( el.parentNode ){ el.parentNode.removeChild(el); } el=null; } } // 为Expr.attrHandle添加方法，针对浏览器兼容性问题，添加特殊的获取属性方法 function addHandle(attrs,handler){ var arr=attrs.split("|"), i=arr.length; while ( i-- ){ Expr.attrHandle[arr[i]]=handler; } } // 两元素相邻状况，返回-1时b为a后续的兄弟节点，1为其他情况 function siblingCheck(a,b){ var cur=b && a, diff=cur && a.nodeType===1 && b.nodeType===1 && a.sourceIndex-b.sourceIndex; // 使用IE的sourceIndex方法判断两元素是否相邻 if ( diff ){ return diff; } // Check if b follows a if ( cur ){ while ( (cur=cur.nextSibling) ){ if ( cur===b ){ return -1; } } } return a ? 1 : -1; } // 创建:radio、:checkbox、:file、:password、:image伪类选择器，返回函数形式 function createInputPseudo(type){ return function(elem){ var name=elem.nodeName.toLowerCase(); return name==="input" && elem.type===type; }; } // 创建:submit、:reset伪类选择器，返回函数形式 function createButtonPseudo(type){ return function(elem){ var name=elem.nodeName.toLowerCase(); return (name==="input" || name==="button") && elem.type===type; }; } // 判断表单元素是否可用 function createDisabledPseudo(disabled){ // Known :disabled false positives: // IE: *[disabled]:not(button, input, select, textarea, optgroup, option, menuitem, fieldset) // not IE: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable return function(elem){ // Check form elements and option elements for explicit disabling return "label" in elem && elem.disabled===disabled || "form" in elem && elem.disabled===disabled || // Check non-disabled form elements for fieldset[disabled] ancestors "form" in elem && elem.disabled===false && ( // Support: IE6-11+ // Ancestry is covered for us elem.isDisabled===disabled || // Otherwise, assume any non- 
    under fieldset[disabled] is disabled /* jshint -W018 */ elem.isDisabled!==!disabled && ("label" in elem || !disabledAncestor(elem))!==disabled ); }; } // 由fn获得匹配元素的index值，再将seed中未匹配的项置为false，matches添加匹配的项 function createPositionalPseudo(fn){ return markFunction(function(argument){ argument=+argument; return markFunction(function(seed,matches){ var j, matchIndexes=fn([],seed.length,argument), i=matchIndexes.length; // Match elements found at the specified indexes while ( i-- ){ if ( seed[(j=matchIndexes[i])] ){ seed[j]=!(matches[j]=seed[j]); } } }); }); } // context有getElementsByTagName方法，返回context function testContext(context){ return context && typeof context.getElementsByTagName!=="undefined" && context; } // 浏览器能力检测 support=Sizzle.support={}; // 是否xml，通过判断根节点是否html isXML=Sizzle.isXML=function(elem){ var documentElement=elem && (elem.ownerDocument || elem).documentElement; return documentElement ? documentElement.nodeName!=="HTML" : false; }; // 返回当前文档根节点document，浏览器能力检测 setDocument=Sizzle.setDocument=function(node){ var hasCompare, subWindow, doc=node ? node.ownerDocument || node : preferredDoc; // doc是当前的文档根节点或者无效的节点 if ( doc===document || doc.nodeType!==9 || !doc.documentElement ){ return document; } document=doc; docElem=document.documentElement; documentIsHTML=!isXML(document); // Support: IE 9-11, Edge // 用户离开文档时，重新调用setDocument函数设置document为sizzle.js所在文档根节点 if ( preferredDoc!==document && (subWindow=document.defaultView) && subWindow.top!==subWindow ){ // Support: IE 11, Edge if ( subWindow.addEventListener ){ subWindow.addEventListener("unload",unloadHandler,false); // Support: IE 9 - 10 only }else if( subWindow.attachEvent ){ subWindow.attachEvent("onunload",unloadHandler); } } // 浏览器能力getElementBy[*]检测，Expr.find|filter["*"]方法改写 // Support: IE<8 校验getAttribute方法能否获取元素的属性 support.attributes=assert(function(el){ el.className="i"; return !el.getAttribute("className"); }); // 校验getElementsByTagName("*")是否会返回注释节点 support.getElementsByTagName=assert(function(el){ el.appendChild(document.createComment("")); return !el.getElementsByTagName("*").length; }); // Support: IE<9 函数体内含有native code support.getElementsByClassName=rnative.test(document.getElementsByClassName); // Support: IE<10 getElementById方法是否包含name属性相同的元素，用getElementsByName校验 support.getById=assert(function(el){ docElem.appendChild(el).id=expando; return !document.getElementsByName || !document.getElementsByName(expando).length; }); if ( support.getById ){ Expr.find["ID"]=function(id,context){ if ( typeof context.getElementById!=="undefined" && documentIsHTML ){ var m=context.getElementById(id); return m ? [m] : []; } }; Expr.filter["ID"]=function(id){ var attrId=id.replace(runescape,funescape); return function(elem){ return elem.getAttribute("id")===attrId; }; }; }else{ // Support: IE6/7 getElementById兼容性问题 delete Expr.find["ID"]; Expr.filter["ID"]=function(id){ var attrId=id.replace(runescape,funescape); return function(elem){ var node=typeof elem.getAttributeNode!=="undefined" && elem.getAttributeNode("id"); return node && node.value===attrId; }; }; } Expr.find["TAG"]=support.getElementsByTagName ? function(tag,context){ if ( typeof context.getElementsByTagName!=="undefined" ){ return context.getElementsByTagName(tag); }else if( support.qsa ){ return context.querySelectorAll(tag); } } : function(tag,context){ var elem, tmp=[], i=0, results=context.getElementsByTagName(tag); if ( tag==="*" ){// 移除注释节点 while ( (elem=results[i++]) ){ if ( elem.nodeType===1 ){ tmp.push(elem); } } return tmp; } return results; }; Expr.find["CLASS"]=support.getElementsByClassName && function(className,context){ if ( typeof context.getElementsByClassName!=="undefined" && documentIsHTML ){ return context.getElementsByClassName(className); } }; // 浏览器querySelectorAll、matchesSelector能力检测 // matchesSelector方法能力检测，不支持的查询字符串填入rbuggyMatches rbuggyMatches=[]; // 各浏览器querySelectorAll方法能力检测，不支持的查询字符串填入rbuggyQSA rbuggyQSA=[]; if ( (support.qsa=rnative.test(document.querySelectorAll)) ){ assert(function(el){ docElem.appendChild(el).innerHTML=""+ ""+ ""; // Support: IE8, Opera 11-12.16 属性内容为空时理应找不到元素 if ( el.querySelectorAll("[msallowcapture^='']").length ){ rbuggyQSA.push("[*^$]="+whitespace+"*(?:''|\"\")"); } // Support: IE8 if ( !el.querySelectorAll("[selected]").length ){ rbuggyQSA.push("\\["+whitespace+"*(?:value|"+booleans+")"); } // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+ if ( !el.querySelectorAll("[id~="+expando+"-]").length ){ rbuggyQSA.push("~=");// ~=元素的属性值中含有用空格分割的value } // IE8报错 if ( !el.querySelectorAll(":checked").length ){ rbuggyQSA.push(":checked"); } // Support: Safari 8+, iOS 8+ if ( !el.querySelectorAll("a#"+expando+"+*").length ){ rbuggyQSA.push(".#.+[+~]"); } }); assert(function(el){ el.innerHTML="" + ""; var input=document.createElement("input"); input.setAttribute("type","hidden"); el.appendChild(input).setAttribute("name","D"); // Support: IE8 if ( el.querySelectorAll("[name=d]").length ){ rbuggyQSA.push("name"+whitespace+"*[*^$|!~]?="); } // FF 3.5 - 隐藏的元素状态为enabled；IE8报错 if ( el.querySelectorAll(":enabled").length!==2 ){ rbuggyQSA.push(":enabled",":disabled"); } // Support: IE9-11+ 状态为disabled的元素其子节点为disabled时，将不包含该子节点 docElem.appendChild(el).disabled=true; if ( el.querySelectorAll(":disabled").length!==2 ){ rbuggyQSA.push(":enabled",":disabled"); } // 无效的伪类本当报错，不报错的时候，rbuggyQSA添加",.*:" el.querySelectorAll("*,:x"); rbuggyQSA.push(",.*:"); }); } if ( (support.matchesSelector=rnative.test( (matches=docElem.matches || docElem.webkitMatchesSelector || docElem.mozMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector) )) ){ assert(function( el ) { // IE 9 未插入文档的节点是否适用matchesSelector support.disconnectedMatch=matches.call(el,"*"); matches.call(el,"[s!='']:x"); rbuggyMatches.push("!=",pseudos); }); } rbuggyQSA=rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") ); rbuggyMatches=rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") ); // 判断a元素是否包含b元素 hasCompare=rnative.test(docElem.compareDocumentPosition); contains=hasCompare || rnative.test(docElem.contains) ? function(a,b){ var adown=a.nodeType===9 ? a.documentElement : a, bup=b && b.parentNode; return a===bup || !!(bup && bup.nodeType===1 && ( adown.contains ? adown.contains(bup) : // compareDocumentPosition方法判断元素的相对位置 // a & 16 按位与，当a大于等于16为16，其他为0 a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16 )); } : function(a,b){ if (b){ while ( (b=b.parentNode) ){ if ( b===a ){ return true; } } } return false; }; // 判断a、b元素的位置关系 sortOrder=hasCompare ? function(a,b){ if ( a===b ){ hasDuplicate=true; return 0; } // 其中一个有compareDocumentPosition方法，一个没有 var compare=!a.compareDocumentPosition-!b.compareDocumentPosition; if ( compare ){ return compare; } compare=(a.ownerDocument || a)===(b.ownerDocument || b) ? a.compareDocumentPosition(b) : 1;// 不在同一个文档 // 不相关的节点，a在当前文档中返回-1，b在当前文档中返回1 if ( compare & 1 || (!support.sortDetached && b.compareDocumentPosition(a)===compare) ){ if ( a===document || a.ownerDocument===preferredDoc && contains(preferredDoc,a) ){ return -1; } if ( b===document || b.ownerDocument===preferredDoc && contains(preferredDoc,b) ){ return 1; } // Maintain original order return sortInput ? ( indexOf(sortInput,a)-indexOf(sortInput,b) ) : 0; } return compare & 4 ? -1 : 1; } : function(a,b){ if ( a===b ){ hasDuplicate=true; return 0; } var cur, i=0, aup=a.parentNode, bup=b.parentNode, ap=[a], bp=[b]; // Parentless nodes are either documents or disconnected if ( !aup || !bup ){ return a===document ? -1 : b===document ? 1 : aup ? -1 : bup ? 1 : sortInput ? ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : 0; // If the nodes are siblings, we can do a quick check }else if( aup===bup ){ return siblingCheck(a,b); } // Otherwise we need full lists of their ancestors for comparison cur = a; while ( (cur = cur.parentNode) ) { ap.unshift( cur ); } cur = b; while ( (cur = cur.parentNode) ) { bp.unshift( cur ); } // Walk down the tree looking for a discrepancy while ( ap[i] === bp[i] ) { i++; } return i ? // Do a sibling check if the nodes have a common ancestor siblingCheck( ap[i], bp[i] ) : // Otherwise nodes in our document sort first ap[i]===preferredDoc ? -1 : bp[i]===preferredDoc ? 1 : 0; }; return document; }; // 滤除elements中不满足expr的元素 Sizzle.matches=function(expr,elements){ return Sizzle(expr,null,null,elements); }; // 检查elem是否expr选择器，原生语句matchesSelector()优先 Sizzle.matchesSelector=function(elem,expr){ if ( (elem.ownerDocument || elem)!==document ){ setDocument(elem); } expr=expr.replace(rattributeQuotes,"='$1']"); if ( support.matchesSelector && documentIsHTML && !compilerCache[expr+" "] && ( !rbuggyMatches || !rbuggyMatches.test(expr) ) && ( !rbuggyQSA || !rbuggyQSA.test(expr) ) ){ try { var ret=matches.call(elem,expr); // IE 9's matchesSelector returns false on disconnected nodes if ( ret || support.disconnectedMatch || // As well, disconnected nodes are said to be in a document // fragment in IE 9 elem.document && elem.document.nodeType!==11 ) { return ret; } }catch(e){} } return Sizzle(expr,document,null,[elem]).length>0; }; // 判断是否包含 Sizzle.contains=function(context,elem){ if ( (context.ownerDocument || context)!==document ){ setDocument(context); } return contains(context,elem); }; // 有兼容性问题的个别属性通过Expr.attrHandle[name.toLowerCase()]方法获取 // 当前浏览器支持getAttribute方法或者xml文档的时候，通过getAttribute方法获取 // 其他通过getAttributeNode(name).specified获取属性值 Sizzle.attr=function(elem,name){ if ( (elem.ownerDocument || elem)!==document ){ setDocument(elem); } var fn=Expr.attrHandle[name.toLowerCase()], val=fn && hasOwn.call(Expr.attrHandle,name.toLowerCase()) ? fn(elem,name,!documentIsHTML) : undefined; return val!==undefined ? val : support.attributes || !documentIsHTML ? elem.getAttribute(name) : (val=elem.getAttributeNode(name)) && val.specified ? val.value : null; }; // unicode转义 Sizzle.escape=function(sel){ return (sel+"").replace(rcssescape,fcssescape); }; // 报错 Sizzle.error=function(msg){ throw new Error("Syntax error, unrecognized expression: "+msg); }; // support.detectDuplicates为否时去重，为真时保留重复项 Sizzle.uniqueSort=function(results){ var elem, duplicates=[], j=0, i=0; hasDuplicate=!support.detectDuplicates; sortInput=!support.sortStable && results.slice(0); results.sort(sortOrder); if ( hasDuplicate ){ // 比对前后两个数组项是否相同，相同记录前一项的index，splice方法移除该项 while ( (elem=results[i++]) ){ if ( elem===results[i] ){ j=duplicates.push(i); } } while ( j-- ){ results.splice(duplicates[j],1); } } sortInput=null; return results; }; // 调用textContent属性或者拼接字符串的方式获取节点及子节点的文本内容 getText=Sizzle.getText=function(elem){ var node, ret="", i=0, nodeType=elem.nodeType; if ( !nodeType ){ while ( (node=elem[i++]) ){ ret+=getText(node); } }else if( nodeType===1 || nodeType===9 || nodeType===11 ){ if ( typeof elem.textContent==="string" ){ return elem.textContent; }else{ for( elem=elem.firstChild; elem; elem=elem.nextSibling ){ ret+=getText(elem); } } }else if( nodeType===3 || nodeType===4 ){ return elem.nodeValue; } return ret; }; Expr=Sizzle.selectors={ cacheLength:50,// 缓存默认长度 createPseudo: markFunction,// fn添加属性，以便查找及管理 match:matchExpr,// 正则表达式 attrHandle:{},// 针对浏览器兼容性问题，添加特殊的获取属性方法，如value、disabled等 find:{}, // dir待校验元素与自右向左查询元素的相对关系，first为真值，严格校验模式 // 如">"，须严格确保父子关系 relative:{ ">":{dir:"parentNode",first:true}, " ":{dir:"parentNode"}, "+":{dir:"previousSibling",first:true}, "~":{dir:"previousSibling"} }, // 处理匹配的正则数组，同时将正则表达式不完善的地方补全 preFilter:{ "ATTR":function(match){ // match[1] Expr.filter.ATTR中参数name // match[2] Expr.filter.ATTR中参数operator // match[3] Expr.filter.ATTR中参数check match[1]=match[1].replace(runescape,funescape); match[3]=(match[3] || match[4] || match[5] || "").replace(runescape,funescape); if ( match[2]==="~=" ){ match[3]=" "+match[3]+" "; } return match.slice(0,4); }, "CHILD":function(match){ // match[1] Expr.filter.ChILD中参数type 如nth // match[2] Expr.filter.ChILD中参数what 如child // match[3] Expr.filter.ChILD中参数argument 如3n+2 // match[4] Expr.filter.ChILD中参数first 如3 // match[5] Expr.filter.ChILD中参数last 如2 /* matches from matchExpr["CHILD"] 1 type (only|nth|...) 2 what (child|of-type) 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) 如+3n-2 4 xn-component of xn+y argument ([+-]?\d*n|) 如+3n 5 sign of xn-component 如+ 6 x of xn-component 如3 7 sign of y-component 如- 8 y of y-component 如2 */ match[1]=match[1].toLowerCase(); if ( match[1].slice(0,3)==="nth" ){ if ( !match[3] ){ Sizzle.error(match[0]); } match[4]=+( match[4] ? match[5]+(match[6] || 1) : 2*( match[3]==="even" || match[3]==="odd" ) ); match[5]=+( (match[7]+match[8]) || match[3]==="odd" ); }else if( match[3] ){ Sizzle.error(match[0]); } return match; }, "PSEUDO":function(match){ // match[1] Expr.filter.PSEUDO中参数pesudo，Expr.pseudos中方法名 如not // match[2] Expr.filter.PSEUDO中参数argument，Expr.pseudos["*"]方法的参数 如".btn" /* matches from matchExpr["PSEUDO"] not(".btn") 1 pesudo (not|eq|gt|hidden) 2 argument ('*'|"*"|\d|...) 如".btn" 3 quotes ('*'|"*") 如".btn" 4 single-quote ('') 5 double-quote ("") 如".btn" 6 使用js语句进行过滤，不匹配 */ var excess, unquoted=!match[6] && match[2]; if ( matchExpr["CHILD"].test(match[0]) ){// 作为child选择器处理 return null; } if ( match[3] ){ match[2]=match[4] || match[5] || ""; }else if( unquoted && rpseudo.test(unquoted) && (excess=tokenize(unquoted,true)) && (excess=unquoted.indexOf(")",unquoted.length-excess)-unquoted.length) ){ match[0]=match[0].slice(0,excess);// 移除")"后字符串 match[2]=unquoted.slice(0,excess); } return match.slice(0,3); } }, // 匹配tag、class、attr、child、pseudo的方法，验证元素是否匹配，返回值为校验函数 filter:{ "TAG":function(nodeNameSelector){ var nodeName=nodeNameSelector.replace(runescape,funescape).toLowerCase(); return nodeNameSelector==="*" ? function(){return true;} : function(elem){ return elem.nodeName && elem.nodeName.toLowerCase()===nodeName; }; }, "CLASS":function(className){ var pattern=classCache[className+" "]; return pattern || (pattern=new RegExp("(^|"+whitespace+ ")"+className+"("+whitespace+"|$)")) && classCache(className,function(elem){ return pattern.test( typeof elem.className==="string" && elem.className || typeof elem.getAttribute!=="undefined" && elem.getAttribute("class") || "" ); }); }, "ATTR":function(name,operator,check){// name属性名，operator操作符，check属性值 return function(elem){ var result=Sizzle.attr(elem,name); if ( result==null ){ return operator==="!="; } if ( !operator ){ return true; } result+=""; return operator==="=" ? result===check : operator==="!=" ? result!==check : operator==="^=" ? check && result.indexOf(check)===0 :// 某值为首项 operator==="*=" ? check && result.indexOf(check)>-1 :// 含某值 operator==="$=" ? check && result.slice(-check.length)===check :// 以某值结尾 operator==="~=" ? (" "+result.replace(rwhitespace," ")+" ").indexOf(check)>-1 :// 以空格分割的某值 operator==="|=" ? result===check || result.slice(0,check.length+1)===check+"-" :// 某值在起始处，以连字符起始 false; }; }, // nth-child(3n+2) type为nth，what为child，argument为3n+2，first为3，last为2 "CHILD":function(type,what,argument,first,last){ var simple=type.slice(0,3)!=="nth", forward=type.slice(-4)!=="last", ofType=what==="of-type"; return first===1 && last===0 ? // :nth-child(1)、:nth-type-of(1) function( elem ){// 匹配首个元素 return !!elem.parentNode; } : function(elem,context,xml){ var cache, uniqueCache, outerCache, node, nodeIndex, start, dir=simple!==forward ? "nextSibling" : "previousSibling", parent=elem.parentNode, name=ofType && elem.nodeName.toLowerCase(), useCache=!xml && !ofType,// 非xml文档，nth-child选择器，缓存 diff=false; if ( parent ){ // :(first|last|only)-(child|of-type) if ( simple ){ // simple限制为真值，dir随last-child变为nextSibling // first-child之前有元素返回false，last-child判断其后有无元素 while ( dir ){ node=elem; while ( (node=node[dir]) ){ if ( ofType ? node.nodeName.toLowerCase()===name : node.nodeType===1 ){ return false; } } // only-child时，dir由previousSibling反转为nextSibling start=dir=type==="only" && !start && "nextSibling"; } return true; } start=[forward ? parent.firstChild : parent.lastChild]; // 不是xml文档、nth-child选择器条件下使用缓存 if ( forward && useCache ){ node=parent; outerCache=node[expando] || (node[expando]={}); // uniqueCache缓存当前元素的序号diff，nodeIndex包含其他节点元素形式 uniqueCache=outerCache[node.uniqueID] || (outerCache[node.uniqueID]={}); cache=uniqueCache[type] || []; nodeIndex=cache[0]===dirruns && cache[1]; diff=nodeIndex && cache[ 2 ]; node=nodeIndex && parent.childNodes[nodeIndex]; while ( (node=++nodeIndex && node && node[dir] || // 没有缓存时初始设置diff=nodeIndex=0，node=parent.firstChild (diff=nodeIndex=0) || start.pop()) ){ if ( node.nodeType===1 && ++diff && node===elem ){ uniqueCache[type]=[dirruns,nodeIndex,diff]; break; } } }else{ if ( useCache ){ node=elem; outerCache=node[expando] || (node[expando]={}); uniqueCache=outerCache[node.uniqueID] || (outerCache[node.uniqueID]={}); cache=uniqueCache[type] || []; nodeIndex=cache[0]===dirruns && cache[1]; diff=nodeIndex; } // xml :nth-child(...) // or :nth-last-child(...) or :nth(-last)?-of-type(...) if ( diff===false ){ while ( (node=++nodeIndex && node && node[dir] || (diff=nodeIndex=0) || start.pop()) ){ if ( ( ofType ? node.nodeName.toLowerCase()===name :// 标签相同的元素 node.nodeType===1 ) && ++diff ){ if ( useCache ){ outerCache=node[expando] || (node[expando]={}); uniqueCache=outerCache[node.uniqueID] || (outerCache[node.uniqueID]={}); uniqueCache[type]=[dirruns,diff]; } if ( node===elem ){ break; } } } } } diff-=last;// 节点的序号diff return diff===first || (diff%first===0 && diff/first>=0); } }; }, "PSEUDO":function(pseudo,argument){ var args, // 获取伪类校验函数，Expr.pseudos优先级高于Expr.setFilters // Expr.setFilters的原型为Expr.pseudos fn=Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || Sizzle.error("unsupported pseudo: "+pseudo); // pesudo如not、has等通过createPseudo创建校验函数fn、或first等通过createPositionalPseudo创建 // 校验函数需要配置参数方可用于校验元素 if ( fn[expando] ){ return fn(argument); } // But maintain support for old signatures // jquery原先的版本用length代替expando实现其功能？？？ if ( fn.length>1 ) { args=[pseudo,pseudo,"",argument]; // pseudo为Expr.setFilters实例自有的方法名，参数为待过滤元素和argument // 使用引用对象形式过滤，而不是返回过滤结果 // 传参seed待过滤元素，函数执行完成seed中匹配项设为false return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function(seed,matches){ var idx, matched=fn(seed,argument), i=matched.length; while( i-- ){ idx=indexOf(seed,matched[i]); seed[idx]=!(matches[idx]=matched[i]); } }) : function(elem){ return fn(elem,0,args); }; } return fn; } }, // 是否匹配伪类选择器函数 pseudos:{ // :not('.classname')校验元素不是.classname元素 "not":markFunction(function(selector){ var input=[], results=[], // 通过compile获取:not()内选择器的校验函数 matcher=compile(selector.replace(rtrim,"$1")); return matcher[expando] ? // :not()内选择器为:first等 markFunction(function(seed,matches,context,xml){ var elem, unmatched=matcher(seed,null,xml,[]), i=seed.length; while ( i-- ){ if ( (elem=unmatched[i]) ){ seed[i]=!(matches[i]=elem);// 匹配matcher的设为否值 } } }) : function(elem,context,xml){ input[0]=elem; matcher(input,null,xml,results); input[0]=null; return !results.pop(); }; }), // 使用elementMatchers普通校验函数，返回布尔值 // 首先由Expr.filter.PESUDO方法获得selector参数，再使用返回函数校验elem "has":markFunction(function(selector){ return function(elem){ return Sizzle(selector,elem).length>0; }; }), // 是否包含给定文本 "contains":markFunction(function(text){ text=text.replace(runescape,funescape); return function(elem){ return ( elem.textContent || elem.innerText || getText(elem) ).indexOf(text)>-1; }; }), // :lang(en)校验 
    
或 
    
 "lang":markFunction(function(lang){ if ( !ridentifier.test(lang || "") ){ Sizzle.error("unsupported lang: "+lang); } lang=lang.replace(runescape,funescape).toLowerCase(); return function(elem){ var elemLang; do { if ( (elemLang=documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ){ elemLang=elemLang.toLowerCase(); return elemLang===lang || elemLang.indexOf(lang+"-")===0; } } while ( (elem=elem.parentNode) && elem.nodeType===1 ); return false; }; }), // 使用elementMatchers普通校验函数，返回布尔值 // 以当前页面hash为id属性的节点 "target":function(elem){ var hash=window.location && window.location.hash;// http://example.com/#foo情形为foo return hash && hash.slice(1)===elem.id; }, // 根节点 "root":function(elem){ return elem===docElem; }, "focus":function(elem){ return elem===document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex); }, "enabled":createDisabledPseudo(false), "disabled":createDisabledPseudo(true), // 选中的option或radio、checkbox "checked":function(elem){ // In CSS3, :checked should return both checked and selected elements // http://www.w3.org/TR/2011/REC-css3-selectors-/#checked var nodeName=elem.nodeName.toLowerCase(); return (nodeName==="input" && !!elem.checked) || (nodeName==="option" && !!elem.selected); }, // 选中的option "selected":function(elem){ // Accessing this property makes selected-by-default // options in Safari work properly if ( elem.parentNode ) { elem.parentNode.selectedIndex; } return elem.selected===true; }, // 元素是否没有子节点 "empty":function(elem){ // http://www.w3.org/TR/selectors/#empty-pseudo // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5), // but not by others (comment: 8; processing instruction: 7; etc.) // nodeType < 6 works because attributes (2) do not appear as children for ( elem=elem.firstChild; elem; elem=elem.nextSibling ){ if ( elem.nodeType<6 ){ return false; } } return true; }, // 作为父节点 "parent":function(elem){ return !Expr.pseudos["empty"](elem); }, // h1、h2等 "header":function(elem){ return rheader.test(elem.nodeName); }, // 表单元素select、input、button、textarea "input":function(elem){ return rinputs.test(elem.nodeName); }, "button":function(elem){ var name=elem.nodeName.toLowerCase(); return name==="input" && elem.type==="button" || name==="button"; }, // 输入框 "text":function(elem){ var attr; return elem.nodeName.toLowerCase()==="input" && elem.type==="text" && // Support: IE<8 // New HTML5 attribute values (e.g., "search") appear with elem.type === "text" ( (attr=elem.getAttribute("type"))==null || attr.toLowerCase()==="text" ); }, // 匹配index值为0的元素，setMatchers特殊校验函数中传入待过滤元素，index=0的满足条件 "first":createPositionalPseudo(function(){ return [0]; }), "last":createPositionalPseudo(function(matchIndexes,length){ return [length-1]; }), "eq":createPositionalPseudo(function(matchIndexes,length,argument){ return [argument<0 ? argument+length : argument]; }), // index为偶数的元素 "even":createPositionalPseudo(function(matchIndexes,length){ var i=0; for ( ; i 
    
      = 0; ) { matchIndexes.push( i ); } return matchIndexes; }), "gt":createPositionalPseudo(function(matchIndexes,length,argument){ var i=argument<0 ? argument+length : argument; for ( ; ++i 
     
       [attr] 将被拆解为一个tokens存储在groups中 tokenize=Sizzle.tokenize=function(selector,parseOnly){ var matched, match, tokens, type, soFar, groups, preFilters, cached=tokenCache[selector+" "]; if ( cached ){ return parseOnly ? 0 : cached.slice(0); } soFar=selector; groups=[]; preFilters=Expr.preFilter;// 处理匹配的正则字符串 while ( soFar ){ // 选择器以空格+逗号起始，移除该空格+逗号 if ( !matched || (match=rcomma.exec(soFar)) ){ if ( match ){ soFar=soFar.slice(match[0].length) || soFar; } groups.push((tokens=[])); } matched=false; // 选择器以空格、>、+、~起始，*匹配0个或多个 // tokens中value正则匹配的数组，type类型如>或+或~ if ( (match=rcombinators.exec(soFar)) ){ matched=match.shift(); tokens.push({ value:matched, type:match[0].replace(rtrim," ") }); soFar=soFar.slice(matched.length); } for ( type in Expr.filter ){// type为tag、class、attr、child或pseudo if ( (match=matchExpr[type].exec(soFar)) && (!preFilters[type] || (match=preFilters[type](match))) ){ matched=match.shift(); tokens.push({ value:matched,// 匹配的完整字符串 type:type,// 类型如tag、class、attr、child或pseudo matches:match// 匹配字符串拆分的数组，如Attr将被拆分为name、operator、check }); soFar=soFar.slice(matched.length); } } if ( !matched ){ break; } } // parseOnly为真时，返回未匹配字符串的长度，否则报错或者tokenCache添加处理后的匹配内容tokens return parseOnly ? soFar.length : soFar ? Sizzle.error(selector) : tokenCache(selector,groups).slice(0); }; // 获取逗号前后分割的单一选择器 function toSelector(tokens){ var i=0, len=tokens.length, selector=""; for ( ; i 
      
        1 ? function(elem,context,xml){ var i=matchers.length; while ( i-- ){ if ( !matchers[i](elem,context,xml) ){ return false; } } return true; } : matchers[0]; } // 多个上下文contexts中查找selector元素 function multipleContexts(selector,contexts,results){ var i=0, len=contexts.length; for ( ; i 
       
         -1 ){ // seed匹配的元素记为否值，results不匹配的元素记为否值 seed[temp]=!(results[temp]=elem); } } } }else{ // matchOut与results相同，返回空数组，否则返回matchOut matcherOut=condense( matcherOut===results ? matcherOut.splice(preexisting,matcherOut.length) : matcherOut ); if( postFinder ){ // setMatcher(postFinder,postSelector)查询temp下所有元素节点并过滤，与results合并 postFinder(null,results,matcherOut,xml); }else{ push.apply(results,matcherOut); } } }); } // 获取校验函数 // 获取校验函数，matcher[expando]为真时通过setMatcher获取特殊的校验函数，单函数形式 // 普通的校验函数为数组形式 // 逗号选择器分割生成多个groups、单个groups有多个tokens // 也即单个groups只可能返回数组形式的普通校验函数或单函数形式的特殊校验函数 function matcherFromTokens(tokens){ var checkContext, matcher, j, len=tokens.length, leadingRelative=Expr.relative[tokens[0].type], implicitRelative=leadingRelative || Expr.relative[" "], i=leadingRelative ? 1 : 0,// 起始无"+|~| |>"，从第二个项开始查找 // 选择器以">"起始等情况，判断addCombinator层级关系校验器修改后elem与context是否相符 matchContext=addCombinator(function(elem){ return elem===checkContext; },implicitRelative,true), matchAnyContext=addCombinator(function(elem){ return indexOf(checkContext,elem)>-1; },implicitRelative,true), matchers=[function(elem,context,xml){ var ret=( !leadingRelative && (xml || context!==outermostContext) ) || ( (checkContext=context).nodeType ? matchContext(elem,context,xml) : matchAnyContext(elem,context,xml) ); checkContext=null; return ret; }]; // form#form .input选择器，else语句分支添加form、#form两个校验函数 // 空格匹配Expr.relative[tokens[i].type]，进入if语句，addCombinator将form、#form两个校验函数合并为一 // addCombinator函数由传参elem(seed或context下查找所有节点)获取待校验节点 // 生成新的校验函数并返回；elem为引用对象的形式，校验过程中被改变（用于传入嵌套的校验函数.panel form#form .input） // .input生成另一校验函数，同addCombinator构建的校验函数平级 // return返回值再用elementMatcher进行包装，先执行.input校验函数，再执行addCombinator构建的校验函数 for ( ; i 
        
          1 && elementMatcher(matchers),// :not之前选择器的校验函数 i>1 && toSelector( tokens.slice(0,i-1).concat({value:tokens[i-2].type===" " ? "*" : "" }) ).replace(rtrim,"$1"),// :not之前选择器完全值，后加"*"或"" matcher,// :not选择器的校验函数 i 
         
           0, byElement=elementMatchers.length>0, superMatcher=function(seed,context,xml,results,outermost){ var elem, j, matcher, matchedCount=0, i="0", unmatched=seed && [], setMatched=[], contextBackup=outermostContext, // 无待匹配元素seed，outermost上下文中获取所有元素节点 elems=seed || byElement && Expr.find["TAG"]("*",outermost), // Use integer dirruns iff this is the outermost matcher dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1), len=elems.length; if ( outermost ){ outermostContext=context===document || context || outermost; } for ( ; i!==len && (elem=elems[i])!=null; i++ ){ // 在outermost中找出所有tag节点，调用elementMatchers中匹配函数校验其是否满足条件 // 逗号分割的选择器前后无:first等需要特殊校验的选择器，results直接推入匹配的元素 if ( byElement && elem ){ j=0; if ( !context && elem.ownerDocument!==document ){ setDocument(elem); xml=!documentIsHTML; } // 怎样处理addCombinator层级校验函数中elem被改变的事实？？？ while ( (matcher=elementMatchers[j++]) ){ if ( matcher(elem,context || document,xml) ){ results.push(elem); break; } } if ( outermost ){ dirruns=dirrunsUnique; } } if ( bySet ){ // matchedCount标记elem元素不匹配elementMatchers普通校验，需要用setMatchers校验 if ( (elem=!matcher && elem) ){ matchedCount--; } // 无seed时，setMatchers将在context查找所有节点并寻找匹配元素 // 有seed，setMatchers将在context下查找unmatched内元素 if ( seed ){ unmatched.push(elem); } } } // 已匹配elementMatchers的元素个数，其余元素需要用setMatchers校验 matchedCount+=i; if ( bySet && i!==matchedCount ){ j=0; while ( (matcher=setMatchers[j++]) ){ // 包装后的setMatchers获得unmatched匹配的为否值，setMatched只包含匹配的元素 // 无seed时，unmatched为空数组，context查找所有节点并寻找匹配元素 // 有seed，context下查找unmatched内元素 matcher(unmatched,setMatched,context,xml); } if ( seed ){ // 有seed时，setMatchers过滤结果中setMatched未匹配项记为否 if ( matchedCount>0 ){ while ( i-- ){ if ( !(unmatched[i] || setMatched[i]) ){ setMatched[i]=pop.call(results); } } } // 移除值为false的数组项，保留值为节点的数组项，即匹配结果 setMatched=condense(setMatched); } // select方法将直接获得results结果集，无须返回results push.apply(results,setMatched); if ( outermost && !seed && setMatched.length>0 && ( matchedCount+setMatchers.length )>1 ){ Sizzle.uniqueSort(results); } } // Override manipulation of globals by nested matchers？？？ if ( outermost ){ dirruns=dirrunsUnique; outermostContext=contextBackup; } return unmatched; }; return bySet ? markFunction(superMatcher) : superMatcher; } // 获取超级匹配函数 // 通过matcherFromTokens获取校验函数集elementMatchers、setMatchers // 接着由matcherFromGroupMatchers函数构建superMatch函数并返回 // 返回值为函数，该函数的返回值为superMatch超级查询并校验匹配函数 compile=Sizzle.compile=function(selector,match/* Internal Use Only */){ var i, setMatchers=[], elementMatchers=[], cached=compilerCache[selector+" "]; if ( !cached ){ if ( !match ){ match=tokenize(selector); } i=match.length;// 逗号分隔的选择器个数 while ( i-- ){ // 逗号分隔的选择器通过matcherFromTokens获取校验函数 // 只可能是数组形式的普通检验函数，推送到elementMatchers中 // 或者函数形式的特殊校验函数，推送到setMatchers中 // 因此setMatchers、elementMatchers各自获取到的结果是逗号分割选择器的各自结果，不需要再过滤 cached=matcherFromTokens(match[i]); if ( cached[expando] ){ // 特殊校验 如:not、:first等，以待校验元素、结果集作为参数传入过滤 // 引用对象形式过滤待校验元素及结果集 setMatchers.push(cached); }else{ // 单元素校验 如tag、id等，以校验元素作为参数传入，返回值为布尔类型 elementMatchers.push(cached); } } // 返回值，向superMatch函数传入校验函数集elementMatchers、setMatchers // cached存储校验函数 cached=compilerCache(selector,matcherFromGroupMatchers(elementMatchers,setMatchers)); cached.selector=selector; } return cached; }; // 在不能使用qsa或兼容性问题，或选择器语句复杂的情况下，使用select函数进行查询 // 单一选择器无逗号分割时，调用getElementById或Expr.find[type]进行查找 // 有逗号分割，调用select方法遍历dom树，Expr.filter方法过滤，获取结果集 select=Sizzle.select=function(selector,context,results,seed){ var i, tokens, token, type, find, compiled=typeof selector==="function" && selector,// 选择器为超级匹配函数 match=!seed && tokenize( (selector=compiled.selector || selector) ); results=results || []; // 逗号分隔的选择器只有一个，且不存在seed if ( match.length===1 ){ // id选择器快速查找，" #id + :lt(3) > .tag"快速找到#id，并且更新context tokens=match[0]=match[0].slice(0); if ( tokens.length>2 && (token=tokens[0]).type==="ID" && support.getById && context.nodeType===9 && documentIsHTML && Expr.relative[tokens[1].type] ){ context=(Expr.find["ID"](token.matches[0].replace(runescape,funescape),context) || [])[0]; if ( !context ){ return results; }else if( compiled ){// selector为函数 context=context.parentNode; } selector=selector.slice(tokens.shift().value.length);// 移除已经找到的id节点 } i=matchExpr["needsContext"].test(selector) ? 0 : tokens.length; // 其他选择器或以"+|~| |>"的选择器通过Expr.find[type]查找 while ( i-- ){// 选择器自右向左查找 token=tokens[i]; // "+","~",">"," "执行跳出循环 if ( Expr.relative[(type=token.type)] ){ break; } // "+ :lt(3) > .tag"情形找到.tag，其余通过超级匹配函数superMatch查找 if ( (find=Expr.find[type]) ){ // 选择器以">"、" "起始context中查询，选择器以"+"、"~"起始context父节点中查询 if ( (seed=find( token.matches[0].replace(runescape,funescape), rsibling.test(tokens[0].type) && testContext(context.parentNode) || context )) ){ tokens.splice(i,1); selector=seed.length && toSelector(tokens); if ( !selector ){// seed存储已找到的元素，选择器查询完毕时，填入results中 push.apply(results,seed); return results; } break; } } } } // 传参有seed，或Expr.find无法找到的内容，调用超级匹配函数superMatch查询文档树，并获得结果集 ( compiled || compile(selector,match) )( seed,// 待匹配元素 context,// 上下文 !documentIsHTML, results,// 查询结果集 // superMatch函数查找所有tag节点的上下文 !context || rsibling.test(selector) && testContext(context.parentNode) || context ); return results; }; // 將hasDuplicate赋值为true，support.sortStable为真 support.sortStable=expando.split("").sort(sortOrder).join("")===expando; // Support: Chrome 14-35+ support.detectDuplicates设定为真值，允许重复项 support.detectDuplicates=!!hasDuplicate; // 初始化设置document，兼容性情况support获取，根据兼容性设置部分特殊的find、filter方法 setDocument(); // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27) // 两个未插入文档的元素调用compareDocumentPosition方法理应返回1，不兼容时返回4 // support.sortDetached为否 support.sortDetached=assert(function(el){ return el.compareDocumentPosition(document.createElement("fieldset")) & 1; }); // 针对兼容性问题添加特殊的属性获取方法 // Support: IE<8 if ( !assert(function(el){ el.innerHTML=" 
          "; return el.firstChild.getAttribute("href")==="#"; }) ){// 没报错向Expr.attrHandle添加方法 addHandle("type|href|height|width",function(elem,name,isXML){ if ( !isXML ){ // 次参为2时，属性值以字符串形式返回；为1时，严格区分大小写 // https://msdn.microsoft.com/en-us/library/ms%28VS.85%29.aspx return elem.getAttribute(name,name.toLowerCase()==="type" ? 1 : 2 ); } }); } // Support: IE<9 使用elem.defaultValue替代getAttribute("value") if ( !support.attributes || !assert(function(el){ el.innerHTML=" 
          "; el.firstChild.setAttribute("value",""); return el.firstChild.getAttribute("value")===""; }) ){ addHandle("value",function(elem,name,isXM ){ if ( !isXML && elem.nodeName.toLowerCase()==="input" ){ return elem.defaultValue; } }); } // Support: IE<9 使用getAttributeNode方法获取布尔值，替代取值有问题的getAttribute if ( !assert(function(el){ return el.getAttribute("disabled")==null; }) ){ addHandle(booleans,function(elem,name,isXML){ var val; if ( !isXML ){ return elem[name]===true ? name.toLowerCase() : (val=elem.getAttributeNode(name)) && val.specified ? val.value : null; } }); } var _sizzle=window.Sizzle; // window.Sizzle被占用的情况下，使用完毕执行noConflict，window.Sizzle还原为初始值 Sizzle.noConflict=function() { if ( window.Sizzle===Sizzle ) { window.Sizzle=_sizzle; } return Sizzle; }; // AMD/CMD模块化加载 if ( typeof define==="function" && define.amd ){ define(function(){ return Sizzle; }); }else if( typeof module!=="undefined" && module.exports ){ module.exports=Sizzle; }else{ window.Sizzle=Sizzle; } })( window );  
          
         
        
       
      
     
  

附

selector-sizzle.js

define([ "./core", "../external/sizzle/dist/sizzle" ],function(jQuery,Sizzle){ jQuery.find=Sizzle;// 查找，第四参数为期望匹配项，若有，从期望匹配项中查找结果 jQuery.expr=Sizzle.selectors;// 开发者扩展sizzle jQuery.expr[":"]=jQuery.expr.pseudos;// 添加伪类选择器 jQuery.uniqueSort=jQuery.unique=Sizzle.uniqueSort;// 去重并排序 jQuery.text=Sizzle.getText;// 拼接文本 jQuery.isXMLDoc=Sizzle.isXML;// 是否xml jQuery.contains=Sizzle.contains;// 包含 jQuery.escapeSelector=Sizzle.escape;// 转义 }); 

selector-native.js（不使用sizzle，而用qsa原生语句）

define([ "./core", "./var/document", "./var/documentElement", "./var/hasOwn", "./var/indexOf" ],function(jQuery,document,documentElement,hasOwn,indexOf){ // 不使用sizzle，使用qsa查询 var hasDuplicate, sortInput, sortStable=jQuery.expando.split("").sort(sortOrder).join("")===jQuery.expando, matches=documentElement.matches || documentElement.webkitMatchesSelector || documentElement.mozMatchesSelector || documentElement.oMatchesSelector || documentElement.msMatchesSelector, rcssescape=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g, fcssescape=function(ch,asCodePoint){ if ( asCodePoint ){ if ( ch==="\0" ){ return "\uFFFD"; } return ch.slice(0,-1)+"\\"+ch.charCodeAt(ch.length-1).toString(16)+" "; } return "\\"+ch; }; function sortOrder(a,b){ if ( a===b ) { hasDuplicate=true; return 0; } var compare=!a.compareDocumentPosition-!b.compareDocumentPosition; if ( compare ){ return compare; } compare=( a.ownerDocument || a )===( b.ownerDocument || b ) ? a.compareDocumentPosition(b) : 1; if ( compare & 1 ){ if ( a===document || a.ownerDocument===document && jQuery.contains(document,a) ){ return -1; } if ( b===document || b.ownerDocument===document && jQuery.contains(document,b) ){ return 1; } return sortInput ? ( indexOf.call(sortInput,a)-indexOf.call(sortInput,b) ) : 0; } return compare & 4 ? -1 : 1; } // 调用sortOrder先排序，再去重 function uniqueSort(results){ var elem, duplicates=[], j=0, i=0; hasDuplicate=false;// 有无重复项 sortInput=!sortStable && results.slice(0); results.sort(sortOrder); if ( hasDuplicate ){ while ( ( elem=results[i++ ]) ){ if ( elem===results[i] ){ j=duplicates.push(i); } } while ( j-- ){ results.splice(duplicates[j],1); } } sortInput=null; return results; } function escape(sel){ return (sel+"").replace(rcssescape,fcssescape); } jQuery.extend( { uniqueSort:uniqueSort,// 去重并排序 unique:uniqueSort, escapeSelector:escape,// 转义 // 有seed，h5语句过滤查询，无seed，qsa语句查询 find: function(selector,context,results,seed){ var elem, nodeType, i = 0; results=results || []; context=context || document; if ( !selector || typeof selector!=="string" ){ return results; } if ( ( nodeType=context.nodeType )!==1 && nodeType!==9 ){ return []; } if ( seed ){ while ( ( elem=seed[i++] ) ) { if ( jQuery.find.matchesSelector(elem,selector) ){ results.push(elem); } } } else { jQuery.merge(results,context.querySelectorAll(selector)); } return results; }, // 以textContent或nodeValue属性获取单元素或多元素的文本内容 text:function(elem){ var node, ret="", i=0, nodeType=elem.nodeType; if ( !nodeType ){ while ( ( node=elem[i++] ) ){ ret += jQuery.text(node); } }else if( nodeType===1 || nodeType===9 || nodeType===11 ){ return elem.textContent; }else if( nodeType===3 || nodeType===4 ){ return elem.nodeValue; } return ret; }, // 原生语句判断是否包含，a、b为dom对象的形式 contains:function(a,b){ var adown=a.nodeType===9 ? a.documentElement : a, bup=b && b.parentNode; return a===bup || !!( bup && bup.nodeType===1 && adown.contains(bup) ); }, // 判断是否xml isXMLDoc:function(elem){ var documentElement=elem && (elem.ownerDocument || elem).documentElement; return documentElement ? documentElement.nodeName!=="HTML" : false; }, expr:{ attrHandle:{},// 由开发者添加获取属性的方法 match: { bool:new RegExp( "^(?:checked|selected|async|autofocus|autoplay|controls|defer" + "|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped)$", "i" ), needsContext: /^[\x20\t\r\n\f]*[>+~]/ } } } ); jQuery.extend(jQuery.find,{ // elements滤除不匹配expr的元素 matches:function(expr,elements){ return jQuery.find(expr,null,null,elements); }, // 使用原生语句判断元素是否匹配选择器 matchesSelector:function(elem,expr){ return matches.call(elem,expr); }, // 自定义jQuery.expr获取属性，区别对待xml的考虑，否则使用elem.getAttribute方法 attr:function(elem,name){ var fn=jQuery.expr.attrHandle[name.toLowerCase()], value=fn && hasOwn.call( jQuery.expr.attrHandle,name.toLowerCase() ) ? fn(elem,name,jQuery.isXMLDoc(elem)) : undefined; return value!==undefined ? value : elem.getAttribute(name); } }); });