jQuery源码分析之sizzle选择器详解

前言

sizzle 原本是 jquery 中用来当作 dom 选择器的，后来被 john resig 单独分离出去，成为一个单独的项目，可以直接导入到项目中使用。

点击这里下：。

本来我们使用 jquery 当作选择器，选定一些 #id 或 .class，使用 document.getelementbyid 或 document.getelemensbyclassname 就可以很快锁定 dom 所在的位置，然后返回给 jquery 当作对象。但有时候会碰到一些比较复杂的选择 div div.hot>span 这类肯定用上面的函数是不行的，首先考虑到的是 element.queryselectorall() 函数，但这个函数存在严重的兼容性问题mdn queryselectorall。这个时候 sizzle 就派上用场了。

介绍中已经说明白，没有介绍 find 函数，其本质上就是 sizzle 函数在 jquery 中的表现。

这个函数在 jquery 中两种存在形式，即原型和属性上分别有一个，先来看下 jquery.fn.find:

jquery.fn.find = function (selector) {
 var i, ret, len = this.length,
 self = this;
 // 这段话真不知道是个什么的
 if (typeof selector !== "string") {
 // fn.pushstack 和 jquery.merge 很像，但是返回一个 jquery 对象，且
 // jquery 有个 prevobject 属性指向自己
 return this.pushstack(jquery(selector).filter(function () {
  for (i = 0; i < len; i++) {
  // jquery.contains(a, b) 判断 a 是否是 b 的父代
  if (jquery.contains(self[i], this)) {
   return true;
  }
  }
 }));
 }

 ret = this.pushstack([]);

 for (i = 0; i < len; i++) {
 // 在这里引用到 jquery.find 函数
 jquery.find(selector, self[i], ret);
 }
 // uniquesort 去重函数
 return len > 1 ? jquery.uniquesort(ret) : ret;
}

