解密jQuery内核 Sizzle引擎筛选器 – 位置伪类(一)


本章开始分析过滤器,根据API的顺序来

主要涉及的知识点

jQuery的组成

pushStack方法的作用

sizzle伪类选择器

 


首页我们知道jQuery对象是一个数组对象

内部结构

解密jQuery内核 Sizzle引擎筛选器 - 位置伪类(一)

jQuery的选择最终还是依靠的DOM提供的接口,jQuery只是最了最佳的方式最快的匹配到合适的位置

构建一个基础的jQuery对象有:

元素合集

元素数量

上下文

通过pushStack()方法构建的prevObject的引用储存,这个在DOM操作的时候特别有用

选择器

具体文章前面有分析,pushStack有什么用处sizzler如何最佳匹配,这里就不详说了,接下来看具体的操作

 


.eq( index )

如果一个jQuery对象表示一个DOM元素的集合,.eq()方法从集合的一个元素中构造新的jQuery对象。所提供的索引标识这个集合中的元素的位置。

根据jQuery的结构,这个很好处理了,返回选择器中的元素,数组索引从0开始的

eq: function( i ) {     var len = this.length,         j = +i + ( i < 0 ? len : 0 );     return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] ); },

这里有个细节,我们取DOM元素是索引,取出来的只是一个节点了,那么还要实现链式操作,我们都知道返回this就能链式,

但是jQuery的每一次操作都是可以回溯的,包括节点的遍历查找,所以这时候返回的当前的this是不行的,这样就需要构建一个新的上下文对象

li.eq(2).css('background-color', 'red');

所以取出来的DOM节点还要通过pushStack方法给包装一次

 

.first()

first: function() {             return this.eq( 0 );         },

 

.last()

last: function() {     return this.eq( -1 ); },

 

可见first,last方法都是一路货,通过eq取索引罢了

 


.slice()

如果提供的jQuery代表了一组DOM元素,.slice()方法从匹配元素的子集中构造一个新的jQuery对象。

所提供的start索引标识的设置一个集合中的元素的位置;如果end被省略,这个元素之后的所有元素将包含在结果中

slice: function() {     return this.pushStack( core_slice.apply( this, arguments ) ); },

其实就是

[].slice.apply(this,arguments )

这里的this是jq对象,根据参数转成数组子集

 


.map( callback(index, domElement) )

描述: 通过一个函数匹配当前集合中的每个元素,产生一个包含新的jQuery对象。

map有点类似each的赶脚,本质上还是有区别的

首先:

在设计上each是不可改变的迭代器,each方法就相当于js中的for循环,返回 ‘false’ 将停止循环 (就像在普通的循环中使用 ‘break’)

map的方法可以作为一个迭代器,但实际是为了操纵提供的数组并返回一个新数组。

map将一组元素转换成其他数组(不论是否是元素数组),你可以用这个函数来通过新规则(如过滤掉数字)来建立一个新列表,

不论是值、属性还是CSS样式,或者其他特别形式。这都可以用’$.map()’来方便的建立。

可见map除了迭代的功能还要返回一新的对象,所以潜在的有内存消耗

map: function( callback ) {     return this.pushStack( jQuery.map(this, function( elem, i ) {         return callback.call( elem, i, elem );     })); },

