/* document.getElementsBySelector(selector)
    version 0.4 simon willson march 25th 2003
    -- work in phonix0.5 mozilla1.3 opera7 ie6 
    */
    function getAllchildren(e){
        //取得一个元素的子孙，并兼容ie5
        return e.all ? e.all : e.getElementsByTgaName('*');
    }

    document.getElementsBySelector = function(selector){
        //如果不支持getElementsByTagName 则直接返回空数组
        if (!document.getElementsByTgaName) {
            return new Array();
        }

        //切割CSS选择符，分解一个个单元格（每个单元可能代表一个或多个选择器，比如p.aaa则由标签选择器和类选择器组成）
        var tokens = selector.split(' ');
        var currentContext = new Array(document);
        //从左至右检测每个单元，换言此引擎是自顶向下选择元素
        //如果集合中间为空，立即中至此循环
        for (var i = 0 ; i < tokens.length; i++) {
            //去掉两边的空白（并不是所有的空白都没有用，两个选择器组之间的空白代表着后代迭代器，这要看作者们的各显神通）
            token = tokens[i].replace(/^\s+/,'').replace(/\s+$/,'');
            //如果包含ID选择器，这里略显粗糙，因为它可能在引号里边。此选择器支持到属性选择器，则代表着可能是属性值的一部分。
            if (token.indexOf('#') > -1) {
                //假设这个选择器是以tag#id或#id的形式，可能导致bug（但这些暂且不谈，沿着作者的思路看下去）
                var bits =token.split('#');
                var tagName = bits[0];
                var id = bits[1];
                //先用id值取得元素，然后判定元素的tagName是否等于上面的tagName
                //此处有一个不严谨的地方，element可能为null,会引发异常
                var element = document.getElementById(id);
                if(tagName && element.nodeName.toLowerCase() != tagName) {
                    //没有直接返回空结合集
                    return new Array();
                }

                //置换currentContext,跳至下一个选择器组
                currentContext = new Array(element);
                continue;
            }
            //如果包含类选择器，这里也假设它以.class或tag.class的形式
            if (token.indexOf('.') > -1){
                var bits = token.split('.');
                var tagName = bits[0];
                var className = bits[1];
                if (!tagName){
                    tagName = '*';
                }
                //从多个父节点，取得它们的所有子孙
                //这里的父节点即包含在currentContext的元素节点或文档对象
                var found = new Array;//这里是过滤集合，通过检测它们的className决定去留
                var foundCount = 0;
                for (var h = 0; h < currentContext.length; h++){
                    var elements;
                    if(tagName == '*'){
                        elements = getAllchildren(currentContext[h]);
                    } else {
                        elements = currentContext[h].getElementsByTgaName(tagName);
                    }
                    for (var j = 0; j < elements.length; j++) {
                        found[foundCount++] = elements[j];
                    }
                }

                currentContext = new Array;
                for (var k = 0; k < found.length; k++) {
                    //found[k].className可能为空，因此不失为一种优化手段，但new regExp放在//外围更适合
                    if (found[k].className && found[k].className.match(new RegExp('\\b'+className+'\\b'))){
                        currentContext[currentContextIndex++] = found[k];
                    }
                }
                continue;
            }
            //如果是以tag[attr(~|^$*)=val]或[attr(~|^$*)=val]的组合形式
            if (token.match(/^(\w*)\[(\w+)([=~\|\^\$\*]?)=?"?([^\]"]*)"?\]$/)){
                var tagName = RegExp.$1;
                var attrName = RegExp.$2;
                var attrOperator = RegExp.$3;
                var attrValue = RegExp.$4;
                if (!tagName){
                    tagName = '*';
                }
                //这里的逻辑以上面的class部分相似，其实应该抽取成一个独立的函数
                var found = new Array;
                var foundCount = 0;
                for (var h = 0; h < currentContext.length; h++){
                    var elements;
                    if (tagName == '*') {
                        elements = getAllchildren(currentContext[h]);
                    } else {
                        elements = currentContext[h].getElementsByTagName(tagName);
                    }
                    for (var j = 0; j < elements.length; j++) {
                        found[foundCount++] = elements[j];
                    }
                }

                currentContext = new Array;
                var currentContextIndex = 0;
                var checkFunction;
                //根据第二个操作符生成检测函数，后面的章节有详细介绍 ，请继续关注哈
                switch (attrOperator) {
                    case '=' : //
                    checkFunction = function(e){ return (e.getAttribute(attrName) == attrValue);};
                    break;
                    case '~' :
                    checkFunction = function(e){return (e.getAttribute(attrName).match(new RegExp('\\b' +attrValue+ '\\b')));};
                    break;
                    case '|' :
                    checkFunction = function(e){ return (e.getAttribute(attrName).match(new RegExp('^'+attrValue+'-?')));};
                    break;
                    case '^' : 
                    checkFunction = function(e) {return (e.getAttribute(attrName).indexOf(attrValue) == 0);};
                    break;
                    case '$':
                    checkFunction = function(e) { return (e.getAttribute(attrName).lastIndexOf(attrValue) == e.getAttribute(attrName).length - attrValue.length);};
                    break;
                    case '*':
                    checkFunction  = function(e) {return (e.getAttribute(attrName).indexOf(attrValue) > -1 );}
                    break;
                    default :
                    checkFunction = function(e) {return e.getAttribute(attrName);}; 
                }
                currentContext = new Array;
                var currentContextIndex = 0 ;
                for (var k = 0; k < found.length; k++) {
                    if (checkFunction(found[k])) {
                        currentContext[currentContextIndex++] = found[k];
                    }
                }
                continue;
            }
            //如果没有 # . [ 这样的特殊字符，我们就当是tagName
            var tagName = token;
            var found = new Array;
            var foundCount = 0;
            for (var h = 0; h < currentContext.length; h++) {
                var elements = currentContext[h].getElementsByTgaName(tagName);
                for (var j = 0; j < elements.length; j++) {
                    found[foundCount++] = elements[j];
                }
            }
            currentContext = found;
        }
        return currentContext; //返回最后的选集
    }

    #aa p.bbb [ccc=ddd]

