jQuery源码解读----part 2

分离构造器

通过new操作符构建一个对象，一般经过四步：

A.创建一个新对象

B.将构造函数的作用域赋给新对象（所以this就指向了这个新对象）

C.执行构造函数中的代码

D.返回这个新对象

最后一点就说明了，我们只要返回一个新对象即可。其实new操作符主要是把原型链跟实例的this关联起来，这才是最关键的一点，所以我们如果需要原型链就必须要new操作符来进行处理。否则this则变成window对象了。

改造jQuery无new的格式，我们可以通过instanceof判断this是否为当前实例：

var $$ = ajQuery = function(selector) {
    if(!(this instanceof ajQuery)){ // 第二次看还是觉得这一句很NB
        return new ajQuery(selector);
    }
    this.selector = selector;
    return this
}

但在jQuery实际上采取的手段是把原型上的一个init方法作为构造器，这样貌似更节省代码空间？

var $$ = ajQuery = function(selector) {
    //把原型上的init作为构造器
    return new ajQuery.fn.init( selector );
}

ajQuery.fn = ajQuery.prototype = {
    name: 'aaron',
    init: function() {
        console.log(this)
    },
    constructor: ajQuery
}

但这样子还缺点东西，init是ajQuery原型上作为构造器的一个方法，那么其this就不是ajQuery了，所以this就完全引用不到ajQuery的原型了，所以这里通过new把init方法与ajQuery给分离成2个独立的构造器。

---

静态与实例方法共享设计

接着上面分割出2个构造器的疑问，来看看jQuery的一个遍历接口：

$(".aaron").each()   //作为实例方法存在
$.each()             //作为静态方法存在

看似实例和静态方法需要两个函数来实现，但在jQuery源码中是这样的：

jQuery.prototype = {
    // 调用实例方法实际上是将实例对象this作为一个参数，调用对应的静态方法，这样就形成了共享
    each: function( callback, args ) {
        return jQuery.each( this, callback, args );
    }
}

实例方法取于静态方法，换句话来说这是静态与实例方法共享设计，静态方法挂在jQuery构造器上，原型方法挂在哪里呢？------jQuery通过new原型prototype上的init方法当作构造器，那么init的原型链方法就是实例的方法了，所以jQuery通过2个构造器划分2种不同的调用方式一种是静态，一种是原型。

那如果要将2个构造器原型关联起来，关键就是靠下面一句：

ajQuery.fn.init.prototype = ajQuery.fn

这样init构造出来的实例对象也能够继承jQuery原型上的方法了。

---

方法链式调用的实现

jQuery的核心理念是Write less,Do more(写的更少,做的更多)，那么链式方法的设计与这个核心理念不谋而合。那么从深层次考虑这种设计其实就是一种Internal DSL。

DSL是指Domain Specific Language，也就是用于描述和解决特定领域问题的语言。

jQuery的Internal DSL形式带来的好处——编写代码时，让代码更贴近作者的思维模式；阅读代码时，让读者更容易理解代码的含义；应用DSL可以有效的提高系统的可维护性（缩小了实现模型和领域模型的距离，提高了实现的可读性）和灵活性，并且提供开发的效率。

jQuery的这种管道风格的DSL链式代码，总的来说：

☑ 节约JS代码；

☑ 所返回的都是同一个对象，可以提高代码的效率

实现链式操作的原理大家都懂的，就只需要在方法内返回当前的这个实例对象this就可以了，因为返回当前实例的this，从而又可以访问自己的原型了，这样的就节省代码量，提高代码的效率，代码看起来更优雅。但是这种方法有一个问题是：所有对象的方法返回的都是对象本身，也就是说没有返回值，所以这种方法不一定在任何环境下都适合。

---

插件接口的设计

jQuery插件的开发分为两种：

☑ 一种是挂在jQuery命名空间下的全局函数，也可称为静态方法；

☑ 另一种是jQuery对象级别的方法，即挂在jQuery原型下的方法，这样通过选择器获取的jQuery对象实例也能共享该方法。

提供的接口：

$.extend(target, [object1], [objectN]);
$.fn.extend();

接口的使用：

// 拓展到jQuery上的静态方法
jQuery.extend({
    data:function(){},
    removeData:function(){}
})

// 拓展到实例对象上的原型方法
jQuery.fn.extend({
    data:function(){},
    removeData:function(){}
})

