CSS selector (jquery的源码分析，修改）

  1. 在jquery.fn.init()中，我们对这句jQuery(context).find(selector)没有深入去分析，在使用$()时候，大部分时间都是在使用这句来完成功能的。它就是调用CSS Selector到Dom树去查找和相符CSS语法的元素节点（集）。jQuery名字中query的意义就体现在这里。   
  2. 根据符合CSS语法的字符串，它是怎么到DOM文档树去找到符合条件的元素呢？无论怎么解析这个字符串，它总得有调用最原始的函数来完成功能，这些函数是什么？   
  3. 在没有分析Selector源码之前，说来也不会相信功能强大的selector是建立在元素的getElementsByTagName，getElementById直接引用和元素的childNodes firstChild、lastChild、nextSibling、parentNode、previousSibling等间接引用这些函数的使用。   
  4. 在分析源码之前，我们得了解一下CSS selector，它可以粗略分成几类基本的类型：ID选择器（#id），Class选择器(.class)，类型（type）选择器(p)，Combinators，属性（Attribute）选择器，Pseudo Classes选择器等。这些都是单一的选择器，可以在应用中把它们组合起来，如：div#id, div:last-child。   
  5. 我们先分析一个例子：span[class=’test’]，它是属性选择器，我们一般把它做一个整体来理解：在Dom文档树中找到其class等于’test’的且标签为span的元素。这是一步到位，直接从dom文档树查找（select）所需要的元素。   
  6. 其实我们更细一点分析，完成可以把这个字符串拆分成两步走，第一步是根据document.getElementsByTagName(tagName)取得span的元素集，第二步是再根据其class是否等于test来进行判断，把不等于的元素从结果集中去掉。   
  7. 不光是属性选择器，对所有的复合的选择器，都可以根据这种细粒度来拆分选择器，接下来就是分别是每个小部分进行操作。如果这样，我们就能把CSS selector分成两大类，第一类是是选择（selector），从根据给定的selector从Dom树找到相关的元素节点放到结果集中来。第二类是筛选(filter)。在结果集中判断该元素还满足表达式。   
  8. 这样一来，就完全可以JS的原有直接或间接对Dom元素进行引用的方法，如div#id就可以变成先找到div的元素，之后就判断其元素的id是否等于id，如果不等于就从结果集中删除掉。而对于div[id=’bar’]也是一样，可以看出div#id与div[id=’id’]是一样的操作。对于div.class也可以转换到属性中去操作。   
  9. 现在要做的事就分析那些基本选择器是完成选择（selector）还是筛选(filter)的工作。我们把类型选择器，Combinators统一称为元素选择器，其形式如下：*，E F，E~F，E+F，E>F，E/F，E。这些一定是从dom树中选择元素。   
  10. 对于ID选择器和Class选择器，它们也可以在selector字符串的起始位置，说明他们也可以完成选择（selector）功能。当它们不在起始位置上，如div#id，div.class那他们就是筛选器。我们可以变通一下统一起来，对于ID选择器可以采用document.getElementById来直接引用。但是对于.class就不一样了，它没有相对的函数。这种情况下，我们可以把它变成*.class。*能取得一个范围内的所有的元素，然后再进行筛选。这样对于ID选择器，它有专门的函数来处理，是选择（selector）器。对Class选择器，它是筛选器，特殊情况就是对于*标签取到元素集进行筛选。   
  11. 其它如属性（Attribute）选择器，Pseudo Classes都是筛选器，只能附在一个元素或多个元素后面。，特殊情况就是对于*标签取到元素集进行筛选。   
  12. 看一个：div.foo:nth-child(odd)[@foo=bar]#aId > a的例子：   
  13. 第一步：找到div type选择器的所有元素。   
  14. 第二步：在这些元素中找到class为foo的元素。如果没有就根本不要去分析下面的字符。   
  15. 第三步：根据:nth-child(odd)找到元素的子孩子元素为偶数的的元素。进一步筛选了。   
  16. 第四步：找到[],就是属性筛选器了，根据foo属性值bar来判断集合中还有那些满足条件。   
  17. 第五步：在这些元素集合，找到id=aId的元素，进一步筛选。   
  18. 第六步：在这些元素集合中找到所有元素对应的子元素类型为a的所有子元素。   
  19. 结果：我们可以看到，现在元素是子元素的集合。   
  20.   
  21. 讲完了通版的大道理，接下来就是来看看jQuery是怎么实现的：   
  22. // 搜索所有与指定表达式匹配的元素。这个函数是找出正在处理的元素的后代元素的好方法。   
  23. // 所有搜索都依靠jQuery表达式来完成。这个表达式可以使用CSS1-3的选择器语法来写。   
  24.     find : function(selector) {   
  25.     var elems = jQuery.map(this, function(elem) {// 找到每个元素的满足的   
  26.                 return jQuery.find(selector, elem); });   
  27.         return this.pushStack(/[^+>] [^+>]/.test(selector) ? jQuery   
  28.                 .unique(elems) : elems);// 是不是返回不重复的元素？   
  29.     },   
  30. 这是jquery.fn.init调用的find方法。它只是完成之本本对象集合中每一个元素都调用jQuery.find(selector, elem)方法，组合成新unique集合后构建新jquery对象。最重要的实质性的工作在jQuery.find(selector, elem)完成：   
  31.   
  32. find : function(t, context) {   
  33. if (typeof t != "string")return [t];// 快速处理非字符表达式   
  34. if (context && context.nodeType != 1 && context.nodeType != 9)   
  35.         return [];// 确保context是DOM元素或document   
  36.     context = context || document;// 缺省的context   
  37. // 初始化，ret:result, done:已经完成，last:上一次的t,nodeName:节点名，   
  38. var ret = [context], done = [], last, nodeName;   
  39.      
  40.     //这里就是把复合选择器的字符串从左到右取最小单元的选择进行分析操作   
  41.     //分析操作完之后就这个分析过的字符串部分给删除，   
  42.     //然后循环分析接下来的剩余的部分。直到字符串为空。   
  43.     //这里的最小单元指如#id,~F(+F,>F),.class,[id='xx'],F,:last()之类   
  44. while (t && last != t) {// t存在，且变化   
  45.         var r = []; // ret的tempValue   
  46.         last = t; // last:上一次的t   
  47.         t = jQuery.trim(t);// 去首尾空格   
  48.   
  49.         var foundToken = false, re = quickChild, // 以>开头的regexp   
  50.         m = re.exec(t);   
  51.            
  52.        //这一部分处理了>,+,~的元素选择器。当然有的后代，有的兄弟选择的。   
  53. // 首先判断是不是以>开头，因为每次处理都处理都删除分析过的字符串部分    
  54.      //这里可以看作是>作为找到tagName元素的子节点们的标记   
  55.     if (m) {                                                           ①   
  56.             nodeName = m[1].toUpperCase();//tagName   
  57.   
  58.     //在结果集中（第一次是默认是给定的context）找到满足的tagName元素的所有子节点。   
  59.     //两个循环，第一是对结果集中每个元素进行，第二个是对每个元素中每个子元素节点。   
  60.     //找到结果集中所有的元素的所有子元素的集合。   
  61.         for (var i = 0;ret[i]; i++)   
  62.             for (var c = ret[i].firstChild;c; c = c.nextSibling)   
  63.             if (c.nodeType == 1&& (nodeName == "*" ||    
  64. c.nodeName.toUpperCase() == nodeName))   
  65.                     r.push(c);   
  66.             ret = r; // 现在找到的所有元素都是结果集   
  67.             t = t.replace(re, "");// remove已经处理过的字符串部分   
  68.                
  69.         //对于E （F，>F,+F etc)的形式，这里跳过后面的代码又回到while处执行。   
  70.         //但是在while处之后会把这个空格去掉。好像没有进行操作。这里变化了是ret。   
  71.         //无论后面是怎样的最小单元选择器，都是要根据这个个ret中的元素来进行操作。   
  72.         //如果是tagName，那么就是转4处执行ret[i].getElementsByTagName().   
  73.         //如果是>tagName,就执行1处的代码，其它的省略，   
  74.         //可见每个最小单元之后都可以是任意的空格分隔。               
  75.         if (t.indexOf(" ") == 0)continue;   
  76.         foundToken = true;// 找到标识   
  77.         }   
  78.  else {// 第二判断是不是以+~开头                                    ②   
  79.         re = /^([>+~])\s*(\w*)/i;   
  80.         if ((m = re.exec(t)) != null) {// 以+~开头的   
  81.             r = [];   
  82.             var merge = {};   
  83.             nodeName = m[2].toUpperCase();// 节点名   
  84.             m = m[1];// 符号，如+，~   
  85.            // 如果selector字符串的匹配+或~（子元素），   
  86. //在结果集中所有元素中找到其兄弟元素节点。   
  87.           //不同的+找的是后续的第一个兄弟元素，   
  88. //而~是找到所有的后续的兄弟元素节点。   
  89.          //之后把找到的所有的元素放到结果集合中。   
  90.        for (var j = 0, rl = ret.length;j < rl; j++) {   
  91.                     // 把~和+的操作统一在一起进行处理   
  92.             var n = (m == "~" || m == "+"  
  93.                             ? ret[j].nextSibling: ret[j].firstChild);   
  94.         for (;n; n = n.nextSibling)   
  95.             if (n.nodeType == 1) {// 保证节点是元素类型   
  96.                 var id = jQuery.data(n);// 为n元素生成全局唯一的id   
  97.   
  98.                 if (m == "~" && merge[id])// 保证ret中元素不重复   
  99.                     break;// nextSibling会循环到第一个节点？   
  100.              if (!nodeName|| n.nodeName.toUpperCase() == nodeName) {   
  101.                     if (m == "~")   merge[id] = true;   
  102.                 r.push(n);   
  103.               }// 直接后续兄弟节点，只进行一次操作。   
  104.             if (m == "+")   break;   
  105.           }   
  106.        }   
  107. ret = r;// 找到的所有的元素放到结果集合中。   
  108. t = jQuery.trim(t.replace(re, ""));   
  109. foundToken = true;   
  110.     }   
  111. }   
  112.         
  113. // 不是以>~+开头的或者说除去已经分析过的字符，接下来的字符是不是>~+开头   
  114. if (t && !foundToken) {                                             ③   
  115.     //这里的意思是在开始的位置找到,号，说明一个selector已经完成了，那么   
  116.     //结果集就要存到已经完成的集合中。结果集也应该初如化。   
  117.     if (!t.indexOf(",")) {                                             ④   
  118.         //说明运行到这里的时候，还是单个selector的字符串分析是刚刚开始   
  119.          //因为>~+不可能得到ret[0]元素等于元素的自身。如果等于的话，   
  120.         //那就清除出ret,因为接下来就要把ret结果集中的元素存入done中   
  121.         if (context == ret[0])  ret.shift();   
  122.         done = jQuery.merge(done, ret);// ret的其它元素放入done   
  123.         r = ret = [context];// 重新初始化               
  124.         t = " " + t.substr(1, t.length); //把,采用空格代替。   
  125.             }   
  126.  else {                                                       ⑤   
  127.         // 说明这一个selector部分还没有完成，同时还没有找到元素   
  128.         // 或者是 >F的后面用空格来分隔。                 
  129.          //* qId:^((?:[\w*_-]|\.)+)(#)((?:[\w*_-]|\.)+)   
  130.         // * qclass:^([#.]?)((?:[\\w*_-]|\.)*)                 
  131.         var re2 = quickID;// 如(.)nodeName#idName   
  132.         var m = re2.exec(t);// 找到第一个相配的   
  133.   
  134.     if (m) {m = [0, m[2], m[3], m[1]];// m=[0,#,idName,nodeName]}    
  135. else {  re2 = quickClass;// #nodeName,.className   
  136.             m = re2.exec(t);// m=[all,#,idName]}   
  137.   
  138.     m[2] = m[2].replace(/\\/g, "");// 去除转义字符   
  139.                    
  140.     //取数组的最后一个元素，其实就是为了取到是不是为document,   
  141.     //因为只有document才有getElementById，为什么不直接采用   
  142.     //document呢？难道document的查找会比先根据element.   
  143.     //getElementsByTagName找到元素下面的tagname的相符的   
  144.     //集合然后采用id属性去判断对比来得更慢吗？不一定？对于大的Dom树，   
  145.     //而element的范围又很小的话，可能会慢一些。   
  146.     //不过由于这里还要通过属性选择器来进行验证进行验证，一般来说    
  147.     //element.getElementsByTagName会快一点。   
  148.     var elem = ret[ret.length - 1];            
  149.     if (m[1] == "#" && elem && elem.getElementById   
  150.                         && !jQuery.isXMLDoc(elem)) {   
  151.             var oid = elem.getElementById(m[2]);   
  152.   
  153.         // 回测元素的ID的确存在，在IE中会取name属性的值，同时在form 元素中   
  154.         // 会选中在form中元素的name属性为id的元素。   
  155.         if ((jQuery.browser.msie || jQuery.browser.opera) && oid   
  156.                         && typeof oid.id == "string" && oid.id != m[2])   
  157.                 //通过属性选择器来进行验证。    
  158.             oid = jQuery('[@id="' + m[2] + '"]', elem)[0];   
  159.   
  160.             // 回测元素的node Name是否相同，如div#foo,可以提交效率   
  161.             ret = r = oid && (!m[3] || jQuery.nodeName(oid, m[3]))   
  162.                             ? [oid]: [];   
  163.                 }   
  164.  else {   
  165.             //这里处理了#id,.class tagName,div#id四种形式   
  166.             //这里我们还可以看出E F形式。并没有特殊的处理。就是采用了   
  167.             //E.getElementsByTagName(F)就可以了。   
  168.             //这个就能取后元素的所有后代为F和F的元素节点。   
  169.             //和F使用是统一的起来。因为E都是结果集。   
  170.          for (var i = 0;ret[i]; i++) {   
  171. //因为m有两种情况：[0,#,idName,nodeName]、[all,#/.,idName/class/tagName]   
  172. //这里就是根据这两种情况来取得tagName，m[1] == "#" && m[3]   
  173. //为真，说明是第一种，取nodeName。如果m[1] == "#" && m[3]为假   
  174. //说明m[1] <> "#"||!m[3],而m[1] != ""说明只能是第二个数组中的.或#   
  175. //说明了对于#nodeName,.className采用element.getElementsByTagName(*).   
  176. //当m[1] == ""，说明是一个E 元素选择器，它不带任何的前缀。如：p。这个时候   
  177. //m[2]是tagName.   
  178. //m[0] == "" ，只能指第二个数组中的。它=="",说明没有找到符合qclass的regExp.   
  179. //其它的情况都不会为"",它为"",!m[1],!m[2]也都为true.                         
  180.         var tag = (m[1] == "#" && m[3] ? m[3] : (m[1] != ""  
  181.                             || m[0] == "" ? "*" : m[2]));// 分情况取tagName   
  182.                           
  183.         //*的情况下，对于object标签转换为param标签进行操作。   
  184.     if (tag == "*"&& ret[i].nodeName.toLowerCase() == "object")   
  185.             tag = "param";// Handle IE7 being really dumb about <object>s   
  186.         //把结果集合中第一个元素的getElementsByTagName存入到临时的结果集中。   
  187.             r = jQuery.merge(r, ret[i].getElementsByTagName(tag));   
  188.         }   
  189.                        
  190.     //class选择器的话，就根据class属性在找到结果集合中过滤   
  191.         if (m[1] == ".")    r = jQuery.classFilter(r, m[2]);        ⑦   
  192.           //id选择器的话，就根据id属性在找到结果集合中过滤   
  193.             if (m[1] == "#") {   
  194.                 var tmp = [];   
  195.                 for (var i = 0;r[i]; i++)   
  196.                 if (r[i].getAttribute("id") == m[2]) {   
  197.                         tmp = [r[i]];   
  198.                         break;   
  199.                         }   
  200.                     r = tmp;   
  201.                 }   
  202.             ret = r;   
  203.             }   
  204.      t = t.replace(re2, "");   
  205.     }   
  206.   
  207.     }   
  208.   
  209.         //这个时候已经找到结果的集合，对于如CSS Selector为:hidden的属性筛选器，   
  210.         //它的集合就是context的下面的所有元素节点。也就是说上面的   
  211.         //代码无论如何都能找到元素的集合。这个集合可能是>/+~ F   
  212.         //或#id,.class tagName,div#id，对于不满足这些条件的，就采用   
  213.         //context.getElementsByTagName(*)要取得其下所有的元素   
  214.         //确保接下来的过滤（筛选）   
  215. if (t) {// 根据余下的selector，对找到的r集合中的元素进行过滤     ⑥     
  216.             var val = jQuery.filter(t, r);                     ⑧   
  217.             ret = r = val.r;   
  218.             t = jQuery.trim(val.t);// 去首尾空格   
  219.         }   
  220.     }   
  221.       
  222.     //如果还会有t存在说明一个问题：last == t   
  223.     //也就是上一次的过程中没有进行成功的解析一个最小单元的选择器   
  224.     //原因是输入的 t 字符串有语法上的错误。如果是采用,分隔的多选择器   
  225.     //那么就是当前及之后的选择器不分析。完成的done就是之前的结果集。   
  226.     //觉得这样处理不好，很多时间我们都会写错CSS selectror,不报错，   
  227.     //对于调试发现问题特难。      
  228.     if (t)  ret = [];   
  229.   
  230.     //出现这种情况说明运行到这里的时候，还是单个selector的字符串分析是刚刚开始   
  231.     //如果等于的话，那就清除出ret,因为接下来就要把ret结果集中的元素存入done中   
  232.     if (ret && context == ret[0])   
  233.         ret.shift();// 去掉根上下文   
  234.   
  235.     done = jQuery.merge(done, ret);// 合并   
  236.   
  237.     return done;   
  238. },   
  239. 上面find的实现的代码有点长。其实分析起来也不是很难。①②③④⑤处两个if-else是元素选择器，针对>/+~ F或#id,.class tagName,div#id这样的选择器进行查找元素，构成结果集。⑥实现的就是分析它之后的属性选择器进行筛选。这段代码说白就是select与Filte之间的交互分析CSS selector的字符串进行查找或筛选的过程。   
  240. 具体的细节在代码中有分析。在⑦处它采用先找到所有元素然后对每个元素进行class的判断来分析如.class这样selector。因为它在起始位说明是查找器。但是这里对这个最小的单元部分，我们还可能两个部分，找到所有元素，然后一个个排查，排查就是采用了jQuery.classFilter(r, m[2])：   
  241. classFilter : function(r, m, not) {   
  242.     m = " " + m + " ";//这里的做法就是怕出现如”class12”这样的问题   
  243.     var tmp = [];      //如果传的m= class1,这个的条件是满足的，实际是不。   
  244.     for (var i = 0;r[i]; i++) {   
  245.         var pass = (" " + r[i].className + " ").indexOf(m) >= 0;   
  246.         if (!not && pass || not && !pass)   
  247.             tmp.push(r[i]);   
  248.     }   
  249.     return tmp;   
  250. },   
  251. jQuery.classFilter是比较简单。在find（）的第二个部分是筛选，它调用jQuery.filter(t, r)来完成功能：   
  252.   
  253. //根据CSS selector表达式查找集合中满足该表达式的所有元素   
  254. //还可以根据not来指定不满足CSS selector表达式元素集   
  255. filter : function(t, r, not) {   
  256.     var last;   
  257.     while (t && t != last) {// t存在，且改变   
  258.         last = t;   
  259.         // Match: [@value='test'], [@foo]   
  260.         // 1、^(\[) *@?([\w:-]+) *([!*$^~=]*) *('?"?)(.*?)\4 *\]/,   
  261.   
  262.         // Match: :contains('foo')   
  263.         // 2、^(:)([\w-]+)\("?'?(.*?(\(.*?\))?[^(]*?)"?'?\)/,   
  264.   
  265.         // Match: :even, :last-child, #id, .class   
  266.         // 3、new RegExp("^([:.#]*)(" + chars + "+)")],         
  267.            
  268.         //这里可以看出我们直接调用filter的时候的selector如不是筛选器的话，   
  269.         //那就不进行筛选了，这里的selector语法如[@value='test'], [@foo]、   
  270.         //:contains('foo')，:even, :last-child, #id, .class的形式   
  271.         //可以是上面这几种形式的组合，但不能包括元素选择器。   
  272.     //而且复合的形式中间不能采用空格隔开，如[@value='test']#id.class可行的。   
  273.         var p = jQuery.parse, m;   
  274.         for (var i = 0;p[i]; i++) {// 找到与jQuery.parse中regexp相配的   
  275.             m = p[i].exec(t);   
  276.             if (m) {   
  277.                 t = t.substring(m[0].length);//删除处理过的字符部分   
  278.                 m[2] = m[2].replace(/\\/g, "");// 有可能会有没有转换的\去掉   
  279.                 break;   
  280.             }   
  281.         }           
  282.         // 与上面三种的regexp都不相配   
  283.         if (!m) break;   
  284.   
  285.         //处理 ：not(.class)的形式，返回集合中不包含.class的其它的元素   
  286.         if (m[1] == ":" && m[2] == "not")   
  287.             // 性能上优化 m[3]是.class经常出现   
  288.             r = isSimple.test(m[3])// isSimple = /^.[^:#\[\.]*$/   
  289.                     ? jQuery.filter(m[3], r, true).r: jQuery(r).not(m[3]);   
  290.                        
  291.         //处理.class的过滤。只要看看m[2]这个class是不是被集合中元素的class包含。   
  292.         else if (m[1] == ".")// 性能上优化考虑   
  293.             r = jQuery.classFilter(r, m[2], not);   
  294.             //处理属性过滤。如[@value='test']形式的属性选择   
  295.         else if (m[1] == "[") {   
  296.             var tmp = [], type = m[3];// 符号，如=   
  297.   
  298.             for (var i = 0, rl = r.length;i < rl; i++) {   
  299.                 //jQuery.props[m[2]]进行tag中属性名和对应的元素的属性名转换，   
  300.                 //因为tag中属性名是元素中简写，z取到 元素的属性值   
  301.                 var a = r[i], z = a[jQuery.props[m[2]] || m[2]];   
  302.                    
  303.                 //直接取元素的属性值，没有取到，说明有的浏览器不支持这种方法   
  304.                 //进一步尝试采用jQuery.attr来进行非标准的兼容取属性值。   
  305.                 //就算是取到了值，但对于属性名为style|href|src|selected，   
  306.                 //它们不能直接取值，要进行特殊的处理，这个在jQuery.attr进行。   
  307.                 //其实这里可以直接采用jQuery.attr(a, m[2])，一步到位。   
  308.                 if (z == null || /style|href|src|selected/.test(m[2]))   
  309.                     z = jQuery.attr(a, m[2]) || '';// 几个特殊的处理   
  310.   
  311.                 //如果属性选择器满足这   
  312. //[foo],[foo=aa][foo!=aa][foo^=aa][foo$=aa][foo~=aa]   
  313.                 //这几种方式之一，这个元素就可能通过。即满足条件。m[5]属性值。   
  314.         if (   (type == "" && !!z//[foo]   
  315.            || type == "=" && z == m[5]//[foo=aa]   
  316.            || type == "!=" && z != m[5]//[foo!=aa]   
  317.            || type == "^=" && z&& !z.indexOf(m[5])//[foo^=aa]   
  318.            || type == "$="  && z.substr(z.length - m[5].length) == m[5]        || (type == "*=" || type == "~=")&& z.indexOf(m[5]) >= 0  
  319.               )   
  320.         ^ not)   
  321.             tmp.push(a);   
  322.             }   
  323.             r = tmp;   
  324.   
  325.         }   
  326.         //处理：nth-child（n+1）。其实这里也改变了结果集，   
  327.         //不过这里是采用的是间接引用的方式，只要知道元素就可以了，   
  328.         //不需要dom树去查找。因为它要解析参数中的表达式   
  329.         else if (m[1] == ":" && m[2] == "nth-child") {// 性能考量   
  330.             var merge = {}, tmp = [],   
  331.         // 分析：nth-child（n+1）中的参数，这里支持   
  332.         //'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'几种形式   
  333.         //test[1]="-或空"，test[2]="n前面的数或空"，test[3]="n后面的数或空"   
  334.         //这样把参数分成三个部分：1是负号的处理，2是xn中的x处理，3是n-x中-x的处理   
  335.             //3中的是带有符号的。也就是+或-。   
  336.             test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(m[3] == "even" && "2n"  
  337.                     || m[3] == "odd" && "2n+1" || !/\D/.test(m[3]) && "0n+"  
  338.                     + m[3] || m[3]),   
  339.   
  340.             // 计算(first)n+(last)   
  341.             first = (test[1] + (test[2] || 1)) - 0, last = test[3] - 0;   
  342.                
  343.             //找到符合(first)n+(last)表达式的所有子元素   
  344.         for (var i = 0, rl = r.length;i < rl; i++) {   
  345.             var node = r[i], parentNode = node.parentNode,    
  346.         id = jQuery.data(parentNode);//为该元素parentNode分配了一个全局的id   
  347.   
  348.             if (!merge[id]) {// 为元素的每个子节点标上顺序号，作了不重复标识   
  349.                     var c = 1;   
  350.                 for (var n = parentNode.firstChild;n; n = n.nextSibling)   
  351.                         if (n.nodeType == 1)n.nodeIndex = c++;   
  352.                     merge[id] = true;   
  353.                 }   
  354.   
  355.                 var add = false;//初始化add的标记   
  356.                    
  357.                 //常数的形式，如1，2等等，当然还要判断元素的序号和这个数是否相等。   
  358.                 if (first == 0) {// 0不能作除数   
  359.                     if (node.nodeIndex == last)   
  360.                         add = true;   
  361.                 }   
  362.                 // 处理3n+2这种形式同时表达式要大于0   
  363.                 //当前的子节点的序号要满足两个条件：   
  364.                 //1、其序号进行first求余的结果=last.   
  365.                 //2、其序号要大于last。对于-n的形式，要大于-last.   
  366.                 else if ((node.nodeIndex - last) % first == 0  
  367.                         && (node.nodeIndex - last) / first >= 0)   
  368.                     add = true;   
  369.   
  370.                 if (add ^ not)  tmp.push(node);   
  371.             }   
  372.   
  373.             r = tmp;   
  374.   
  375.         }    
  376.         else {// 根据m[1]m[2]在Query.expr找到对应的处理函数   
  377.             var fn = jQuery.expr[m[1]];   
  378.             //支持一个符号（如：last）后的方法名与函数的对应   
  379.             if (typeof fn == "object")   
  380.                 fn = fn[m[2]];   
  381.                 
  382.                 //支持更简短的string来代替jQuery.expr中的funciton。   
  383.                 //这里没有用到。   
  384.             if (typeof fn == "string")   
  385.                 fn = eval("false||function(a,i){return " + fn + ";}");   
  386.   
  387.         // 执行处理函数fn过滤。对于r中每个元素，如果fn返回的结果为true，保留下来。   
  388.             r = jQuery.grep(r, function(elem, i) {   
  389.                 return fn(elem, i, m, r);   
  390.             }, not);   
  391.         }   
  392.     }   
  393.     return {   
  394.         r : r,   
  395.         t : t   
  396.     };   
  397. },   
  398. jQuery.filter完成分析属性([])、Pseudo(:)，class (.),id(#),的筛选的功能。从给定的集合中筛选出满足上面四种筛选表达式的集合。针对于find()。这个filter完成不表明整个selector的分析完成了。还会交替地通过查找器来查找或通过该函数来筛选。对于单独使用这个函数，表达式中就不应该含有查找的selector表达式了。筛选是根据[、:、#、.这四个符号来做为筛选器的分隔符的。   
  399. class筛选器是通过classFilter来完成。它还把Pseudo中：not、：nth-child单独从Pseudo类的中单独提起出来处理。对于[的属性筛选器，实现起来也是很简单。除去这些，它还调用jQuery.expr[m[1]];来处理Pseudo类，而jQuery还做了扩展。jQuery.expr中的Pseudo类有以下几个部分：// Position Checks、// Child Checks、// Parent Checks、// Text Check、// Visibility、// Form attributes、// Form elements、// :has()、// :header、// :animated。也就是说在CSS selector中，我们可以采用Pseudo类提供上面这些类别的方法来进行筛选。其代码就是一些判断，不作分析。   
  400. 如果想详细了解这样怎么用吧，推荐由一揪整理编辑jquery的中文文档。,   
  401.   
  402. 对于CSS selector，尽管多次分析domQuery，和jquery Selector。尽管自己也吃透。但是感觉到写出来还是不到位。如果读者之前没有接受这方面。建议仔细分析上面的代码和注释。找一个复杂的例子，自行分析一下，或许可能弄懂selector的设计。  
posted @ 2008-12-03 10:13  瑞尼书苑  阅读(973)  评论(0)  编辑  收藏  举报