h1 {color: red;font-size: 14px;}

    function getChildren(el) {
        if (el.childElementCount) {
            return [].slice.call(el.children);
        }
        var ret = [];
        for (var node = el.firstChild; node; node = node.nextSibling) {
            node.nodeType == 1 && ret.push(node);
        }
        return ret;
    }

    function getNext (el) {
        if ("nextElementSibling" in el) {
            return el.nextElementSibling
        }
        while (el = el.nextSibling) {
            if (el.nodeType === 1) {
                return el;
            }
        }
        return null
    }

    function getPrev(el) {
        if ("previousElementSibling" in el) {
            return el.previousElementSibling;
        }
        while (el = el.previousSibling) {
            if (el.nodeType === 1) {
                return el;
            }
        }
        return null;
    }

window.onload = function(){
    document.querySelector("#aaa").onclick = function() {
        alert(document.querySelectorAll(":focus").length) ;// =>1
    }

    document.querySelector("#bbb").onclick = function() {
        alert(document.querySelectorAll(":hover").length); //=> 4  //4 ,html body p a
    }

    function test() {
        alert(document.querySelectorAll(":link").length);//=> 3
    }
}    

    "target": function(elem) {
        var hash = window.location && window.location.hash;
        return hash && hash.slice(1) === elem.id;
    }

