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

 

画一张直观图便于理解