Sizzle.find = function( expr, context) {}

Sizzle.find = function( expr, context, isXML ) {
    for ( i = 0, len = Expr.order.length; i < len; i++ ) {
        var type = Expr.order[i];
        if((match = Expr.leftMatch[ type ].exec( expr ))){             //    对应第一步
            if((set = Expr.find[ type ]( match, context ))!=null){   //对应第二步（1）
                expr = expr.replace( Expr.match[ 'ID' ], "" );       //对应第三步
                break;
            }
        }
    }
    if(!set){//对应第二步（2）
        set = context.getElementsByTagName( "*" );
    }
    return {expr : expr,set  : set}
}

var set;
var expr = 'input[class*="default"]';

var match = Expr.leftMatch[ 'ID' ].exec( expr )
var left = match[1];
match.splice( 1, 1 );

set = Expr.find[ 'ID' ]( match, document);
if ( set != null ) {
    expr = expr.replace( Expr.match[ 'ID' ], "" );
}
if ( !set ) {
    set = typeof document.getElementsByTagName !== "undefined" ?document.getElementsByTagName( "*" ) :[];
}
Expr.find['ID'] = function( match, context ) {
    if ( typeof context.getElementById !== "undefined") {
        var m = context.getElementById(match[1]);
        return m && m.parentNode ? [m] : [];
    }
}
console.log({ set: set, expr: expr });

Sizzle.find = function( expr, context, isXML ) {
    var set, i, len, match, type, left;

    if ( !expr ) {  //如果没有选择表达式，直接返回空集合
        return [];
    }

    for ( i = 0, len = Expr.order.length; i < len; i++ ) {//用来判断应该选用哪个查找器，对应的顺序是[ "ID", "NAME", "TAG" ];
        type = Expr.order[i];

        if ( (match = Expr.leftMatch[ type ].exec( expr )) ) { //碰到符合条件的匹配
            left = match[1];
            match.splice( 1, 1 ); //因为leftMatch在match的头部添加了一个新的分组，所以现在提取第一个分组到left里面，然后删除这个分组

            if ( left.substr( left.length - 1 ) !== "\\" ) { //参见讨论部分
                match[1] = (match[1] || "").replace( rBackslash, "" ); //检测，替换回车而已
                set = Expr.find[ type ]( match, context, isXML ); //转到相应的查找器执行查找程序

                if ( set != null ) { //找到相应的结果，修剪expr
                    expr = expr.replace( Expr.match[ type ], "" );
                    break;
                }
            }
        }
    }

    if ( !set ) {    //[ "ID", "NAME", "TAG" ]中没有匹配的类型时候，直接返回context范围内的所有标签。
        set = typeof context.getElementsByTagName !== "undefined" ? context.getElementsByTagName( "*" ) :[];
    }

    return { set: set, expr: expr };
};

Expr.order = [ "ID", "NAME", "TAG" ];
Expr.find  = {
    ID: function( match, context, isXML ) {
        if ( typeof context.getElementById !== "undefined" && !isXML ) {
            var m = context.getElementById(match[1]);
            return m && m.parentNode ? [m] : []; //这里注意优先级的问题。&&的优先级高于?:的优先级
        }
    },

    NAME: function( match, context ) {
        if ( typeof context.getElementsByName !== "undefined" ) {
            var ret = [],
                results = context.getElementsByName( match[1] );

            for ( var i = 0, l = results.length; i < l; i++ ) {
                if ( results[i].getAttribute("name") === match[1] ) {
                    ret.push( results[i] );
                }
            }
            return ret.length === 0 ? null : ret;
        }
    },

    TAG: function( match, context ) {
        if ( typeof context.getElementsByTagName !== "undefined" ) {
            return context.getElementsByTagName( match[1] );
        }
    }
};