<html>
<head>
</head>
<body lang="de">
<p>一个段落</p>
</body>
</html>

    "lang": markFunction(function(lang) {
        //lang value must be a valid iddentifider
        if (!ridentifier,test(lang || "") + lang);
    }
    lang = lang.replace(runescape, funescape).toLowerCase();
    return function(elem) {
        var ememLang;
        do {
            if ((ememLang = documentIsXML ? elem.getAttribute("xml:lang") || elem.getAttribute("lang"):elem.lang)){
                elemLang = elemLang.toLowerCase();
                return elemLang === lang || elemLang.indexOf(lang + "-") === 0;
            }
        } while ((elem = elem.parentNode) && elem.nodeType === 1);
        return false;
       }
    }),

    "empty": function(elem) {
        for (elem = elem.firstChild; elem ; elem = elem.nextSibling) {
            if (elem.nodeName > "@" || elem.nodeType === 3 || elem.nodeType === 4){
                return false;
            }
        }
        return true;
    },

    "empty": function(node) {
        var child = node.firstChild;
        return !(child && child.nodeType == 1) && !(node.innerText || node.textContent || '').length;
    },

    var isXML = Sizzle.isXML = function (elem) {
        var documentElement = elem && (elem.ownDocument || elem).documentElement;
        return documentElement ? documentElement.nodeName !== "HTML" : false;
    };

    try{
        var doc = document.implementation.createDocument(null, 'HTML', null);
        alert(doc.documentElement)
        alert(isXML(doc))
    } catch (e) {
        alert("不支持creatDocument")
    }

    isXML = function(document){
        return (!!document.xmlVersion) || (!!document.xml) || (toString.call(document) == '[object XMLDocument]') || (document.nodeType == 9 && document.documentElement.nodeName != 'HTML');
    };

    var isXML = window.HTMLDocument ? function(doc) {
        return !(doc instanceof HTMLDocument)
    } : function (doc) {
        return "selectNodes" in doc
    }

    var isXML = function(doc) {
        return doc.createDocument("p").nodeName !== doc.createDocument("p").nodeName;
    }

    //sizzle 1.10.15
    if (context.ownerDocument && (elem = context.ownerDocument.getElementById(m)) && contains(context, elem) && elem.id === m) {
        results.push(elem);
        return results;
    }

        var rnative = /^[^]+\{\s*\[native \w/,
        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) :
                           a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16
                           ));
                   } :
        function (a, b) {
            if (b) {
                while ((b = b.parentNode)) {
                    if (b === a) {
                        return true
                    }
                }
            }
            return false;
        };

        //第一个节点是否包含第二个节点，same允许两者相等
        if (a === b){
            return !!same;
        }
        if (!b.parentNode)
            return false;
        if (a.contains) {
            return a.contains(b);
        } else if (a.compareDocumentPosition) {
            return !!(a.compareDocumentPosition(b) & 16);
        }

        while ((b = b.parentNode))
            if (a === b) return true;
        return false;
    }

    function comparePosition(a, b) {
        return a.compareDocumentPosition ? a.compareDocumentPosition(b) :
        a.contains ? (a != b && a.contains(b) && 16) +
          (a.sourceIndex >= 0 && b.sourceIndex >= 0 ?
          (a.sourceIndex < b.sourceIndex && 4) +
          (a.sourceIndex > b.sourceIndex && 2): 1) : 0;
    }

    var compare =comparerange.compareBoundaryPoints(how, sourceRange);

