jQuery1.11源码分析(3)-----Sizzle源码中的浏览器兼容性检测和处理[原创]
上一章讲了正则表达式，这一章继续我们的前菜，浏览器兼容性处理。
先介绍一个简单的沙盒测试函数。
/**
* Support testing using an element
* @param {Function} fn Passed the created div and expects a boolean result
*/
//特性检测的一个技巧，造一个div，最后将其删掉,提供一种简单的沙盒(如果该div不加入到DOM树上，则部分属性如currentStyle会没有)
function assert( fn ) {
var div = document.createElement("div");
try {
return !!fn( div );
} catch (e) {
return false;
} finally {
// Remove from its parent by default
if ( div.parentNode ) {
//为了不造成影响，最后如果该div还在DOM树上，就将其移除掉
div.parentNode.removeChild( div );
}
// release memory in IE
// IE下对于不在DOM树里的DOM节点必须手动置为null，关于IE内存泄露的文章很多，不再赘述
div = null;
}
}
嗯，说明如注释，接下来我们先处理push函数，有些浏览器Nodelist是不能使用push的，我们先检测一下在当前浏览器下push能不能支持Nodelist，不能的话则把push换成自己的方法，使push能够支持Nodelist
// Optimize for push.apply( _, NodeList )
//居然还可以对push进行优化，看看push支不支持Nodelist
//因为Nodelist不是数组，所以在某些浏览器下没有Push方法，需要人工造一个支持nodelist的push方法。
try {
push.apply(
(arr = slice.call( preferredDoc.childNodes )),
preferredDoc.childNodes
);
// Support: Android < 4.0
// Detect silently failing push.apply
//防止安卓4.0以下版本静默失败(失败了但不报错)。
arr[ preferredDoc.childNodes.length ].nodeType;
} catch ( e ) {
//如果arr有值，即arr.length > 0，说明上述push方法是有效的，使用原生API，否则换成自己的方法
push = { apply: arr.length ?
// Leverage slice if possible
function( target, els ) {
//这里一定要用apply,否则会把整个els给Push进去而不是拆成一个个push
push_native.apply( target, slice.call(els) );
} :
// Support: IE<9
// Otherwise append directly
//这里不明白为什么。。
//因为在IE下对Nodelist执行slice会报错找不到JScript对象，所以arr.length为0
//http://www.jb51.net/article/24182.htm
function( target, els ) {
var j = target.length,
i = 0;
// Can't trust NodeList.length
//为什么IE8下不能相信长度？
while ( (target[j++] = els[i++]) ) {}
target.length = j - 1;
}
};
}
说明如注释，然后再来三发对于html元素向DOM元素转换时，部分属性会遇到的bug以及处理
// Support: IE<8
// Prevent attribute/property "interpolation"
// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
//在IE<8下会自动串改部分属性，比如下面的href会改成当前地址+#，大家可以试试。
//出现这种情况后，当我们要取某些属性时，交给代理函数进行处理，比如Expr.attrHandle
if ( !assert(function( div ) {
div.innerHTML = "<a href='#'></a>";
return div.firstChild.getAttribute("href") === "#" ;
}) ) {
addHandle( "type|href|height|width", function( elem, name, isXML ) {
if ( !isXML ) {
//getAttribute我搜了一下。。没有第二个参数，还没翻标准。。暂且认为是错的。
//我靠。。还真有第二个参数。。http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
}
});
}
// Support: IE<9
// Use defaultValue in place of getAttribute("value")
if ( !support.attributes || !assert(function( div ) {
div.innerHTML = "<input/>";
div.firstChild.setAttribute( "value", "" );
return div.firstChild.getAttribute( "value" ) === "";
}) ) {
addHandle( "value", function( elem, name, isXML ) {
if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
return elem.defaultValue;
}
});
}
// Support: IE<9
// Use getAttributeNode to fetch booleans when getAttribute lies
//使用getAttribute获取那些非attrName=attrValue形式的attr属性时，会出错，所以换成使用getAttributeNode，然后判断获得的Attr节点的specified属性，看看是否指定。
if ( !assert(function( div ) {
return div.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;
}
});
}
说明如注释，接下来我们先声明一个对象，这个对象类似于配置文件(config)的作用，嗯。。配置文件通常很长
Expr = Sizzle.selectors = {
// Can be adjusted by the user
//缓存的长度
cacheLength: 50,
//用来标识奇葩函数
createPseudo: markFunction,
//存放用来匹配的表达式
match: matchExpr,
//前面说过的，存放提取部分特殊属性的handle
attrHandle: {},
//查找过程所用的函数就存在这，后面会进行声明
find: {},
//前面说个token中有一种类型是表示两个元素的关系，这个关系处理函数用relative保存起来，first用来表示是否是查找到的第一个元素。
//例如假设tokens[i]是{type:'>',value:'>'},调用body[Expr.relative[tokens[i].type][dir]],
relative: {
">": { dir: "parentNode", first: true },
" ": { dir: "parentNode" },
"+": { dir: "previousSibling", first: true },
"~": { dir: "previousSibling" }
},
在Expr里还有三个部分：preFilter(用来对捕获组进行预处理)，filter(返回一个个matcher，最后将多个matcher编译成一个)，pseudo(其实就是filter的一种)，后续可能留出篇幅来进行讲解。
接下来我们休息一下，再一口气啃掉一个超长的初始化函数。这个初始化的主要作用是从健壮性的考虑出发，设置一下文档节点，检查一下是不是HTML，检查一下各个原生API是不是好用，检查一下querySelectorAll是不是好用，初始化查找过程用的函数(比如Expr.find['ID']);
/**
* Sets document-related variables once based on the current document
* @param {Element|Object} [doc] An element or document object to use to set the document
* @returns {Object} Returns the current document
*/
//基于当前文档节点设置一些文档相关的内容，如支持性什么的。
setDocument = Sizzle.setDocument = function( node ) {
console.log('setDocument in');
var hasCompare,
doc = node ? node.ownerDocument || node : preferredDoc, //获得文档节点的一种方式，这样写的好处是保持健壮性
parent = doc.defaultView;
// If no document and documentElement is available, return
//nodeType不等于9说明不是文档节点
//做这么多判断。。嗯。。还是为了健壮性
if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
return document;
}
// Set our document
document = doc;
docElem = doc.documentElement;
// Support tests
documentIsHTML = !isXML( doc );
// Support: IE>8
// If iframe document is assigned to "document" variable and if iframe has been reloaded,
// IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936
// IE6-8 do not support the defaultView property so parent will be undefined
//这里是一个jQuery的bug修复
if ( parent && parent !== parent.top ) {
// IE11 does not have attachEvent, so all must suffer
if ( parent.addEventListener ) {
parent.addEventListener( "unload", function() {
setDocument();
}, false );
} else if ( parent.attachEvent ) {
parent.attachEvent( "onunload", function() {
setDocument();
});
}
}
/* Attributes
---------------------------------------------------------------------- */
// Support: IE<8
// Verify that getAttribute really returns attributes and not properties (excepting IE8 booleans)
//如果这里检测通过的话，后面获取属性值用的就是getAttribute这个API，否则用的就是getAttributeNode
support.attributes = assert(function( div ) {
div.className = "i";
return !div.getAttribute("className");
});
/* getElement(s)By*
---------------------------------------------------------------------- */
// Check if getElementsByTagName("*") returns only elements
//检查getElementsByTagName是否会包含注释节点，最好不要包含。
support.getElementsByTagName = assert(function( div ) {
div.appendChild( doc.createComment("") );
return !div.getElementsByTagName("*").length;
});
// Check if getElementsByClassName can be trusted
//?????细节
support.getElementsByClassName = rnative.test( doc.getElementsByClassName ) && assert(function( div ) {
div.innerHTML = "<div class='a'></div><div class='a i'></div>";
// Support: Safari<4
// Catch class over-caching
div.firstChild.className = "i";
// Support: Opera<10
// Catch gEBCN failure to find non-leading classes
//Opera<10 的时候当一个元素有多个class的时候，获得第二个会出错。
return div.getElementsByClassName("i").length === 2;
});
// Support: IE<10
// Check if getElementById returns elements by name
// The broken getElementById methods don't pick up programatically-set names,
// so use a roundabout getElementsByName test
//????所以迂回使用getElementsByName来检测？不明原理
support.getById = assert(function( div ) {
docElem.appendChild( div ).id = expando;
return !doc.getElementsByName || !doc.getElementsByName( expando ).length;
});
//Expr里的函数分为查找和过滤两种功能类型。
//接下来分别进行这两种函数功能性的检测和支持
// ID find and filter
if ( support.getById ) {
Expr.find["ID"] = function( id, context ) {
//??????为什么要转换成字符串形式的undefined
if ( typeof context.getElementById !== strundefined && documentIsHTML ) {
var m = context.getElementById( id );
// Check parentNode to catch when Blackberry 4.6 returns
// nodes that are no longer in the document #6963
//!!!!在黑莓4.6的浏览器中会返回那些不在DOM树中的节点，所以通过该节点是否有父节点来判断该节点是否在DOM树中,bug修正，并且转换为数组形式。
return m && m.parentNode ? [m] : [];
}
};
//这里返回一个后面用来做matcher的函数
Expr.filter["ID"] = function( id ) {
//对id做编码转换，这是一种闭包类型。
var attrId = id.replace( runescape, funescape );
return function( elem ) {
return elem.getAttribute("id") === attrId;
};
};
} else {
// Support: IE6/7
// getElementById is not reliable as a find shortcut
//???getElementById不可靠？？
//!!!!删掉以后，Sizzle就不再通过ID来获取节点，获取属性的方式也由getAttribute变为getAttributeNode
delete Expr.find["ID"];
Expr.filter["ID"] = function( id ) {
var attrId = id.replace( runescape, funescape );
return function( elem ) {
//每个DOM元素下有隐含的属性节点，通过查看其属性节点的方式来过滤
var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
return node && node.value === attrId;
};
};
}
// Tag
Expr.find["TAG"] = support.getElementsByTagName ?
function( tag, context ) {
console.log('find tag begin');
if ( typeof context.getElementsByTagName !== strundefined ) {
return context.getElementsByTagName( tag );
}
} :
//否则采用过滤掉注释节点的写法。
function( tag, context ) {
console.log('find tag begin');
var elem,
tmp = [],
i = 0,
results = context.getElementsByTagName( tag );
// Filter out possible comments
//必须过滤注释节点
if ( tag === "*" ) {
//赋值判断写法。
while ( (elem = results[i++]) ) {
if ( elem.nodeType === 1 ) {
tmp.push( elem );
}
}
return tmp;
}
return results;
};
// Class
Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
console.log('find class begin');
if ( typeof context.getElementsByClassName !== strundefined && documentIsHTML ) {
return context.getElementsByClassName( className );
}
};
/* QSA/matchesSelector
---------------------------------------------------------------------- */
// QSA and matchesSelector support
// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
rbuggyMatches = [];
// qSa(:focus) reports false when true (Chrome 21)
// We allow this because of a bug in IE8/9 that throws an error
// whenever `document.activeElement` is accessed on an iframe
// So, we allow :focus to pass through QSA all the time to avoid the IE error
// See http://bugs.jquery.com/ticket/13378
//用来存放有bug的QSA字符串，最后用|连接起来当作正则表达式，用来检测选择符是否有bug
rbuggyQSA = [];
if ( (support.qsa = rnative.test( doc.querySelectorAll )) ) {
// Build QSA regex
// Regex strategy adopted from Diego Perini
//这两个assert没有返回值，主要是把有bug的QSA字符串检测出来。
assert(function( div ) {
// Select is set to empty string on purpose
// This is to test IE's treatment of not explicitly
// setting a boolean content attribute,
// since its presence should be enough
// http://bugs.jquery.com/ticket/12359
//这个bug检测很简练
div.innerHTML = "<select>
<option selected="selected"></option>
</select>";
// Support: IE8, Opera 10-12
// Nothing should be selected when empty strings follow ^= or $= or *=
//!!!空白字符串不应该跟在 ^=、$=、*=这样的字符后面，否则逻辑上是走不通的，你想想啊，^=''的意思是匹配开头为空字符的字符串。。哪个字符串开头是空字符？，剩下同理
if ( div.querySelectorAll("[t^='']").length ) {
rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
}
// Support: IE8
// Boolean attributes and "value" are not treated correctly
//!!!IE8中的QSA不能正确识别非key=value形式的属性选择符
if ( !div.querySelectorAll("[selected]").length ) {
rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
}
// Webkit/Opera - :checked should return selected option elements
// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
// IE8 throws error here and will not see later tests
//!!!!:checked伪类选择器理论应该返回被选择的option元素，但IE8下有bug。。
if ( !div.querySelectorAll(":checked").length ) {
rbuggyQSA.push(":checked");
}
});
assert(function( div ) {
// Support: Windows 8 Native Apps
// The type and name attributes are restricted during .innerHTML assignment
//????卧槽。。win8不能直接用innerHTML来创建type和name属性？
var input = doc.createElement("input");
input.setAttribute( "type", "hidden" );
div.appendChild( input ).setAttribute( "name", "D" );
// Support: IE8
// Enforce case-sensitivity of name attribute
//!!!!增强对name大小写的敏感性，如果大小写不敏感，则不能使用带有name=.的属性选择符
if ( div.querySelectorAll("[name=d]").length ) {
rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
}
// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
// IE8 throws error here and will not see later tests
//!!!!理论上hidden的元素还应该能用:enabled伪类选择符选择到的，但IE8和FF3.5下有bug
if ( !div.querySelectorAll(":enabled").length ) {
rbuggyQSA.push( ":enabled", ":disabled" );
}
// Opera 10-11 does not throw on post-comma invalid pseudos
//?????
div.querySelectorAll("*,:x");
rbuggyQSA.push(",.*:");
});
}
if ( (support.matchesSelector = rnative.test( (matches = docElem.webkitMatchesSelector ||
docElem.mozMatchesSelector ||
docElem.oMatchesSelector ||
docElem.msMatchesSelector) )) ) {
assert(function( div ) {
// Check to see if it's possible to do matchesSelector
// on a disconnected node (IE 9)
//!!!!检测是否matchesSelector会匹配到没有连接的节点
support.disconnectedMatch = matches.call( div, "div" );
// This should fail with an exception
// Gecko does not error, returns false instead
//?????
matches.call( div, "[s!='']:x" );
rbuggyMatches.push( "!=", pseudos );
});
}
rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
/* Contains
---------------------------------------------------------------------- */
hasCompare = rnative.test( docElem.compareDocumentPosition );
// Element contains another
// Purposefully does not implement inclusive descendent
// As in, an element does not contain itself
//这里和懒函数的方式异曲同工,如果有原生compareDocumentPosition或contains
contains = hasCompare || rnative.test( docElem.contains ) ?
function( a, b ) {
console.log('contains begin');
var adown = a.nodeType === 9 ? a.documentElement : a,
bup = b && b.parentNode;
return a === bup || !!( bup && bup.nodeType === 1 && (
adown.contains ?
adown.contains( bup ) :
//这里&上16仅仅是判断a是否包含bup，b如果是a本身，则两者应该不算包含关系
//http://www.2cto.com/kf/201301/181075.html
a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
));
} :
//否则就用土办法不断遍历DOM树
function( a, b ) {
if ( b ) {
while ( (b = b.parentNode) ) {
if ( b === a ) {
return true;
}
}
}
return false;
};
/* Sorting
---------------------------------------------------------------------- */
// Document order sorting
//用来传给sort函数的排序方法
sortOrder = hasCompare ?
function( a, b ) {
// Flag for duplicate removal
if ( a === b ) {
hasDuplicate = true;
return 0;
}
// Sort on method existence if only one input has compareDocumentPosition
//!undefined === true
//!function (){} === false
//if(-1){console.log(1);} -->1
//用以检查是否两个输入都有该API
var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
if ( compare ) {
return compare;
}
// Calculate position if both inputs belong to the same document
compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
a.compareDocumentPosition( b ) :
// Otherwise we know they are disconnected
1;
// Disconnected nodes
if ( compare & 1 ||
(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
// Choose the first element that is related to our preferred document
if ( a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
return -1;
}
if ( b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
return 1;
}
// Maintain original order
return sortInput ?
//最后这里处理了给字符串调用sort的情况
//后面有一句代码
//support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
0;
}
return compare & 4 ? -1 : 1;
} :
//如果没有contains这样的原生API使用
function( a, b ) {
// Exit early if the nodes are identical
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 === doc ? -1 :
b === doc ? 1 :
aup ? -1 :
bup ? 1 :
sortInput ?
( indexOf.call( sortInput, a ) - indexOf.call( 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 doc;
};
上面这个初始化函数实在太长。。再调用一下就好。
// Initialize against the default document setDocument();