(function(){
    // 先创建一个测试环境<div><a name="script20120215"></a></div>
    var form = document.createElement("div"),
        id = "script" + (new Date()).getTime(),
        root = document.documentElement;

    form.innerHTML = "<a name='" + id + "'/>";
    root.insertBefore( form, root.firstChild );

    //检测getElementById的返回值，现获取了相应的节点之后，添加一步检测id属性，如果吻合就保存，不吻合就丢弃
    if ( document.getElementById( id ) ) {
        Expr.find.ID = function( match, context, isXML ) {
            if ( typeof context.getElementById !== "undefined" && !isXML ) {
                var m = context.getElementById(match[1]);

                return m ?
                    m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
                        [m] :
                        undefined :
                    [];
            }
        };
        Expr.filter.ID = function( elem, match ) {
            var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");

            return elem.nodeType === 1 && node && node.nodeValue === match;
        };
    }

    root.removeChild( form );

    // 对于IE，需要释放刚才添加的DIV过程中各变量的缓存，便于垃圾回收
    root = form = null;
})();

var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g;

Expr = {
    match:{
        //ID:....
    }
}

var fescape = function(all, num){
    return "\\" + (num - 0 + 1);
};

for ( var type in Expr.match ) {
    Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
    Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
}

var Sizzle = function( selector, context, results, seed ){}