而jQuery源码中对于上面两种扩展，其实是同指向同一方法的不同引用（这里有一个设计的重点，通过调用的上下文，我们来确定这个方法是作为静态还是实例处理，在javascript的世界中一共有四种上下文调用方式：方法调用模式、函数调用模式、构造器调用模式、apply调用模式），而这一切都是依靠this来完成的。

☑  jQuery.extend调用的时候上下文指向的是jQuery构造器，this指向的是jQuery

☑  jQuery.fn.extend调用的时候上下文指向的是jQuery构造器的实例对象了，this指向实例对象

因此在源码中是这样的：

aAron.extend = aAron.fn.extend = function() {
    var options, src, copy,
        target = arguments[0] || {},
        i = 1,
        length = arguments.length;

    // 只有一个参数，就是对jQuery自身的扩展处理
    if (i === length) {
        target = this; // 调用的上下文对象，前一个方法对应jQuery，后一个方法对应实例
        i--;
    }
    for (; i < length; i++) {
        // 从i开始取参数,不为空开始遍历
        if ((options = arguments[i]) != null) {
            for (name in options) {
                copy = options[name];
                // 覆盖拷贝
                target[name] = copy;
            }
        }
    }
    return target;
}

我来讲解一下上面的代码：因为extend的核心功能就是通过扩展收集功能（类似于mix混入），所以就会存在收集对象（target）与被收集的数据，因为jQuery.extend并没有明确实参，而且是通过arguments来判断的，所以这样处理起来很灵活。arguments通过判断传递参数的数量可以实现函数重载。其中最重要的一段target = this，通过调用的方式我们就能确实当前的this的指向，所以这时候就能确定target了。最后就很简单了，通过for循环遍历把数据附加到这个target上了。当然在这个附加的过程中我们还可以做数据过滤、深拷贝等一系列的操作了。

---

回溯处理的设计

通过jQuery处理后返回的不仅仅只有DOM对象，而是一个包装容器，返回jQuery对象。而这一个对象中有一个preObject的属性。

要了解这个属性是做什么的，首先了解一下jQuery对象栈，jQuery内部维护着一个jQuery对象栈。每个遍历方法（在当前选中范围内的DOM再进行筛选的操作，例如.find()方法）都会找到一组新元素（一个jQuery对象），然后jQuery会把这组元素推入到栈中。

而每个jQuery对象都有三个属性：context、selector和prevObject（用id选择器的话这个属性不一定有），其中的prevObject属性就指向这个对象栈中的前一个对象，而通过这个属性可以回溯到最初的DOM元素集中。

可以看下下面的例子：

$("div").find('.foo').find('.aaa') // 这里的preObject属性就会指向$("div").find('.foo')的DOM集合
$("div").find('.foo')  // 往前一级的preObect属性就是指向$("div")的DOM集合

而这种可以回溯到之前选择的DOM集合的机制，是为这两个方法服务的：

.end() // 回溯到前一个jQuery对象，即prevObject属性
.addBack() // 把当前位置和前一个位置的元素结合组合起来，并且将这个新的组合的元素集推入栈的上方

而利用这个回溯机制和对应的方法可以进行如下的操作：

<ul class="first">
	<li class="foo">list item 1</li>
	<li>list item 2</li>
	<li class="bar">list item 3</li>
</ul>

<script>
    // foo类li标签背景设置为红色， bar类li标签背景设置为绿色
	$("#test2").click(function(){
  	    //通过end连贯处理
  	    $('ul.first')
            .find('.foo')
            .css('background-color', 'red')
    		.end()
            .find('.bar')
            .css('background-color', 'green');
	})
</scripts>

利用这个DOM元素栈可以减少重复的查询和遍历的操作，而减少重复操作也正是优化jQuery代码性能的关键所在。

---

end

end方法能够帮助我们回溯到上一个DOM合集，因此该方法返回的就是一个jQuery对象，在源码中的表现就是返回了prevObject对象：

end: function() {
    return this.prevObject || this.constructor(null);
}

那么prevObject在什么情况下会产生？

在构建jQuery对象的时候，通过pushStack方法构建，如下代码：