jQuery.map: function( elems, callback, arg ) {             var value,                 i = 0,                 length = elems.length,                 isArray = isArraylike( elems ),                 ret = [];              // Go through the array, translating each of the items to their             if ( isArray ) {                 for ( ; i < length; i++ ) {                     value = callback( elems[ i ], i, arg );                      if ( value != null ) {                         ret[ ret.length ] = value;                     }                 }                  // Go through every key on the object,             } else {                 for ( i in elems ) {                     value = callback( elems[ i ], i, arg );                      if ( value != null ) {                         ret[ ret.length ] = value;                     }                 }             }              // Flatten any nested arrays             return core_concat.apply( [], ret );         },

可见除了执行回调,还要收集返回值

value = callback( elems[ i ], i, arg );  if ( value != null ) {     ret[ ret.length ] = value; }

通过jQuery.map会返回一个新的迭代对象,然后又让pushStack方法包装一个新的堆上的元素集合(jQuery对象)

 


.filter()

选择器是个比较复杂的东东了,这里又要涉及到sizzle的处理了,顺便一起回顾以往的知识点,加以巩固

讲过滤器,就里不得不提一下.find(),虽然2者都是一个效果,但是处理有本质的区别

filterfind

jQuery官方的API这样说明filterfind函数:

filter(selector):        Description: Reduce the set of matched elements to those that match the selector or pass the function’s test.    find(selector):       Description: Get the descendants of each element in the current set of matched elements, filtered by a selector.

find()会在当前指定元素中查找符合条件的子元素,是对它的子集操作,

filter()则是在当前指定的元素集合中查找符合条件的元素,是对自身集合元素进行筛选。

显而易见find()是对它的子集操作,filter()对自身集合元素筛选

find以后再说,先看看filter的实现

 


filter实例

官方给出的直接搬过来

<ul>     <li>list item 1</li>     <li>list item 2</li>     <li>list item 3</li> </ul>

li.filter(':even').css('background-color', 'red');

解密jQuery内核 Sizzle引擎筛选器 - 位置伪类(一)

 


filter源码

第一步

可见winnow一定是返回一个数据对象,在通过pushStack包装

filter: function( selector ) {     return this.pushStack( winnow(this, selector || [], false) ); },

第二步

jQuery.extend({     filter: function( expr, elems, not ) {         var elem = elems[ 0 ];          if ( not ) {             expr = ":not(" + expr + ")";         }          return elems.length === 1 && elem.nodeType === 1 ?             jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] :             jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {                 return elem.nodeType === 1;             }));     },

filter是针对元素节点本身操作的,所以还要顾虑一下保证合集中都是elem.nodeType === 1的节点类型才行

第三步

方法最终还是靠sizzle去解析,传递一个符合解析的实参

解密jQuery内核 Sizzle引擎筛选器 - 位置伪类(一)

传递了选择器与种子合集了,这里具体可以参考之前的sizzle系列文章,走的流程依然一样

通过词法分析器,解析出词法关系

解密jQuery内核 Sizzle引擎筛选器 - 位置伪类(一)

Token:{      value:'匹配到的字符串',     type:'对应的Token类型',     matches:'正则匹配到的一个结构' }

几种Token : TAG, ID, CLASS, ATTR, CHILD, PSEUDO, NAME,但是这里的type对应是一种伪类PSEUDO,这是在之前sizzle里面没有提到的

 


sizzle伪类

其实之前的文章分析了tokenize方法,把选择语句分解成分词

当然看这里需要结合之前的sizzle系列的篇幅了,比较复杂

Sizzle巧妙的就是它没有直接将拿到的“分词”结果与Expr中的方法逐个匹配逐个执行,而是先根据规则组合出一个大的匹配方法,最后一步执行

编译函数机制中最核心的一段

Sizzle.compile:

i = group.length; while ( i-- ) {     cached = matcherFromTokens( group[i] );     if ( cached[ expando ] ) {         setMatchers.push( cached );     } else {         elementMatchers.push( cached );     } } // Cache the compiled function cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );

1 :matcherFromTokens方法,通过tokens生成匹配程序,它充当了selector“分词”与Expr中定义的匹配方法的串联与纽带的作用,可以说选择符的各种排列组合都是能适应的了

2: matcherFromGroupMatchers方法,通过返回curry的superMatcher方法执行

 


伪类如何生成最终的匹配器

matcherFromTokens源码核心部分

for ( ; i < len; i++ ) {     if ( (matcher = Expr.relative[ tokens[i].type ]) ) {         matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];     } else {         matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );

可见根据分词器类型type的不同,会适配2组不同的处理方案

第一种是位置词素,之前就讲过,主要看下面一种