Sizzle('div',#test,[#a,#b],[#c,#d,#e])

    var Sizzle = function( selector, context, results, seed ){
    var soFar = selector,
        extra    ,//extra用来保存并联选择的其他部分，一次只处理一个表达式
        parts = [],
        m;
    do {
        chunker.exec( "" );     //这一步主要是将chunker的lastIndex重置，当然直接设置chunker.lastIndex效果也一样
        m = chunker.exec( soFar );
        if ( m ) {
            soFar = m[3];
            parts.push( m[1] );
            if ( m[2] ) {       //如果存在并联选择器，就中断，保存其他的选择器部分。
                extra = m[3];
                break;
            }
        }
    } while ( m );
}

if ( parts.length > 1 && origPOS.exec( selector ) ) {
    //自左向右，判断标准就是存在关系选择符同时有位置选择符，因为如果只是类似div#test的选择表达式，就不存在顺序的问题。
}else{
    //其他，自右向左
}

ret = seed ?{ expr: parts.pop(), set: makeArray(seed) } :Sizzle.find( parts.pop(), context);//Sizzle.find负责查找
set = ret.expr ? Sizzle.filter( ret.expr, ret.set ) : ret.set;//Sizzle.filter负责过滤

while ( parts.length ) {
        Expr.relative[ cur ]( checkSet, context, contextXML );//context代表上下文，并非源码中的参数
    }

(function(){
    ...
})()

(function(){
    return false;
    ...
})()

if ( document.querySelectorAll ) {
    ...
}

if ( document.querySelectorAll && false) {
    ...
}

window.Sizzle = function(){
    //主要负责分块和主线流程，通过元素之间关系过滤也被放在这个部分
};
Sizzle.find = function(){
    //查找元素
};
Sizzle.filter = function(){
    //过滤元素，主要处理通过元素自身属性过滤
};
Sizzle.selectors = {
    //命名空间，以及定义一些变量和特异方法
};
var Expr = Sizzle.selectors;//别称

getElementById
getElementsByName
getElementsByTagName

expr='[class="test"][rel=1]:first-child'

var B = [];
for( i = 0; (item = A[i]) != null; i++ ){
    A[i] = isMatch(item);
}
for( i = 0;  i < A.length; i++ ){
    if(A[i]){
        B.push(A[i]);
    }
}

var B = [];
for( i = 0; (item = A[i]) != null; i++ ){
    if(isMatch(item)){
        B.push(A[i]);
    }
}

function _$(element){
    if(typeof element == 'string'){
        element = document.getElementById(element);
    }
    return element;
}

//如果传入的是多个id，保留上面一个函数
function $(element){
    if(arguments.length > 1){
        for(var i = 0,elements = [],len = arguments.length; i < len; i++){
            if(typeof element == 'string'){
                element = _$(element);
            }
            elements.push(element);
        }
    }
    return elements;
}

function $(element){
    if(arguments.length > 1){
        for(var i = 0,elements = [],len = arguments.length; i < len; i++){
            elements.push(_$(element));
        }
    }
    return elements;
}

function $(element){
    if(arguments.length > 1){
        for(var i = 0,elements = [],len = arguments.length; i < len; i++){
            elements.push($(element));
        }
        return elements;
    }
    if(typeof element == 'string'){
        element = document.getElementById(element);
    }
    return element;
    //最后一步，这里返回的是扩展了的Element元素，于是return Element.extend(element);
}

(function(proto) {
  function toISOString() {
    return this.getUTCFullYear() + '-' +
      (this.getUTCMonth() + 1).toPaddedString(2) + '-' +
      this.getUTCDate().toPaddedString(2) + 'T' +
      this.getUTCHours().toPaddedString(2) + ':' +
      this.getUTCMinutes().toPaddedString(2) + ':' +
      this.getUTCSeconds().toPaddedString(2) + 'Z';
  }
  function toJSON() {
    return this.toISOString();
  }
  if (!proto.toISOString){
      proto.toISOString = toISOString;
  }
  if (!proto.toJSON){
      proto.toJSON = toJSON;
  }

})(Date.prototype);

// Here we check if the JavaScript engine is using some sort of
// optimization where it does not always call our comparision
// function. If that is the case, discard the hasDuplicate value.
//   Thus far that includes Google Chrome.
[0, 0].sort(function() {
    baseHasDuplicate = false;
    return 0;
});

var a = 0, b = 0;
[0, 0].sort(function() {
    a = 1;
    return 0;
});
[0, 1].sort(function() {
    b = 1;
    return 0;
});

alert(a === b); // true or false ?

function sort(comparefn) {
  var custom_compare = (typeof(comparefn) === 'function');
  function Compare(x,y) {
    if (x === y) return 0;
    if (custom_compare) {
      return comparefn.call(null, x, y);
    }
    ...
}

function Hash(object){
    this._object = object;
}
Hash.prototype = {
    constructor : Hash,
    method_1 : function(){//this._object},
    method_2 : function(){//this._object}
    //...
}
var hash_1 = new Hash({name : 'xesam'});

var Hash = Class.create(Enumerable, (function() {
        function initialize() {
            //this._object
        }
        return {
            initialize : initialize
        }
    })())

{
    key   : key,
    value : value
}

function set(key, value) {
  return this._object[key] = value;
}

function get(key) {
  if (this._object[key] !== Object.prototype[key])
    return this._object[key];
}

function unset(key) {
  var value = this._object[key];
  delete this._object[key];
  return value;
}

hash.set('name','new name')

hash._object.name = 'new name'

function clone(object) {
    return extend({ }, object);
}

function clone() {
  return new Hash(this);
}

function initialize(object) {
    this._object = Object.isHash(object) ? object.toObject() : Object.clone(object);
}

function keys() {
  return this.pluck('key');
}

function values() {
  return this.pluck('value');
}

function merge(object) {
  return this.clone().update(object);//先拷贝了内部变量_object
}

function update(object) {
  return new Hash(object).inject(this, function(result, pair) {
    result.set(pair.key, pair.value);
    return result;
  });
}

function toQueryPair(key, value) {
  if (Object.isUndefined(value)) return key;
  return key + '=' + encodeURIComponent(String.interpret(value));
}

function toArray() {
  return this.map();
}

function size() {
  return this.length;
}

function inspect() {
  return '[' + this.map(Object.inspect).join(', ') + ']';
}

Enumerable.eachSlice = function(number){
    if(number < 1){ //第一步
        return this;
    }
    var array = this.toArray();//第二步
    var index = 0;
    var results = [];
    while(index < array.length){//第三步
        results.push(array.slice(index,index + number));
        index += number;
    }
    return results;
};

  function eachSlice(number, iterator, context) {
    var index = -number, slices = [], array = this.toArray();
    if (number < 1) return array;
    while ((index += number) < array.length)
      slices.push(array.slice(index, index+number));
    return slices.collect(iterator, context);   //collect就是map
  }
````

例子：

```javascript
console.log([1,2,3,4,5].eachSlice(2));//[[1,2],[3,4],[5,6]]

Enumerable.inGroupsOf = function(number, fillWith) {
  fillWith = typeof fillWith == 'undefined' ? null : fillWith;//源码中这里使用的是Object.isUndefined
  return this.eachSlice(number, function(slice) {
    while(slice.length < number){
        slice.push(fillWith);
    }
    return slice;
  });
}

inject(accumulator, iterator[, context]) -> accumulatedValue

console.dir([1,2,3,4].inject(0,function(sum,n){
    return sum + n;
}));//10

var sum = 0;
[1,2,3,4].each(function(value){
    sum += value;
})
console.dir(sum);//10

function fn(accumulator,interator,context){
    [1,2,3,4].each(function(value,index){
        accumulator = interator.call(context,accumulator,value,index);
    })
    return accumulator;
}
console.dir(fn(0,function(accumulator,value,index){
    accumulator += value;
    return accumulator;
}));//10

accumulator = interator.call(context,accumulator,value,index);

var array_1 = [1,2,3,4].map(function(value){
    return value.toString();
});
console.log('array_1:',array_1);//["1", "2", "3", "4"]
var array_2 = [1,2,3,4].invoke('toString');
console.log('array_2:',array_2);//["1", "2", "3", "4"]

function invoke(method) {
  //var args = $A(arguments).slice(1); //源码实现
  var args  = Array.prototype.slice.call(arguments,1);
  return this.map(function(value) {
    return value[method].apply(value, args);
  });
}

function pluck(property) {
  var results = [];
  this.each(function(value) {
    results.push(value[property]);
  });
  return results;
}

['hello', 'world', 'my', 'is', 'xesam'].pluck('length')// [5, 5, 2, 3, 5]

zip(Sequence...[, iterator = Prototype.K]) -> Array

function zip(){
    var array_1 = [1,2,3];
    var array_2 = ['a','b','c'];
    var array_3 = ['x','y','z'];
    var result = [array_1].concat([array_2,array_3]);//[[1,2,3],['a','b','c'],['x','y','z']]
    return array_1.map(function(value,index){
        return result.pluck(index);
    })
}
console.log(zip());//[[1,'a','x'],[2,'b','y'],[3,'c','z']]

function zip(){
    var result = [this].concat(Array.prototype.slice.call(arguments,1));
    return this.map(function(value,index){
        return result.pluck(index);
    })
}
console.log([1,2,3].zip(['a','b','c'],['x','y','z']));////[[1,'a','x'],[2,'b','y'],[3,'c','z']]

function zip(){
    var args = Array.prototype.slice.call(arguments,0);
    var interator = function(x){ return x;} //Prototype.K
    if(args[args.length - 1].constructor == Function){
        interator = args.pop();
    }
    var result = [this].concat(Array.prototype.slice.call(arguments,1));
    return this.map(function(value,index){
        return interator.call(result.pluck(index));
    })
}

var array_1 = [1,2,3];
var array_2 = ['a','b','c'];
(function(){
    for(var i = 0, len = array_1.length; i < len; i++){
        for(var j = 0, len_j = array_1.length; i < len_j; j++){
            if('c' === array_2[j]){
                break;
            }
            console.log(array_2[j]);
        }
    }
})();//a,b,a,b,a,b
(function(){
    for(var i = 0, len = array_1.length; i < len; i++){
        try{
            for(var j = 0, len_j = array_1.length; i < len_j; j++){
                if('c' === array_2[j]){
                    throw new Error();
                }
                console.log(array_2[j]);
            }
        }catch(e){
            console.log('退出一层循环');
        }
    }
})();//a,b,'退出一层循环',a,b,'退出一层循环',a,b,'退出一层循环'
(function(){
    try{
        for(var i = 0, len = array_1.length; i < len; i++){
            for(var j = 0, len_j = array_1.length; i < len_j; j++){
                if('c' === array_2[j]){
                    throw new Error();
                }
                console.log(array_2[j]);
            }
        }
    }catch(e){
        console.log('退出一层循环');
    }
})();//a,b,'退出一层循环'

Enumerable.each = function(iterator, context) {
    var index = 0;
    try{
        this._each(function(value){
            iterator.call(context, value, index++);
        });
    }catch(e){
        if(e != $break){
            throw e;
        }
    }
    return this;
};

function all(iterator, context) {
  var result = true;
  this.each(function(value, index) {
    result = result && !!iterator.call(context, value, index);
  });
  return result;
}

Prototype.K = function(){};
Enumerable.all = function(iterator, context) {
  iterator = iterator || Prototype.K;
  var result = true;
  this.each(function(value, index) {
    result = result && !!iterator.call(context, value, index);
    if (!result) throw $break;
  });
  return result;
}

function collect(iterator, context) {
  iterator = iterator || Prototype.K;
  var results = [];
  this.each(function(value, index) {
    results.push(iterator.call(context, value, index));
  });
  return results;
}

function any(iterator, context) {
  iterator = iterator || Prototype.K;
  var result = false;
  this.each(function(value, index) {
    if (result = !!iterator.call(context, value, index))
      throw $break;
  });
  return result;
}

function include(object) {
  if (Object.isFunction(this.indexOf))//这个判定函数应该很熟悉了
    if (this.indexOf(object) != -1) return true;//有indexOf就直接调用

  var found = false;
  this.each(function(value) {//这里的效率问题
    if (value == object) {
      found = true;
      throw $break;
    }
  });
  return found;
}

console.dir([{value : 3},{value : 1},{value : 2}].max(function(item){
    return item.value;
}));//3

function max() {
  var result;
  this.each(function(value) {
    if (result == null || value >= result) //result==null是第一次比较
      result = value;
  });
  return result;
}

function max(iterator, context) {
  iterator = iterator || Prototype.K;
  var result;
  this.each(function(value, index) {
    value = iterator.call(context, value, index);
    if (result == null || value >= result)
      result = value;
  });
  return result;
}

Enumerable.grep = function(filter) {
    if(typeof filter == 'string'){
        filter = new RegExp(filter);
    }
    var results = [];
    this.each(function(value,index){
        if(value.match(filter)){
            results.push(value);
        }
    })
    return results;
};

if(value.match(filter))

if (filter.match(value))

RegExp.prototype.match = RegExp.prototype.test;

function grep(filter, iterator, context) {
  iterator = iterator || Prototype.K;
  var results = [];

  if (Object.isString(filter))
    filter = new RegExp(RegExp.escape(filter));

  this.each(function(value, index) {
    if (filter.match(value))//原生filter是没有match方法的。
      results.push(iterator.call(context, value, index));
  });
  return results;
}

var each = Array.prototype.forEach || function(iterator,context){
    for(var i = 0,len = this.length ; i < len ; i++){
       iterator.call(context,this[i],this);
    }
};

Array.prototype.each = Array.prototype.forEach || function(iterator,context){
    for(var i = 0,len = this.length ; i < len ; i++){
        iterator.call(context,this[i],i,this);
    }
};
Array.prototype.print = function(){
    this.each(function(item){
        console.log(item);
    });
}
console.log([1,2,3,4].print());//1,2,3,4

Array.prototype.each = function(iterator,context){
    this._each(iterator,context)
}
Array.prototype._each = function(iterator,context){
    for(var i = 0,len = this.length ; i < len ; i++){
        iterator.call(context,this[i],i,this);
    }
};

Array.prototype.each = function(iterator,context){
    var index = 0;
    this._each(function(value){
        iterator.call(context,value,index++);
    })
}

var Enumerable = {};
Enumerable.each = function(iterator, context) {
    var index = 0;
    this._each(function(value){
        iterator.call(context, value, index++);
    });
    return this;
};
Enumerable.print = function(){
    this.each(function(item){
        console.log(item);
    })
};
Array.prototype._each = function(iterator,context){
    for(var i = 0,len = this.length ; i < len ; i++){
        iterator.call(context,this[i],i,this);
    }
};
//下面的实现源码中是用的extend方法
for(var key in Enumerable){
    Array.prototype[key] = Enumerable[key];
};
[1,2,3,4].print();//1,2,3,4