pushStack: function( elems ) {
    // Build a new jQuery matched element set
    // 这里将传进来的DOM元素，通过调用jQuery的方法构建成一个新的jQuery对象
    var ret = jQuery.merge( this.constructor(), elems );

    // Add the old object onto the stack (as a reference)
    // 在此对象上把前一个jQuery对象添加到prevObject属性中
    ret.prevObject = this;
    ret.context = this.context;

    // Return the newly-formed element set
    // 最后返回这个jQuery对象
    return ret;
 }

那么在find方法中，为了将前一个jQuery对象推入栈中，就会调用这个pushStack方法来构建：

jQuery.fn.extend({
    find: function(selector) {

        //...........................省略................................

        //通过sizzle选择器，返回结果集
        jQuery.find(selector, self[i], ret);

        // Needed because $( selector, context ) becomes $( context ).find( selector )
        ret = this.pushStack(len > 1 ? jQuery.unique(ret) : ret); // 这里就是将实例对象推入栈中，然后返回新的jQuery对象
        ret.selector = this.selector ? this.selector + " " + selector : selector;
        return ret;
    }
}

---

仿栈与队列的操作

jQuery既然是模仿的数组结构，那么肯定会实现一套类数组的处理方法，比如常见的栈与队列操作push、pop、shift、unshift、求和、遍历循环each、排序及筛选等一系的扩展方法。

jQuery提供了.get()、:index()、 :lt()、:gt()、:even()及 :odd()这类索引值相关的选择器，他们的作用可以过滤他们前面的匹配表达式的集合元素，筛选的依据就是这个元素在原先匹配集合中的顺序。

先来看看get方法的实现源码：

get: function(num) {
    return num != null ?  // 不传参为undefined, 走false线
    // Return just the one element from the set
    (num < 0 ? this[num + this.length] : this[num]) :
    // Return all the elements in a clean array
    slice.call(this); // 返回整个DOM元素数组
}

---

get与eq的区别

熟悉jQuery的童鞋都清楚，get返回的是DOM元素，而eq返回的是jQuery对象，这样就可以继续执行链式操作。

eq实现的原理：

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

上面实现代码的逻辑就是跟get是一样的，区别就是通过了pushStack产生了一个新的jQuery对象。

如果需要的是一个合集对象要怎么处理？因此jQuery便提供了一个slice方法，根据下标范围取元素集合，并生成一个新的jQuery对象。

slice方法实现源码：

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

---

迭代器

迭代器是一个框架的重要设计。我们经常需要提供一种方法顺序用来处理聚合对象中各个元素，而又不暴露该对象的内部，这也是设计模式中的迭代器模式(Iterator)。

针对迭代器，这里有几个特点：

☑ 访问一个聚合对象的内容而无需暴露它的内部。

☑ 为遍历不同的集合结构提供一个统一的接口，从而支持同样的算法在不同的集合结构上进行操作。

☑ 遍历的同时更改迭代器所在的集合结构可能会导致问题。

另外还要考虑这四点：

☑ 聚合对象，可能是对象，字符串或者数组等类型

☑ 支持参数传递

☑ 支持上下文的传递

☑ 支持循环中退出（返回false的时候退出循环，节省性能）

简单实现一个迭代器：

function each(obj, callback, context, arg) {
    var i = 0;
    var value;
    var length = obj.length;
    for (; i < length; i++) {
        value = callback.call(context || null, obj[i], arg);
        if (value === false) {
            break;
        }
    }

---

jQuery的each迭代器

$.each()函数和$(selector).each()是不一样的，后者是专门用来遍历一个jQuery对象的，是为jQuery内部服务的。

jQuery的实例方法最终也是调用的静态方法，我们在之前就解释过jQuery的实例与原型方法共享的设计。

$.each()实例方法如下：

// 内部是直接调用的静态方法
each: function(callback, args) {
    return jQuery.each(this, callback, args);
},

jQuery.each静态方法：

each: function(obj, callback, args) {
    var value,
        i = 0,
        length = obj.length,
        isArray = isArraylike(obj);

    if (args) {
        if (isArray) {
            for (; i < length; i++) {
                value = callback.apply(obj[i], args);

                if (value === false) {
                    break;
                }
            }
        } else {
            for (i in obj) {
                value = callback.apply(obj[i], args);

                if (value === false) {
                    break;
                }
            }
        }

实现原理几乎一致，只是增加了对于参数的判断。对象用for in遍历，数组用for遍历。

---