【jQuery源码】tokenize方法

 //得到由选择器生成的token对象的数组（下面的groups）
 //Sizzle的Token格式如下 ：{value:'匹配到的字符串', type:'对应的Token类型', matches:'正则匹配到的一个结构'}
 //比如"title,div > :nth-child(even)"解析下面的符号流
     // [ [{value:"title",type:"TAG",matches:["title"]}],
     //   [{value:"div",type:["TAG",matches:["div"]},
     //    {value:">", type: ">"},
     //    {value:":nth-child(even)",type:"CHILD",matches:["nth",
     //     "child","even",2,0,undefined,undefined,undefined]}
     //   ]
     // ]
     //有多少个并联选择器，里面就有多少个数组，数组里面是拥有value与type的对象

 //tokenize两个作用:1.解析选择器；2.将解析结果存入缓存
 tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
     var matched, match, tokens, type,
         soFar, groups, preFilters,
         cached = tokenCache[ selector + " " ];
     //这里的soFar是表示目前还未分析的字符串剩余部分

     //如果tokenCache中已经有selector了，则直接拿出来就好了
     if ( cached ) {
         return parseOnly ? 0 : cached.slice( 0 );
     }

     soFar = selector;
     groups = [];

     //这里的预处理器为了对匹配到的Token适当做一些调整
     preFilters = Expr.preFilter;

     //循环处理字符串
     while ( soFar ) {

         // Comma and first run
         //whitespace = "[\\x20\\t\\r\\n\\f]";
         //rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" );
         //!matched：若是第一次执行循环体，则为true；否则为false。
         //这里matched即作为是否第一次执行循环体的标识，
         if ( !matched || (match = rcomma.exec( soFar )) ) {
             if ( match ) {
                 // Don't consume trailing commas as valid
                 //去掉sofar中第一个的无用","，比如",div,#id"中的第一个","
                 //举个例子，"div.news,span.closed"
                 //在解析过程中，首先由后续代码解析完毕div.news，剩下",span.closed"
                 //在循环体内执行到这里时，将逗号及之前之后连续的空白（match[0]）删除掉，
                 //使soFar变成"span.closed"，继续执行解析过程
                 soFar = soFar.slice( match[0].length ) || soFar;
             }
             //往规则组里边压入一个Token序列，目前Token序列还是空的
             groups.push( (tokens = []) );
         }

         matched = false;

         // Combinators
         //rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*"),
         //rcombinators用来匹配四种关系符，即>+~和空白
         if ( (match = rcombinators.exec( soFar )) ) {
             // 举个例子：
             // 若soFar = " + .div";
             // 执行match = rcombinators.exec(soFar)后，
             // match[0] = " + "，而match[1]="+";
             // 执行完matched = match.shift()后，
             // matched=" + "，而match[0]="+";
             matched = match.shift();
             tokens.push({
                 value: matched,
                 // Cast descendant combinators to space
                 type: match[0].replace( rtrim, " " )
             });
             soFar = soFar.slice( matched.length );
         }

         // Filters
         //下面通过for语句对soFar逐一匹配ID、TAG、CLASS、CHILD、ATTR、PSEUDO类型的选择器
         // 若匹配到了，则先调用该类型选择器对应的预过滤函数，
         // 然后，将结果压入tokens数组，继续本次循环。
         for ( type in Expr.filter ) {
             //  match = matchExpr[type].exec(soFar)：对soFar调用type类型的正则表达式对soFar进行匹配
             // 并将匹配结果赋予match。若未匹配到数据，则match为null。
             // !preFilters[type]：若不存在type类型的预过滤函数，则为true
             // match = preFilters[type](match)：执行预过滤，并将结果返回给match
             if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
                 (match = preFilters[ type ]( match ))) ) {
                 // 将match[0]移除match数组，同时将它赋予matched
                 matched = match.shift();
                 // 将匹配结果压入tokens数组中
                 tokens.push({
                     value: matched,
                     type: type,
                     matches: match
                 });
                 // 将匹配结果之后的字符串赋予soFar，继续解析
                 soFar = soFar.slice( matched.length );
             }
         }

         //matched为false,说明本次循环没有效的选择器（包括关系符和id、class等类型选择器）
         if ( !matched ) {
             break;
         }
     }

     // Return the length of the invalid excess
     // if we're just parsing
     // Otherwise, throw an error or return tokens
     return parseOnly ?
         soFar.length :
         soFar ?
             Sizzle.error( selector ) :
             // Cache the tokens
             tokenCache( selector, groups ).slice( 0 );
 };

画一张直观图便于理解