用Expr.filter的工厂方法来生成匹配器

每条选择器规则最小的几个单元可以划分为:ATTR | CHILD | CLASS | ID | PSEUDO | TAG

解密jQuery内核 Sizzle引擎筛选器 - 位置伪类(一)

 


位置伪元素

解密jQuery内核 Sizzle引擎筛选器 - 位置伪类(一)

每个子规则都有对应的匹配器,同样道理,位置伪类也有特殊的匹配器,它是由setMatcher工厂生成。

为了区分其他规则跟位置伪类,需要对位置伪类的过滤器匹配器等打个标记。

Sizzle源码里边用到的打标记方法

function markFunction( fn ) {   fn[ expando ] = true;   return fn; }

 

位置伪元素共同的特点被createPositionalPseudo给curry一次了

function createPositionalPseudo(fn) {     return markFunction(function(argument) {         argument = +argument;         return markFunction(function(seed, matches) {             var j,                 matchIndexes = fn([], seed.length, argument),                 i = matchIndexes.length;              // Match elements found at the specified indexes             while (i--) {                 if (seed[(j = matchIndexes[i])]) {                     seed[j] = !(matches[j] = seed[j]);                 }             }         });     }); }

curry化 :它是一种通过把多个参数填充到函数体中,实现将函数转换成一个新的经过简化的(使之接受的参数更少)函数技术

当然也会形成闭包了,保存私有值在作用

所以这里很好理解,返回的函数其实最终是

function(argument) {         argument = +argument;         return markFunction(function(seed, matches) {             var j,                 matchIndexes = fn([], seed.length, argument),                 i = matchIndexes.length;              // Match elements found at the specified indexes             while (i--) {                 if (seed[(j = matchIndexes[i])]) {                     seed[j] = !(matches[j] = seed[j]);                 }             }         });     });

所以总结,针对(位置型的)伪筛选:first/:last/:eq/:even/:odd/:It/:gt,都是做了单独的处理,

然后过滤器还有别的比如:not,:has,:contains 等等,其实基础的流程处理都差不多,只是针对不通的情况分别hack

在初始化的时候就:

1 返回新的curry函数

2 打上标记markFunction

 


回到主线方法:

Expr.filter.PSEUDO

"PSEUDO": function( pseudo, argument ) {     // pseudo-class names are case-insensitive     // http://www.w3.org/TR/selectors/#pseudo-classes     // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters     // Remember that setFilters inherits from pseudos     var args,         fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||             Sizzle.error( "unsupported pseudo: " + pseudo );      // The user may use createPseudo to indicate that     // arguments are needed to create the filter function     // just as Sizzle does     if ( fn[ expando ] ) {         return fn( argument );     }

The user may use createPseudo to indicate that

其实显而易见了,fn执行的正是上面

"even": createPositionalPseudo(function( matchIndexes, length ) {     var i = 0;     for ( ; i < length; i += 2 ) {         matchIndexes.push( i );     }     return matchIndexes; }),

执行继续嵌套形成的curry 函数了,在返回一个curry方法,给新方法继续打上一个标记

function( seed, matches ) {     var j,         matchIndexes = fn( [], seed.length, argument ),         i = matchIndexes.length;      // Match elements found at the specified indexes     while ( i-- ) {         if ( seed[ (j = matchIndexes[i]) ] ) {             seed[j] = !(matches[j] = seed[j]);         }     } }

所以最终的匹配器方法贼恶心的,嵌套了4,5层作用域

matcher :

解密jQuery内核 Sizzle引擎筛选器 - 位置伪类(一)

为什么要写这么复杂?因为可以合并不同的参数传递

其实sizzle就是核心处理机制是不变的,只是针对不同的分支做了不同的处理方式,当然写东西整合在一起就显得尤为的复杂了

下一章在深入位置伪类特有的 setMatcher 匹配器工厂


发表评论

电子邮件地址不会被公开。 必填项已用*标注

您可以使用这些HTML标签和属性: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>