Ruby's Louvre

每天学习一点点算法

导航

统计

Sizzle是怎样工作的

作为闻名遐迩的选择器,Sizzle并不是人们所说的从右到左选择那么简单的。本文将揭开其神秘的内幕,让大家看看其令人惊叹的优化。

在此之前,大家必需有一些概念,否则无法勾勒其轮廓。这些概念我在做类似的事,一点点总结出来的。总的来说,有如下几个:种子选择器,候选集,映射集,迭代器,过滤器,切割器,查询次数……

由于CSS选择器的种类是如此繁多,加上jQuery的自定义伪类就更多,因此它们组成的表达式一定要加以拆分,才能工作。我们就拿一个简单的CSS表达式着手吧。

div div.aaa就是我们的小白鼠,大抵它可以拆分为四个部分,标签选择器,后代选择器,标签选择器与类选择器。但Sizzle一开始并没有这样做,请见下面Sizzle的切割器部分

     parts = [],
        soFar = selector;
       //chunker 的正则会用不在双引号单引号之内的后代亲子相邻兄长并联(' ','>','+','~',',')作为切割符,
       //从左到右切割表达式,并在第一个并联选择器之时结束。
       //比如"li[name=ee]>span.aaa, div span" 会变成parts = ["li[name=ee]",">","span.aaa"], extra = "div span" 
        do {
            chunker.exec( "" );
            m = chunker.exec( soFar );
            if ( m ) {
                soFar = m[3];
                parts.push( m[1] );
                if ( m[2] ) {//如果是并联选择器,中断
                     extra = m[3];
                    break;
                }
            }
        } while ( m );

单从这点,这种切割方法就注定其不可能是单纯的从右到左选择,它可能是从中间到左进行。

接下来有许多分支,分别是对ID与位置伪类进行优化的,我们暂时跳过它们。看其另外几个重要概念,种子选择器与候选集,候选集你也可以称之为种子集,因为sizzle中就有这么一个单词seed。为了获取候选集,我们需要调一个种子选择器Sizzle.find。重要的参数是并联选择器前面的那个子选择器模块,若根据上面的例子,它就是那个"span.aaa"。"span.aaa"的组成部分在标准浏览器下都可以用原生API来获取。除去后来的那两个querySelector,querySelectorAll,HTML文档一共有这么四个API:

  • getElementById,上下文只能是HTML文档。
  • getElementsByName,上下文只能是HTML文档。
  • getElementsByTagName,上下文可以是HTML文档,XML文档及元素节点。
  • getElementsByClassName,上下文可以是HTML文档及元素节点。IE8还没有支持。

那我们是先取span还是.aaa,就要视原生API获取元素节点的数量而定,更直白地说,数量越少,后面过滤起来越轻松,John Resig不是傻瓜,肯定在这里做点优化。这个原生选择器的调用顺序被放到一个叫Sizzle.selectors.order的数组中,对于旧一点的浏览器,其顺序为ID,NAME,TAG,对于支持getElementsByClassName的浏览器,其顺序为ID,CLASS,NAME,TAG。种子选择器Sizzle.find会调用相应的正则去切割它,并进行进一步的处理放进原生API中去获取节点。当然不如意的情况还有许多,如碰到选择器群组是"[href='aaa']:target"的情况,我们唯有把文档的所有节点充当获选集了。

Sizzle.find = function( expr, context, isXML ) {
	var set;
	if ( !expr ) {
		return [];
	}
	for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
		var match,type = Expr.order[i];
		if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
			var left = match[1];
			match.splice( 1, 1 );
			if ( left.substr( left.length - 1 ) !== "\\" ) {
				match[1] = (match[1] || "").replace(/\\/g, "");
				set = Expr.find[ type ]( match, context, isXML );

				if ( set != null ) {
					expr = expr.replace( Expr.match[ type ], "" );
					break;
				}
			}
		}
	}
	if ( !set ) {
		set = context.getElementsByTagName( "*" );
	}
	return { set: set, expr: expr };
};

经过种子选择器后,原选择器群组可能还留下一点小尾巴,如上面的例子,在FF会留下"span"。这时轮到五大迭代器出场了。在我的体系中,我分别把它们取名为border,borders,father,fathers,current,在Sizzle里具体对应Sizzle.selectors.relative["+"],Sizzle.selectors.relative["~"],Sizzle.selectors.relative[">"],Sizzle.selectors.relative[""]及Sizzle.filter。Sizzle.filter在father与fathers还充当过滤器。我们还是先看current迭代器吧。current迭代器的意思应该很易懂,只对于当前集合的元素进行或过滤或置换处理。