window.onload = function () {
    function shuffle(a) {
        //洗牌
        var array = a.concat();
        var i = array.length;
        while (i) {
            var j = Math.floor(Math.random() * i);
            var t = array[--i];
            array[i] = array[j];
            array[j] = t;
        }
        return array;
    }
    var log = function(s) {
        //查看调试消息
        window.console && window.console.log(s)
    }

    var sliceNodes = function(arr){
        //将NodeList转化为纯数组
        var ret = [],
               i = arr.length;
        while (i)
            ret [--i] = arr[i];
        return ret;
    }

    var sortNodes = function(a, b) {
        //节点排序
        var p = "parentNode",
              ap = a[p],
              bp = b[p];
        if (a === b) {
            return 0
        } else if (ap === bp) {
            while (a = a.nextSibling) {
                if (a === b) {
                    return -1
                }
            }
            return 1
        } else if (!ap) {
            return -1
        } else if (!bp) {
            return 1
        }
        var al = [],
            ap = a
        //不断往上取，一值取到HTML
        while (ap && ap.nodeType === 1) {
            al[al.length] = ap
            ap = ap[p]
        }
        var bl =[],
            bp = b;
        while (bp && bp.nodeType === 1) {
            bl[bl.length] = bp
            bp = bp[p]
        }
        //然后一起去掉公共祖先
        ap = al.pop();
        bp = bl.pop();
        while(ap === bp) {
            ap = al.pop();
            bp = bl.pop();
        }
        if (ap && bp) {
            while (ap = ap.nextSibling) {
                if (ap === bp) {
                    return -1
                }
            }
            return 1;
        }
    return ap ? 1 : -1    
    }
    var els = document.getElementsByTagName("*")
    els = sliceNodes(els); //转换成纯数组
    log(els);

    els = shuffle(els); //洗牌的过程(模拟选择器引擎最初得到的结果集的情况)
    log(els);
    els = els.sort(sortNodes); //进行节点排序
    log(els)
}

     /[\w\u00a1-\uFFFF][\w\u00a1-\uFFFF-]*|[#.:\[][\w\(\)\]]+|\s*[>+~,*]\s*|\s+/g

    //让小括号里边的东西不被切割
    var reg = /[\w\u00a1-\uFFFF][\w\u00a1-\uFFFF-]*|[#.:\[](?:[\w\u00a1-\uFFFF-]|\([^\)]*\)|\])+|(?:\s*)[>+~,*](?:\s*)|\s+/g

[".td1","[aa",">","111"]

    //确保属性选择器作为一个完整的词素
    var reg = /[\w\u00a1-\uFFFF][\w\u00a1-\uFFFF-]*|[#.:](?:[\w\u00a1-\uFFFF-]|\S*\([^\)]*\))+|\[[^\]]*\]|(?:\s*)[>+~,*](?:\s*)|\s+/g

    //缩小后迭代选择器的范围
    var reg = /[\w\u00a1-\uFFFF][\w\u00a1-\uFFFF-]*|[#.:](?:[\w\u00a1-\uFFFF-]|\S+\([^\)]*\))+|\[[^\]]*\]|(?:\s*)[>+~,*](?:\s)|\s(?=[\w\u00a1-\uFFFF*#.[:])/g

    var reg_split = /^[\w\u00a1-\uFFFF\-\*]+|[#.:][\w\u00a1-\uFFFF-]+(?:\([^\])*\))?|\[[^\]]*\])|(?:\s*)[>+~,](?:\s*)|\s(?=[\w\u00a1-\uFFFF*#.[:])|^\s+/;
    
    var slim = /\s+|\s*[>+~,*]\s*$/

    function spliter(expr) {
        var flag_break = false;
        var full = []; //这里放置切割单个选择器群组得到的词素，以,为界
        var parts = []; //这里放置切割单个选择器组得到的词素，以关系选择器为界
        do {
            expr = expr.replace(reg_split,function(part) {
                if (part === ",") { //这个切割器只处理到一个并联选择器
                    flag_break = true;
                } else {
                    if (part.match(slim)) { //对于关系并联。通配符选择器两边的空白进行处理
                        //对parts进行反转，例如 div.aaa,反转先处理aaa
                        full = full.concat(parts.reverse(),part.replace(/\s/g, ''));
                        parts = [];
                    } else {
                        parts[parts.length] = part
                    }
                }
                return "";//去掉已经处理了的部分
            });
            if (flag_break) 
                break;
        } while (expr)
            full =full.concat(parts.reverse());
            !full[0] && full.shift(); //去掉开头的第一个空白
            return full;
    } 
    var expr = " div >  div#aaa,span"
    console.log(spliter(expr)); //=>  ["div", ">", "div"]

<!DOCTYPE html>
<html>
<head>
    <title></title>
    <meta charset="utf-8">
</head>
<body>
<script type="text/javascript">
window.onload = function () {
    console.log(document.querySelector("#test1[title='']")); //<div title="" id="test1"></div>
    console.log(document.querySelector("#test1[title~='']")); // null
    console.log(document.querySelector("#test1[title|='']")); //<div title="" id="test1"></div>
    console.log(document.querySelector("#test1[title^='']")); //null
    console.log(document.querySelector("#test1[title$='']")); // null
    console.log(document.querySelector("#test1[title*='']")); //null
    console.log("==========================================")
    console.log(document.querySelector("#test2[title='']")); //null
    console.log(document.querySelector("#test2[title~='']")); //null
    console.log(document.querySelector("#test2[title|='']")); //null
    console.log(document.querySelector("#test2[title^='']")); //null
    console.log(document.querySelector("#test2[title$='']")); //null
    console.log(document.querySelector("#test2[title*='']")); //null
}
</script>

<div title="" id="test1"></div>
<div title="aaa" id="test2"></div>
</body>
</html>

    var expr = ":nth-child(2n+1)"
    var rsequence = /^([#\.:])|\[\s*]((?:[-\w]|[^\x00-\xa0]|\\.)+)/
    var rpseudo = /^\(\s*("([^"]*)"|'([^']*)'|[^\(\)]*(\([^\(\)]*\))?)\s*\)/
    var rBackslash = /\\/g
        //这里把伪类从选择符里分散出来
        match = expr.match(rsequence); //[":nth-child",":",":nth-child"]
        expr = RegExp.rightContext; //用它左边的部分重写expr--> "(2n+1)"
           key = (match[2] || "").replace(rBackslash, ""); //去掉换行符 key=--> "nth-child" 
    switch (match[1]) {
        case "#":
             //id选择器 略
             break;
        case ".":
             //类选择器 略
             break;
        case ":":
             //伪类 略
             tmp = Icarus.pseudoHooks[key];
             //Icarus.pseudoHooks里边放置我们所能处理的伪类
             expr = RegExp.rightContext;//继续取它左边的部分重写expr
             if ( !! ~key.indexOf("nth")) { //如果子元素过滤伪类
                 args = parseNth[match[1]] || parseNth(match[1]);//分解小括号的传参
             } else {
                 args = match[3] || match [2] || match[1]
             }
        
        break;
        default:
            //属性选择器 略
            break;
    }

    function parseNth (expr) {
        var orig = expr
        expr = expr.replace(/^\+|\s*/g, '');//清除掉无用的空白
        var match = (expr === "even" && "2n" || expr === "odd" && "2n+1" || !/\D/.test(expr) && "0n+" + expr || expr).match(/(-?)(\d*)n([-+]?\d*)/);
        return parse_nth[orig] = {
            a: (match[1] + (match[2] || 1) - 0 ,
            b: match[3] - 0)
        };
    }

    var Sizzle = function(slelctor, context, results, seed) {
    //通过短路运算符，设置一些默认值
        results = results || [];
        context = context || document;
        //备份，因为context会被改写，如果出现并联选择器，就无法确保当前节点是对于哪一个context

        var origContext = context;
    //上下文对象必须是元素节点或文档对象
        if (context.nodeType !== 1 && context.nodeType !== 9) {
            return [];
        }
    //选择符必须是字符，且不能为空
        if (!slelctor || typeof slelctor !== "string") {
            return results;
        }    

        var m, set, checkSet, extra, ret, cur, pop, i,
            prune = true,
            contextXML = Sizzle.isXML(context),
            parts = [],
            soFar = slelctor;
    //下面是切割器的实现，每次只处理到并联选择器，extra给留下次递归自身时作传参
    //不过与其他引擎实现不同的是，它没有一下子切成选择器，而且切成选择器组与关系选择器的集合
    //比如body div > div:not(.aaa),title
    //后代选择器虽然被忽略了，但在循环这个数组时，它默认每两个选择器组与关系选择器不存在就放在后代选择器到那个位置上
        do {
            chunker.exec(""); //这一步主要讲chunker的lastIndex重置，当然是直接设置chunker.lastIndex效果也一样
            m = chunker.exec(soFar);
            if (m) {
                soFar = m[3];
                parts.push(m[1]);
                if (m[2]) { //如果存在并联选择器，就中断
                    extra = m[3];
                    break;
                }
            }
        } while (m);
        // 略....
    }

    //这是征对最左边的选择器组存在ID做出的优化
    ret = Sizzle.find(parts.shift(), context, contextXML);
    context = ret.expr ? Sizzle.filter(ret.expr, ret.set)[0] : ret.set[0]

    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);

    set = ret.expr ? Sizzle.filter(ret.expr, ret.set) : ret.set;

//sizzle.find为主查找函数
    Sizzle.find = function(expr, context, isXML) {
        var set, i, len, match, type, left;

        if (!expr) {
            return [];
        }

        for (i = 0, len = Expr.order.length; i < len; i++) {
            type = Expr.order[i];
            //读取正则，匹配想要的id class name tag
            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);
                    //如果不为undefined , 那么取得选择器组中用过的部分
                    if (set != null) {
                        expr = expr.replace(Expr.match[type], "");
                        break;
                    }
                }
            }
        }
        if (!set) { //没有的话，寻找该上下文对象的所有子孙
            set = typeof context.getElementsByTagName !== "undefined" ? context.getElementsByTagName("*") : [];
        }

        return {
            set: set,
            expr : expr
        };
    };

    Sizzle.filter = function (expr, set, inplace, not) {
        //用于生成种子集或映射集，视第三个参数而定
        //expr: 选择符
        //set: 元素数组
        //inplace: undefined, null时进入种子集模式，true时进入映射集模式
        //not: 一个布尔值，来源自去反选择器
        .....
    }

if (extara) {
    Sizzle(extra, origContext, results, seed);
    Sizzle.uniqueSort(result)
}

    if (document.querySelectorAll) { //如果支持querySelectorAll
        (function(){
            var oldSizzle = Sizzle,
                div = document.createElement("div"),
                id = "__sizzle__";
            div.innerHTML = "<p class='TEST'>test</p>";
            //safari在怪异模式下querySelectorAll不能工作，终止从写
            if (div.querySelectorAll && div.querySelectorAll(".TEST").length === 0) {
                return;
            }

            Sizzle = function(query, context, extra, seed) {
                context = context || document;
                //querySelectorAll只能用于HTML文档，在标准浏览器XML文档中实现了接口，但不工作
                if (!seed && !Sizzle.isXML(context)) {
                    //See if we find a selector to speed up
                    var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec(query);

                    if (match && (context.nodeType === 1 || context.nodeType === 9)) { //元素Element文档Document
                        //优化只有单个标签选择器的情况
                        if (match[1]) {
                            return makeArray(context.getElementsByTagName(query), extra);
                            //优化只有单个类选择的情况
                        } else if (match[2] && Expr.find.CLASS && context.getElementsByClassName) {
                            return makeArray(context.getElementsByClassName(match[2]), extra);
                        }
                    }

                    if (context.nodeType === 9) { //文档Document
                        //优化选择符为body的情况
                        //因为文档只有它一个标签，并且对于属性直接取它
                        if (query === "body" && context.body) {
                            return makeArray ([context.body], extra);
                            //优化只有ID选择器的情况
                            //speed-up: Sizzle("ID")
                        } else if (match && match[3]) {
                            var elem = context.getElementById(match[3]);
                            //注意，浏览器也会优化，它会缓存了上次的结果
                            //即便他现在移除了DOM树
                            if (elem && elem.parentNode) {
                                //ie和opera会混淆id和name,确保id等于目标值
                                if (elem.id === match[3]) {
                                    return makeArray([elem], extra);
                                }
                            } else {
                                return makeArray([], extra);
                            }
                        }
                        try {
                            return makeArray(context.querySelectorAll(query), extra);
                        } catch (queryError) {}
                        //ie8下的querySelectorAll实现存在bug，它会包含自己的集合内查找符合自己的元素节点
                        //根据规范，应该是在当前上下文中的所有子孙元素下查找，IE8下如果元素节点为Object,无法查找元素
                    } else if (context.nodeType === 1 && context.nodeName.toLowerCase() !== "object") {
                        var oldContext = context;
                            old = context.getElementById("id"),
                            nid = old || id,
                            hasParent = context.parentNode,
                            relativeHierarchySelector = /^\s*[+~]/.test(query);
                            if (!old) {
                                context.setAttribute("id" , nid);
                            } else {
                                nid = nid.replace(/'/g, "\\$&");
                            }
                            if (relativeHierarchySelector && hasParent) {
                                context = context.parentNode;
                            }
                    // 如果存在id ,则将id取出来放到这个分组的最前面，比如div b --> [id=xxx] div b
                    //不存在id，就创建一个，重复上面的操作，最后会删掉这个id
                            try {
                                if (!relativeHierarchySelector || hasParent) {
                                    return makeArray(context.querySelectorAll("[id='" + nid +"']" + query), extra);
                                }
                            } catch (pseudoError) {} finally {
                                if (!old) {
                                    oldContext.removeAttribute("id");
                                }
                            }
                    }
                }

                return oldSizzle(query, context, extra, seed);
            };
            //将原来的方法重新绑定到Sizzle函数上
            for (var prop in oldSizzle) {
                Sizzle[prop] = oldSizzle[prop];
            }

            //release memory in IE
            div = null
        })();
    }

    var tag = "getElementsByTagName", sqa = "querySelectorAll";
    console.log(document[tag]("div") == document[tag]("div")); //=>true
    console.log(document[sqa]("div") == document[sqa]("div")); //=>false

    var els = document.body.querySelectorAll('div');
    alert(els[2])//2> els.length-1