分离构造器
通过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遍历。