@ -3681,81 +3681,114 @@ if ( !jQuery.support.submitBubbles ) {
}
// IE change delegation and checkbox/radio fix
// 判断jQuery是否不支持change事件冒泡（ ， ）
if ( ! jQuery . support . changeBubbles ) {
// 为jQuery的事件系统中的'special'对象添加名为'change'的自定义事件相关配置
jQuery . event . special . change = {
// 'setup'函数会在绑定事件时被调用，用于进行一些初始化设置
setup : function ( ) {
// 测试当前节点的节点名是否匹配特定的表单元素相关的正则表达式（ ）
if ( rformElems . test ( this . nodeName ) ) {
// IE doesn't fire change on a check/radio until blur; trigger it on click
// after a propertychange. Eat the blur-change in special.change.handle.
// This still fires onchange a second time for check/radio after blur.
// 在IE浏览器中， （ ） （ ） （ ） ， （ ） （ ）
// 并且在'special.change.handle'中处理掉因失去焦点导致的重复的'change'事件触发情况。
// 但这样对于复选框和单选框在失去焦点后还是会第二次触发'onchange'事件。
if ( this . type === "checkbox" || this . type === "radio" ) {
// 为当前元素添加名为'propertychange._change'的事件监听器，当属性改变事件发生时执行下面的回调函数
jQuery . event . add ( this , "propertychange._change" , function ( event ) {
// 如果属性改变事件的原始事件中属性名为'checked'（也就是复选框或单选框的选中状态改变了）
if ( event . originalEvent . propertyName === "checked" ) {
// 标记当前元素刚刚发生了改变
this . _just _changed = true ;
}
} ) ;
// 为当前元素添加名为'click._change'的事件监听器，当点击事件发生时执行下面的回调函数
jQuery . event . add ( this , "click._change" , function ( event ) {
// 如果当前元素刚刚发生了改变且不是通过代码手动触发的事件（!event.isTrigger）
if ( this . _just _changed && ! event . isTrigger ) {
// 重置刚刚改变的标记
this . _just _changed = false ;
// 模拟触发'change'事件， （ ， ）
jQuery . event . simulate ( "change" , this , event , true ) ;
}
} ) ;
}
// 表示不需要执行默认的事件绑定逻辑了（ ）
return false ;
}
// Delegated event; lazy-add a change handler on descendant inputs
// 如果是委托事件（意味着事件是绑定在父元素上，等待子元素触发的情况）
// 延迟添加一个针对后代输入元素的'change'事件处理程序
jQuery . event . add ( this , "beforeactivate._change" , function ( e ) {
// 获取实际触发事件的目标元素
var elem = e . target ;
// 再次测试目标元素的节点名是否匹配特定表单元素正则，并且该元素还没有添加过'_change'相关的事件处理程序（!elem._change_attached）
if ( rformElems . test ( elem . nodeName ) && ! elem . _change _attached ) {
// 为目标元素添加名为'change._change'的事件监听器，当'change'事件发生时执行下面的回调函数
jQuery . event . add ( elem , "change._change" , function ( event ) {
// 如果目标元素有父元素，并且事件不是模拟触发的（!event.isSimulated） （ ）
if ( this . parentNode && ! event . isSimulated && ! event . isTrigger ) {
// 模拟触发父元素的'change'事件， （ ）
jQuery . event . simulate ( "change" , this . parentNode , event , true ) ;
}
} ) ;
// 标记该元素已经添加过'_change'相关的事件处理程序了
elem . _change _attached = true ;
}
} ) ;
} ,
// 'handle'函数用于处理实际触发的事件，决定是否执行默认的事件处理逻辑等
handle : function ( event ) {
// 获取实际触发事件的目标元素
var elem = event . target ;
// Swallow native change events from checkbox/radio, we already triggered them above
// 如果当前处理事件的对象不是目标元素本身（ ） ， （ ） ， （ ） ，
if ( this !== elem || event . isSimulated || event . isTrigger || ( elem . type !== "radio" && elem . type !== "checkbox" ) ) {
// 执行默认的事件处理程序， ， （ ）
return event . handleObj . handler . apply ( this , arguments ) ;
}
} ,
// 'teardown'函数会在解绑事件时被调用，用于清理相关的事件绑定等操作
teardown : function ( ) {
// 移除当前元素上所有名称包含'._change'的事件监听器
jQuery . event . remove ( this , "._change" ) ;
// 返回当前节点的节点名是否匹配特定表单元素的正则表达式的测试结果（可能用于判断是否还有相关清理工作要做等）
return rformElems . test ( this . nodeName ) ;
}
} ;
}
// Create "bubbling" focus and blur events
// 判断jQuery是否不支持焦点进入（ ） （ ） （ ， ）
if ( ! jQuery . support . focusinBubbles ) {
// 遍历包含'focus'和'blur'的对象，将'focus'映射为'focusin'，
jQuery . each ( { focus : "focusin" , blur : "focusout" } , function ( orig , fix ) {
// Attach a single capturing handler while someone wants focusin/focusout
// 用于记录当前有多少个地方想要使用'focusin'或'focusout'事件，
var attaches = 0 ,
// 定义事件处理函数，用于模拟触发对应的'fix'（也就是'focusin'或'focusout'）事件
handler = function ( event ) {
jQuery . event . simulate ( fix , event . target , jQuery . event . fix ( event ) , true ) ;
} ;
// 为jQuery的事件系统中的'special'对象添加名为'fix'（也就是'focusin'或'focusout'）的自定义事件相关配置
jQuery . event . special [ fix ] = {
//'setup'函数会在绑定'focusin'或'focusout'事件时被调用，用于进行初始化设置
setup : function ( ) {
// 当第一次有地方绑定该事件时（ ， ）
if ( attaches ++ === 0 ) {
// 在文档对象上添加原生的'orig'（也就是'focus'或'blur'）事件的捕获阶段监听器，绑定上面定义的'handler'函数
document . addEventListener ( orig , handler , true ) ;
}
} ,
// 'teardown'函数会在解绑'focusin'或'focusout'事件时被调用，用于清理相关操作
teardown : function ( ) {
// 当所有绑定该事件的地方都解绑了（ ）
if ( -- attaches === 0 ) {
// 移除文档对象上对应的原生'orig'（也就是'focus'或'blur'）事件的捕获阶段监听器
document . removeEventListener ( orig , handler , true ) ;
}
}
@ -3763,68 +3796,84 @@ if ( !jQuery.support.focusinBubbles ) {
} ) ;
}
// 使用jQuery.fn.extend方法来扩展jQuery的原型对象，
jQuery . fn . extend ( {
// on方法用于绑定事件，
on : function ( types , selector , data , fn , /*INTERNAL*/ one ) {
var origFn , type ;
// Types can be a map of types/handlers
// 第一种情况： ，
if ( typeof types === "object" ) {
// ( types-Object, selector, data )
// 如果selector参数不是字符串类型（ ， ， ） ， ，
if ( typeof selector !== "string" ) { // && selector!= null
// ( types-Object, data )
// 将data参数赋值为原本的selector（ ） ， ， ( types-Object, data )的参数预期
data = data || selector ;
selector = undefined ;
}
// 遍历传入的types对象的每个属性（ ）
for ( type in types ) {
// 递归调用on方法， ，
this . on ( type , selector , data , types [ type ] , one ) ;
}
// 返回当前的jQuery对象实例，
return this ;
}
// 第二种情况： ， ， ，
if ( data == null && fn == null ) {
// ( types, fn )
fn = selector ;
data = selector = undefined ;
} else if ( fn == null ) {
// 如果fn为null， ， ， ， ，
if ( typeof selector === "string" ) {
// ( types, selector, fn )
fn = data ;
data = undefined ;
} else {
// ( types, data, fn )
// 如果selector不是字符串类型， ( types, data, fn )， ， ，
fn = data ;
data = selector ;
selector = undefined ;
}
}
// 如果fn的值为false， （ ， ， ）
if ( fn === false ) {
fn = returnFalse ;
} else if ( ! fn ) {
// 如果fn为假值（ ） ， ，
return this ;
}
// 如果one参数的值为1，
if ( one === 1 ) {
origFn = fn ;
// 重新定义fn函数， ， （ ， ， ， ， ） ， （ ）
fn = function ( event ) {
// Can use an empty set, since event contains the info
jQuery ( ) . off ( event ) ;
return origFn . apply ( this , arguments ) ;
} ;
// Use same guid so caller can remove using origFn
// 让新的fn函数继承原本origFn函数的唯一标识符（ ） ， ， ，
fn . guid = origFn . guid || ( origFn . guid = jQuery . guid ++ ) ;
}
// 遍历当前jQuery对象集合中的每个元素， ，
return this . each ( function ( ) {
jQuery . event . add ( this , types , fn , data , selector ) ;
} ) ;
} ,
// one方法是对on方法的一个简单封装， ，
one : function ( types , selector , data , fn ) {
return this . on ( types , selector , data , fn , 1 ) ;
} ,
// off方法用于解绑事件，
off : function ( types , selector , fn ) {
// 如果types参数是一个已经触发过的jQuery.Event对象（ ） ，
if ( types && types . preventDefault && types . handleObj ) {
// ( event ) dispatched jQuery.Event
// 获取事件对象中的handleObj属性，
var handleObj = types . handleObj ;
// 通过事件对象中的delegateTarget属性找到对应的元素（ ） ， ，
jQuery ( types . delegateTarget ) . off (
handleObj . namespace ? handleObj . origType + "." + handleObj . namespace : handleObj . origType ,
handleObj . selector ,
@ -3832,116 +3881,142 @@ jQuery.fn.extend({
) ;
return this ;
}
// 如果types参数是一个对象，
if ( typeof types === "object" ) {
// ( types-object [, selector] )
// 遍历传入的types对象的每个属性（ ）
for ( var type in types ) {
// 递归调用off方法， ，
this . off ( type , selector , types [ type ] ) ;
}
return this ;
}
// 如果selector参数是false或者是一个函数类型， ， ，
if ( selector === false || typeof selector === "function" ) {
// ( types [, fn] )
fn = selector ;
selector = undefined ;
}
// 如果fn的值为false， （ ）
if ( fn === false ) {
fn = returnFalse ;
}
// 遍历当前jQuery对象集合中的每个元素， ，
return this . each ( function ( ) {
jQuery . event . remove ( this , types , fn , selector ) ;
} ) ;
} ,
// bind方法是对on方法的一种简化调用形式， ， ， ，
bind : function ( types , data , fn ) {
return this . on ( types , null , data , fn ) ;
} ,
// unbind方法是对off方法的一种简化调用形式， ， ， ，
unbind : function ( types , fn ) {
return this . off ( types , null , fn ) ;
} ,
// live方法用于给当前元素的上下文（ ） ， ， （ ） ， ，
live : function ( types , data , fn ) {
jQuery ( this . context ) . on ( types , this . selector , data , fn ) ;
return this ;
} ,
// die方法用于移除通过live方法绑定的事件， ， （
die : function ( types , fn ) {
jQuery ( this . context ) . off ( types , this . selector || "**" , fn ) ;
return this ;
} ,
// delegate方法是对on方法的另一种调用形式， ， ，
delegate : function ( selector , types , data , fn ) {
return this . on ( types , selector , data , fn ) ;
} ,
// undelegate方法用于移除通过delegate方法绑定的事件， ， ， ， ； ，
undelegate : function ( selector , types , fn ) {
// ( namespace ) or ( selector, types [, fn] )
return arguments . length == 1 ? this . off ( selector , "**" ) : this . off ( types , selector , fn ) ;
} ,
// trigger方法用于触发指定的事件， ， ，
trigger : function ( type , data ) {
return this . each ( function ( ) {
jQuery . event . trigger ( type , data , this ) ;
} ) ;
} ,
// triggerHandler方法用于触发指定的事件， ， （ ） ， （ ， ） ， ， （ ）
triggerHandler : function ( type , data ) {
if ( this [ 0 ] ) {
return jQuery . event . trigger ( type , data , this [ 0 ] , true ) ;
}
} ,
// toggle方法用于实现点击事件的切换效果，
toggle : function ( fn ) {
// Save reference to arguments for access in closure
// 保存传入的所有参数，方便在闭包中访问
var args = arguments ,
guid = fn . guid || jQuery . guid ++ ,
i = 0 ,
toggler = function ( event ) {
// Figure out which function to execute
// 计算出当前应该执行的函数索引， （ ， ， ， ） ，
var lastToggle = ( jQuery . _data ( this , "lastToggle" + fn . guid ) || 0 ) % i ;
// 更新当前元素上存储的上一次执行的函数索引， ，
jQuery . _data ( this , "lastToggle" + fn . guid , lastToggle + 1 ) ;
// Make sure that clicks stop
// 阻止事件的默认行为， （ ）
event . preventDefault ( ) ;
// and execute the function
// 执行对应的函数， ， （ ）
return args [ lastToggle ] . apply ( this , arguments ) || false ;
} ;
// link all the functions, so any of them can unbind this click handler
// 让toggler函数继承传入函数的唯一标识符（ ） ，
toggler . guid = guid ;
// 遍历所有传入的函数参数， （ ） ，
while ( i < args . length ) {
args [ i ++ ] . guid = guid ;
}
// 将toggler函数绑定到当前jQuery对象集合的点击事件（ ） ，
return this . click ( toggler ) ;
} ,
// hover方法用于方便地绑定鼠标移入（ ） （ ） ， ， ，
hover : function ( fnOver , fnOut ) {
return this . mouseenter ( fnOver ) . mouseleave ( fnOut || fnOver ) ;
}
} ) ;
// 遍历一个包含众多常见事件名称的字符串，通过空格分割后得到的事件名称数组，对每个事件名称进行相关操作
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对象（ ） ，
jQuery . fn [ name ] = function ( data , fn ) {
if ( fn == null ) {
fn = data ;
data = null ;
}
// 根据传入参数的个数来决定是绑定事件（ ） （ ， ） ， ，
return arguments . length > 0 ?
this . on ( name , null , data , fn ) :
this . trigger ( name ) ;
} ;
// 如果jQuery.attrFn对象存在（ ， ） ， （ ）
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 ;
}
@ -3955,57 +4030,72 @@ jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblcl
* Released under the MIT , BSD , and GPL Licenses .
* More information : http : //sizzlejs.com/
* /
// 立即执行函数，创建一个独立的作用域，避免变量污染全局环境
( function ( ) {
// 定义一个正则表达式用于分割选择器字符串，它能匹配各种复杂的选择器语法结构，例如括号包裹的内容、方括号包裹的内容、转义字符、普通字符等，并提取相关部分
var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g ,
// 生成一个随机的扩展属性名称（用于在对象上添加自定义属性来做一些标记等操作，避免与其他属性冲突），通过在随机数基础上处理得到一个字符串
expando = "sizcache" + ( Math . random ( ) + '' ) . replace ( '.' , '' ) ,
done = 0 ,
// 获取Object原型上的toString方法的引用，
toString = Object . prototype . toString ,
hasDuplicate = false ,
baseHasDuplicate = true ,
// 用于匹配转义字符的正则表达式
rBackslash = /\\/g ,
// 用于匹配回车换行符的正则表达式
rReturn = /\r\n/g ,
// 用于匹配非单词字符（比如标点符号等）的正则表达式
rNonWord = /\W/ ;
// Here we check if the JavaScript engine is using some sort of
// optimization where it does not always call our comparision
// function. If that is the case, discard the hasDuplicate value.
// Thus far that includes Google Chrome.
// 这里检查JavaScript引擎是否使用了某种优化， （ ） ，
// 通过对包含两个0的数组进行排序操作，
[ 0 , 0 ] . sort ( function ( ) {
baseHasDuplicate = false ;
return 0 ;
} ) ;
// 定义Sizzle函数， ，
var Sizzle = function ( selector , context , results , seed ) {
// 如果没有传入results参数， ，
results = results || [ ] ;
// 如果没有传入context参数， （ ） ，
context = context || document ;
// 保存原始的查找上下文对象，方便后续可能的使用
var origContext = context ;
// 如果传入的上下文对象不是元素节点（ ， ） ， ，
if ( context . nodeType !== 1 && context . nodeType !== 9 ) {
return [ ] ;
}
// 如果没有传入选择器或者选择器类型不是字符串， （ ） ，
if ( ! selector || typeof selector !== "string" ) {
return results ;
}
// 定义一系列局部变量，用于后续在选择器解析和元素查找过程中的各种操作
var m , set , checkSet , extra , ret , cur , pop , i ,
prune = true ,
// 判断上下文是否是XML文档环境（ ， ）
contextXML = Sizzle . isXML ( context ) ,
// 用于存储分割后的选择器各个部分，方便后续按顺序处理
parts = [ ] ,
soFar = selector ;
// Reset the position of the chunker regexp (start from head)
// 重置chunker正则表达式的匹配位置（ ） ，
do {
chunker . exec ( "" ) ;
m = chunker . exec ( soFar ) ;
if ( m ) {
// 更新剩余未处理的选择器部分
soFar = m [ 3 ] ;
// 将匹配到的选择器部分添加到parts数组中
parts . push ( m [ 1 ] ) ;
// 如果存在分隔符（表示后面还有更多选择器部分需要处理），提取额外的部分并跳出循环，后续会单独处理这部分
if ( m [ 2 ] ) {
extra = m [ 3 ] ;
break ;
@ -4013,30 +4103,34 @@ var Sizzle = function( selector, context, results, seed ) {
}
} while ( m ) ;
// 如果分割后的选择器部分数量大于1， （ ）
if ( parts . length > 1 && origPOS . exec ( selector ) ) {
// 如果分割后的部分只有两个， （ ， ）
if ( parts . length === 2 && Expr . relative [ parts [ 0 ] ] ) {
// 调用posProcess函数（ ， ） ，
set = posProcess ( parts [ 0 ] + parts [ 1 ] , context , seed ) ;
} else {
// 如果第一个部分是相对位置选择器， （ ） ， （ ）
set = Expr . relative [ parts [ 0 ] ] ?
[ context ] :
Sizzle ( parts . shift ( ) , context ) ;
// 循环处理剩余的选择器部分
while ( parts . length ) {
selector = parts . shift ( ) ;
// 如果当前选择器部分是相对位置选择器，将其与下一个部分合并（因为相对位置选择器通常要和后面的部分一起处理才有意义）
if ( Expr . relative [ selector ] ) {
selector += parts . shift ( ) ;
}
// 再次调用posProcess函数处理合并后的选择器，
set = posProcess ( selector , set , seed ) ;
}
}
} else {
// Take a shortcut and set the context if the root selector is an ID
// (but not if it'll be faster if the inner selector is an ID)
// 如果选择器的根部分（ ） （ ， ， ） ， ， （ ）
if ( ! seed && parts . length > 1 && context . nodeType === 9 && ! contextXML &&
Expr . match . ID . test ( parts [ 0 ] ) && ! Expr . match . ID . test ( parts [ parts . length - 1 ] ) ) {
@ -4046,57 +4140,73 @@ var Sizzle = function( selector, context, results, seed ) {
ret . set [ 0 ] ;
}
// 如果存在上下文（也就是前面处理后找到了合适的查找起点）
if ( context ) {
// 如果传入了seed参数， ， （ ） ， （ ） ； （ ）
ret = seed ?
{ expr : parts . pop ( ) , set : makeArray ( seed ) } :
Sizzle . find ( parts . pop ( ) , parts . length === 1 && ( parts [ 0 ] === "~" || parts [ 0 ] === "+" ) && context . parentNode ? context . parentNode : context , contextXML ) ;
// 如果找到的结果中有expr属性（ ） ， ；
set = ret . expr ?
Sizzle . filter ( ret . expr , ret . set ) :
ret . set ;
// 如果还有剩余的选择器部分需要处理，则将当前的元素集合转为数组（方便后续循环处理）
if ( parts . length > 0 ) {
checkSet = makeArray ( set ) ;
} else {
// 如果没有剩余选择器部分了， ， （ ， ）
prune = false ;
}
// 循环处理剩余的选择器部分（从后往前处理，因为可能涉及到相对位置选择器等依赖后面元素的情况）
while ( parts . length ) {
cur = parts . pop ( ) ;
pop = cur ;
// 如果当前选择器部分不是相对位置选择器，将其设为空字符串（可能有特殊处理逻辑，比如当作普通选择器等情况）
if ( ! Expr . relative [ cur ] ) {
cur = "" ;
} else {
// 如果是相对位置选择器，取出下一个选择器部分（可能和当前相对位置选择器配合使用）
pop = parts . pop ( ) ;
}
// 如果取出的配合使用的选择器部分为null（ ） ， （ ）
if ( pop == null ) {
pop = context ;
}
// 调用相对位置选择器对应的处理函数（ ， ） ， ，
Expr . relative [ cur ] ( checkSet , pop , contextXML ) ;
}
} else {
// 如果没有合适的上下文（ ） ， ，
checkSet = parts = [ ] ;
}
}
// 如果checkSet为空（ ） ， （ ）
if ( ! checkSet ) {
checkSet = set ;
}
// 如果checkSet仍然为空， ， （ ， ） ，
if ( ! checkSet ) {
Sizzle . error ( cur || selector ) ;
}
// 判断checkSet的类型是否是数组（
if ( toString . call ( checkSet ) === "[object Array]" ) {
// 如果不需要进行筛选操作（ ） ， （ ， ）
if ( ! prune ) {
results . push . apply ( results , checkSet ) ;
} else if ( context && context . nodeType === 1 ) {
// 如果需要筛选， ， ， （ ， ， ） ，
for ( i = 0 ; checkSet [ i ] != null ; i ++ ) {
if ( checkSet [ i ] && ( checkSet [ i ] === true || checkSet [ i ] . nodeType === 1 && Sizzle . contains ( context , checkSet [ i ] ) ) ) {
results . push ( set [ i ] ) ;
@ -4104,6 +4214,7 @@ var Sizzle = function( selector, context, results, seed ) {
}
} else {
// 如果需要筛选， ， ， ，
for ( i = 0 ; checkSet [ i ] != null ; i ++ ) {
if ( checkSet [ i ] && checkSet [ i ] . nodeType === 1 ) {
results . push ( set [ i ] ) ;
@ -4112,74 +4223,105 @@ var Sizzle = function( selector, context, results, seed ) {
}
} else {
// 如果checkSet不是数组类型， （ ， ） ，
makeArray ( checkSet , results ) ;
}
// 如果存在额外的选择器部分（前面分割出来的，还未处理的部分）
if ( extra ) {
// 递归调用Sizzle函数， （ ） （ ）
Sizzle ( extra , origContext , results , seed ) ;
// 调用Sizzle.uniqueSort函数（ ， ） ，
Sizzle . uniqueSort ( results ) ;
}
// 返回最终的查找结果数组
return results ;
} ;
// 定义Sizzle对象的uniqueSort方法，
Sizzle . uniqueSort = function ( results ) {
// 如果sortOrder存在（ ， ， ）
if ( sortOrder ) {
// 恢复hasDuplicate的值为baseHasDuplicate的值（ ， ， ）
hasDuplicate = baseHasDuplicate ;
// 使用sortOrder规则对results数组进行排序，
results . sort ( sortOrder ) ;
// 如果存在重复元素（ ）
if ( hasDuplicate ) {
// 从索引为1开始遍历results数组（ ）
for ( var i = 1 ; i < results . length ; i ++ ) {
// 如果当前元素和前一个元素相等（说明是重复元素）
if ( results [ i ] === results [ i - 1 ] ) {
// 使用splice方法从数组中移除当前这个重复元素， ， ，
results . splice ( i -- , 1 ) ;
}
}
}
}
// 返回经过去重和排序后的results数组
return results ;
} ;
// 定义Sizzle对象的matches方法， ， （ ） ， （ ） ，
Sizzle . matches = function ( expr , set ) {
return Sizzle ( expr , null , null , set ) ;
} ;
// 定义Sizzle对象的matchesSelector方法， ， （ ） ， ， （ ） ，
Sizzle . matchesSelector = function ( node , expr ) {
return Sizzle ( expr , null , null , [ node ] ) . length > 0 ;
} ;
// 定义Sizzle对象的find方法， （ ） ， （ ） ， （ ）
Sizzle . find = function ( expr , context , isXML ) {
var set , i , len , match , type , left ;
// 如果没有传入表达式（ ） ， ，
if ( ! expr ) {
return [ ] ;
}
// 遍历Expr.order数组（ ， ， ）
for ( i = 0 , len = Expr . order . length ; i < len ; i ++ ) {
type = Expr . order [ i ] ;
// 使用对应类型的左匹配正则（ ， ， ） （ ） ，
if ( ( match = Expr . leftMatch [ type ] . exec ( expr ) ) ) {
// 获取匹配到的左边部分（可能是选择器的关键标识部分等）
left = match [ 1 ] ;
// 移除匹配结果数组中的第二个元素（具体用途可能和不同查找类型的处理逻辑有关，这里不清楚具体原因，但从代码逻辑看是要去掉这个元素）
match . splice ( 1 , 1 ) ;
// 如果左边部分的最后一个字符不是转义字符（\），说明是正常的匹配情况
if ( left . substr ( left . length - 1 ) !== "\\" ) {
// 去除匹配结果数组中第二个元素（ ， ， ） （ ）
match [ 1 ] = ( match [ 1 ] || "" ) . replace ( rBackslash , "" ) ;
// 调用对应查找类型的查找函数（ ， ， ） ， ，
set = Expr . find [ type ] ( match , context , isXML ) ;
// 如果查找到了元素集合（ ）
if ( set != null ) {
// 将表达式中已经匹配并处理过的部分替换为空字符串，也就是去掉已经查找过的部分，继续处理剩余的表达式部分
expr = expr . replace ( Expr . match [ type ] , "" ) ;
// 找到元素集合后就跳出循环，因为已经完成了本次查找任务
break ;
}
}
}
}
// 如果没有找到匹配的元素集合（ ）
if ( ! set ) {
// 判断上下文对象是否有getElementsByTagName方法（
set = typeof context . getElementsByTagName !== "undefined" ?
context . getElementsByTagName ( "*" ) :
[ ] ;
}
// 返回一个包含找到的元素集合（ ） （ ） ， （ ）
return { set : set , expr : expr } ;
} ;