Sizzle.filter = function( expr, set, inplace, not ) {
//set必须是数组,inplace为true时用于其他迭代器,not只用于最简单的反选选择器
	var match, anyFound,
		old = expr,
		result = [],
		curLoop = set,
		isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
	while ( expr && set.length ) {
		for ( var type in Expr.filter ) {
//这里是除关系选择器与并联选择器的其他选择器类型,其中还把位置伪类从伪类中独立出来
//CLASS,ID,TAG,CHILD,ATTR,PSEUDO,POS
			if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {//取得过滤参数
				var found, item,
					filter = Expr.filter[ type ],//取得过滤函数
					left = match[1];
				anyFound = false;
				match.splice(1,1);
				if ( left.substr( left.length - 1 ) === "\\" ) {
					continue;
				}
				if ( curLoop === result ) {
					result = [];//这里用于缩小候选集时
				}
				if ( Expr.preFilter[ type ] ) {
               //Expr.preFilter里面的函数都用于进一步加工过滤参数,对于类选择器,出于优化需要,直接进行过滤(它返回false)
					match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
					if ( !match ) {//处理CLASS
						anyFound = found = true;
					} else if ( match === true ) {//处理POS
						continue;
					}
				}
				if ( match ) {//处理CLASS、POS之外的类型
					for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
						if ( item ) {//如果item不为false
							found = filter( item, match, i, curLoop );//此值为布尔
							var pass = not ^ !!found;//此值为布尔

							if ( inplace && found != null ) {
								if ( pass ) {
									anyFound = true;

								} else {
									curLoop[i] = false;
								}

							} else if ( pass ) {
								result.push( item );//这里用于构建一下循环的数组
								anyFound = true;
							}
						}
					}
				}
				if ( found !== undefined ) {
					if ( !inplace ) {
						curLoop = result;
					}
					expr = expr.replace( Expr.match[ type ], "" );//削减CSS表达式直到变为空字符串
					if ( !anyFound ) {
						return [];
					}

					break;
				}
			}
		}
		// Improper expression
		if ( expr === old ) {//如果到最后正则也不能动CSS表达式一条毫毛,说明此CSS表达式有问题
			if ( anyFound == null ) {
				Sizzle.error( expr );

			} else {
				break;
			}
		}
		old = expr;
	}
	return curLoop;//这里用于其他迭代器
};

嘛,简单来说,此迭代器有两种形态。一是当inplace为undefined时,它会不断缩减集合的数量。如[ [object HTMLDivElement], [object HTMLDivElement], [object HTMLDivElement], [object HTMLDivElement] ]缩减成[ [object HTMLDivElement] ]一个,被操作的集合为候选集本身。另一种是inplace为true时,它不会缩减集合的数量,但会将不符合的节点置换为false,若在fathers迭代器中,符合条件的节点还会变成其某一个祖先,borders则变成其某一个previousSiblingElement,border与father相仿,总之会面目全非。这种情况是应用于映射集,映射集与候选集的数量总是相等。在Sizzle,映射集的变量名为checkSet。

好了,总之到下面这一段代码,span选择器已被搞掉了。

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

这时候候选集的数量已少到不能最少,我们需要设置一个映射集:

checkSet = makeArray( set );

现在我们就来处理其他子选择器群集,它们都是以关系选择器间隔开的。

while ( parts.length ) {
  cur = parts.pop();//取得关系选择器
  pop = cur;
  if ( !Expr.relative[ cur ] ) {
	cur = "";//如果不是则默认为后代选择器
  } else {
	pop = parts.pop();//取得后代选择器前面的子选择器群集
  }
  if ( pop == null ) {
	pop = context;
  }
  Expr.relative[ cur ]( checkSet, pop, contextXML );//根据其他四种迭代器改变映射集里面的元素
//得到诸如[ [object HTMLDivElement] ,false, false, [object HTMLSpanElement] ]的集合
}

最后一步就是根据映射集甄选候选集。

  for ( i = 0; checkSet[i] != null; i++ ) {
                    if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
                        results.push( set[i] );
                    }
   }

如果存在并联选择器,那就再调用Sizzle主函数,把得到的两个结果合并去重就是。

嘛,以上就是Sizzle的基本流程了,其他迭代器,过滤器的解读应该没有难度,有空再说。下再重新把大纲罗列一下结文:

  • 将CSS表达式切割到第一个并联选择器为止,得到的数组是按子选择器群集,关系选择器,子选择器群组,关系选择器.....的顺序排列。
  • 将最后一个选择器放进种子选择器(Sizzle.find),得到最佳的候选集。
  • 如果刚才的子选择器群组还残留什么,就放到current迭代器,把候选集的元素个数缩小(减少过滤基数)。
  • 然后根据候选集克隆一个映射集,用于放进其他迭代器的过滤函数中进行筛选,不符合者将置换为false,符合者置换其兄长祖先。
  • 最后根据映射集甄选候选集,如果存在并联选择器,重复刚才的事,两者合并排序去重返回。

posted on 2011-01-24 21:47  司徒正美  阅读(...)  评论(...编辑  收藏