jquery.fn.find 的用法一般在 $('.test').find("span") ，所以此时的 this 是指向 $(‘.test') 的，懂了这一点，后面的东西自然而然就好理解了。

然后就是 jquery.find 函数，本章的重点讨论部分。

先来看一个正则表达式：

var rquickexpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/;
rquickexpr.exec('#id') //["#id", "id", undefined, undefined]
rquickexpr.exec('div') //["div", undefined, "div", undefined]
rquickexpr.exec('.test') //[".test", undefined, undefined, "test"]
rquickexpr.exec('div p')// null

你可能会疑惑，rquickexpr 的名字已经出现过一次了。实际上 sizzle 是一个闭包，这个 rquickexpr 变量是在 sizzle 闭包内的，不会影响到 jquery 全局。这个正则的作用主要是用来区分 tag、id 和 class，而且从返回的数组也有一定的规律，可以通过这个规律来判断 selector 具体是哪一种。

jquery.find = sizzle;

function sizzle(selector, context, results, seed) {
 var m, i, elem, nid, match, groups, newselector, newcontext = context && context.ownerdocument,

 // nodetype defaults to 9, since context defaults to document
 nodetype = context ? context.nodetype : 9;

 results = results || [];

 // return early from calls with invalid selector or context
 if (typeof selector !== "string" || !selector || nodetype !== 1 && nodetype !== 9 && nodetype !== 11) {

 return results;
 }

 // try to shortcut find operations (as opposed to filters) in html documents
 if (!seed) {

 if ((context ? context.ownerdocument || context : preferreddoc) !== document) {
  // setdocument 函数其实是用来将 context 设置成 document，考虑到浏览器的兼容性
  setdocument(context);
 }
 context = context || document;
 // true
 if (documentishtml) {

  // match 就是那个有规律的数组
  if (nodetype !== 11 && (match = rquickexpr.exec(selector))) {

  // selector 是 id 的情况
  if ((m = match[1])) {

   // document context
   if (nodetype === 9) {
   if ((elem = context.getelementbyid(m))) {

    if (elem.id === m) {
     results.push(elem);
     return results;
    }
   } else {
    return results;
   }

   // 非 document 的情况
   } else {

   if (newcontext && (elem = newcontext.getelementbyid(m)) && contains(context, elem) && elem.id === m) {

    results.push(elem);
    return results;
   }
   }

  // selector 是 tagname 情况
  } else if (match[2]) {
   // 这里的 push：var push = arr.push
   push.apply(results, context.getelementsbytagname(selector));
   return results;

  // selector 是 class 情况
  } else if ((m = match[3]) && support.getelementsbyclassname && context.getelementsbyclassname) {

   push.apply(results, context.getelementsbyclassname(m));
   return results;
  }
  }

  // 如果浏览器支持 queryselectorall
  if (support.qsa && !compilercache[selector + " "] && (!rbuggyqsa || !rbuggyqsa.test(selector))) {

  if (nodetype !== 1) {
   newcontext = context;
   newselector = selector;

   // qsa looks outside element context, which is not what we want
   // support: ie <=8,还是要考虑兼容性
  } else if (context.nodename.tolowercase() !== "object") {

   // capture the context id, setting it first if necessary
   if ((nid = context.getattribute("id"))) {
   nid = nid.replace(rcssescape, fcssescape);
   } else {
   context.setattribute("id", (nid = expando));
   }

   // sizzle 词法分析的部分
   groups = tokenize(selector);
   i = groups.length;
   while (i--) {
   groups[i] = "#" + nid + " " + toselector(groups[i]);
   }
   newselector = groups.join(",");

   // expand context for sibling selectors
   newcontext = rsibling.test(selector) && testcontext(context.parentnode) || context;
  }

  if (newselector) {
   try {
   push.apply(results, newcontext.queryselectorall(newselector));
   return results;
   } catch(qsaerror) {} finally {
   if (nid === expando) {
    context.removeattribute("id");
   }
   }
  }
  }
 }
 }

 // all others，select 函数和 tokenize 函数后文再谈
 return select(selector.replace(rtrim, "$1"), context, results, seed);
}

整个分析过程由于要考虑各种因素，包括效率和浏览器兼容性等，所以看起来非常长，但是逻辑一点都不难：先判断 selector 是否是非 string，然后正则 rquickexpr 对 selector 进行匹配，获得数组依次考虑 id、tagname 和 class 情况，这些都很简单，都是单一的选择，一般用浏览器自带的函数 getelement 即可解决。遇到复杂一点的，比如 div div.show p,先考虑 queryselectorall 函数是否支持，然后考虑浏览器兼容 ie<8。若不支持，即交给 select 函数（下章）。

sizzle 的优势

sizzle 使用的是从右向左的选择方式，这种方式效率更高。

浏览器在处理 html 的时候，先生成一个 dom tree，解析完 css 之后，然后更加 css 和 dom tess 生成一个 render tree。render tree 用于渲染，不是一一对应，如 display:none 的 dom 就不会出现在 render tree 中。

如果从左到右的匹配方式，div div.show p，

1. 找到 div 节点，
2. 从 1 的子节点中找到 div 且 class 为 show 的 dom，找不到则返回上一步
3. 从 2 的子节点中找到 p 元素，找不到则返回上一步
   

如果有一步找不到，向上回溯，直到遍历所有的 div，效率很低。

如果从右到左的方式，

1. 先匹配到所有的 p 节点，
2. 对 1 中的结果注意判断，若其父节点顺序出现 div.show 和 div，则保留，否则丢弃
   

因为子节点可以有若干个，而父节点只有一个，故从右向左的方式效率很高。

衍生的函数

jquery.fn.pushstack

jquery.fn.pushstack是一个类似于 jquery.merge 的函数，它接受一个参数，把该参数（数组）合并到一个 jquery 对象中并返回，源码如下：

jquery.fn.pushstack = function (elems) {

 // build a new jquery matched element set
 var ret = jquery.merge(this.constructor(), elems);

 // add the old object onto the stack (as a reference)
 ret.prevobject = this;

 // return the newly-formed element set
 return ret;
}

jquery.contains

这个函数是对 dom 判断是否是父子关系，源码如下：

jquery.contains = function (context, elem) {
 // 考虑到兼容性，设置 context 的值
 if ((context.ownerdocument || context) !== document) {
 setdocument(context);
 }
 return contains(context, elem);
}

// contains 是内部函数，判断 dom_a 是否是 dom_b 的
var contains = function (a, b) {
 var adown = a.nodetype === 9 ? a.documentelement : a,
 bup = b && b.parentnode;
 return a === bup || !!(bup && bup.nodetype === 1 && (
 adown.contains ? adown.contains(bup) : a.comparedocumentposition && a.comparedocumentposition(bup) & 16));
}

jquery.uniquesort

jquery 的去重函数，但这个去重职能处理 dom 元素数组，不能处理字符串或数字数组，来看看有什么特别的：

jquery.uniquesort = function (results) {
 var elem, duplicates = [],
 j = 0,
 i = 0;

 // hasduplicate 是一个判断是否有相同元素的 flag，全局
 hasduplicate = !support.detectduplicates;
 sortinput = !support.sortstable && results.slice(0);
 results.sort(sortorder);

 if (hasduplicate) {
 while ((elem = results[i++])) {
  if (elem === results[i]) {
   j = duplicates.push(i);
  }
 }
 while (j--) {
  // splice 用于将重复的元素删除
  results.splice(duplicates[j], 1);
 }
 }

 // clear input after sorting to release objects
 // see https://github.com/jquery/sizzle/pull/225
 sortinput = null;

 return results;
}

sortorder 函数如下，需要将两个函数放在一起理解才能更明白哦：

var sortorder = function (a, b) {

 // 表示有相同的元素，设置 flag 为 true
 if (a === b) {
 hasduplicate = true;
 return 0;
 }

 // sort on method existence if only one input has comparedocumentposition
 var compare = !a.comparedocumentposition - !b.comparedocumentposition;
 if (compare) {
 return compare;
 }

 // calculate position if both inputs belong to the same document
 compare = (a.ownerdocument || a) === (b.ownerdocument || b) ? a.comparedocumentposition(b) :

 // otherwise we know they are disconnected
 1;

 // disconnected nodes
 if (compare & 1 || (!support.sortdetached && b.comparedocumentposition(a) === compare)) {

 // choose the first element that is related to our preferred document
 if (a === document || a.ownerdocument === preferreddoc && contains(preferreddoc, a)) {
  return -1;
 }
 if (b === document || b.ownerdocument === preferreddoc && contains(preferreddoc, b)) {
  return 1;
 }

 // maintain original order
 return sortinput ? (indexof(sortinput, a) - indexof(sortinput, b)) : 0;
 }

 return compare & 4 ? -1 : 1;
}

总结

可以说今天先对 sizzle 开个头，任重而道远！下面就会接受 sizzle 中的 tokens 和 select 函数。感兴趣的朋友们可以继续关注，希望本文的内容对大家能有一定的帮助。