解密jQuery内核 Sizzle引擎筛选器

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

主要涉及的知识点

jQuery的组成

pushStack方法的作用

sizzle伪类选择器

---

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

内部结构

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者都是一个效果，但是处理有本质的区别

filter与find

jQuery官方的API这样说明filter和find函数：

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');

---

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去解析，传递一个符合解析的实参

传递了选择器与种子合集了，这里具体可以参考之前的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

---

位置伪元素

每个子规则都有对应的匹配器，同样道理，位置伪类也有特殊的匹配器，它是由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 ：

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

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

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