jQuery.extend 与 jQuery.fn.extend

extend方法为jQuery对象的核心之一，语法如下:

jQuery.extend([deep], target, object1, [objectN]),返回值Object。

概述：用一个或多个其它对象来扩展一个对象，返回被扩展的对象。

如果不指定target，则给Jquery命名空间本身进行扩展。这有助于插件作者为Jquery增加新方法。

如果第一个参数设置为true，则Jquery返回一个深层次的副本，递归地复制找到的任何对象。否则的话，副本会与原对象共享结构。未定义的属性将不会被复制，然而从对象的原型继承的属性将会被复制。

参数：target,[object1],[objectN]Object,Object,Object

target:一个对象，如果附加的对象被传递给这个方法将那么它将接收新的属性，如果它是唯一的参数将扩展jQuery的命名空间。

object1:待合并到第一个对象的对象。

objectN:待合并到第一个对象的对象。

[deep],target,object1,[objectN] Object,Object,Object,Object

deep:如果设为true，则递归合并。

target:待修改对象。

object1:待合并到第一个对象的对象。

objectN:待合并到第一个对象的对象。

示例：

var ts = function () {this.age = 23;}
console.log($.extend([1,2,3],[4,5,6,7]));
// 结果：[4,5,6,7]
console.log($.extend(false, new ts(), { age: 12, name: "lisi" }));
//结果: Object {age: 12, name: "lisi"}
console.log($.extend({ age: 43, name: "张三" }, { sex: "男", height: 180 }, { job: "警察" }));
//结果：Object {age: 43, name: "张三", sex: "男", height: 180, job: "警察"}
console.log($.extend(true, { age: 23, child: { age: 1, sex: "男" } }, { name: '张三', child: { name: "李四" } }));
//结果：Object {age: 23, child: {age:1,name:'李四',sex:'男'}, name: "张三"}
console.log($.extend(false, { age: 23, child: { age: 1, sex: "男" } }, { name: '张三', child: { name: "李四" } }));
//结果：Object {age: 23, child: {name:"李四"}, name: "张三"}
console.log($.extend(true))
//结果: Object {}

在看源码之前我们先了解下深拷贝和浅拷贝:

浅拷贝 ：仅仅复制对象的引用，而不是对象本身；

深拷贝：把复制的对象所引用的全部对象都复制一遍。

浅拷贝例子：

/* ================ 浅拷贝 ================ */
function simpleClone(initalObj) {
var obj = {};
for ( var i in initalObj) {
obj[i] = initalObj[i];
}
return obj;
}

深拷贝例子：

/* ================ 深拷贝 ================ */
function deepClone(initalObj, finalObj) {
var obj = finalObj || {};
for (var i in initalObj) {
if (typeof initalObj[i] === 'object') {
obj[i] = (initalObj[i].constructor === Array) ? [] : {};
arguments.callee(initalObj[i], obj[i]);
} else {
obj[i] = initalObj[i];
}
}
return obj;
}

有了深拷贝和浅拷贝的介绍，我们再来看 Jquery.extend的源码分析:

jQuery.extend = jQuery.fn.extend = function() {
var src, copyIsArray, copy, name,
options, //20170614 huanhua 需要被合并的对象的临时变量
clone,
target = arguments[0] || {}, //huanhua 20170614 第一个参数赋值给 target ,需要合并到的对象 target
i = 1, //huanhua 20170614 被合并的对象，在参数中的起始位置，默认是第二个参数，索引下标就是1
length = arguments.length,
deep = false; //huanhua 20170614 深浅拷贝，默认是浅拷贝

// Handle a deep copy situation
　　// 20170614 huanhua 处理类似 jquery.extend(true,{age:23,child:{age:1,sex:"男"}},{name:'张三',child:{name:"李四"}})这种扩展

if ( typeof target === "boolean" ) {
deep = target; //huanhua 20170614 设置是深拷贝还是浅拷贝
target = arguments[1] || {}; //huanhua 20170614 此时需要合并到的对象是第二个参数
// skip the boolean and the target
i = 2; //20170614 huanhua 在进行深浅拷贝时，需要被合并的对象的起始位置是第3个参数,索引下标就是2开始
}

// Handle case when target is a string or something (possible in deep copy)
// 20170614 huanhua 处理类似 $.extend("hshshdhd", [4, 5, 6, 7]) 结果:Object {0: 4, 1: 5, 2: 6, 3: 7}这种的扩展
if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
target = {}; //20170614 huanhua 被扩展的对象，扩展到一个对象上
}

// extend jQuery itself if only one argument is passed
// 20170614 huanhau 处理类似 $.extend({name:"张哈"}) 这种，只有一个参数,并且还不是 $.extend(true)这种的参数格式
//此时参数的长度是1，i也是1
if ( length === i ) {
target = this;//20170614 huanhua 需要扩展到的对象就是jquery自己
--i; //20170614 huanhua 需要被合并的对象起始位置就是第一个参数，所以索引下标就是从 (--i)0开始
}
//20170614 huanhua 从需要被合并的对象的起始位置开始循环处理合并
for ( ; i < length; i++ ) {
// Only deal with non-null/undefined values
//20170614 huanhua 把需要被合并的对象赋值给 options ,并且只处理 非 null,非 undefined 的对象
if ( (options = arguments[ i ]) != null ) {
// Extend the base object
//20170614 huanhua 开始合并对象
for ( name in options ) {
//20170614 huanhua 在需要被扩展到的对象中寻找需要扩展的对象属性，并赋值给 src
src = target[ name ];
//20170614 huanhua 把需要被扩展的对象属性赋值给copy
copy = options[ name ];

// Prevent never-ending loop
//20170614 huanhua var o={w:2} $.extend(o,{hao:o}),结果 Object {w:2} 处理这种扩展，在递归深拷贝的时候以防死循环
//20170614 huanhua 譬如：
// var o = { n: o };
//    var xh = 0;
//    var f = function (o) {
//        for (var m in o) {
//            console.log((xh++));
//            console.log(m);
//            f(m);
//        }
//    }
//    f(o);
// 在递归运行的时候，就是一个死循环
if ( target === copy ) {
continue;
}

// Recurse if we're merging plain objects or arrays
//20170614 huanhua 需要深拷贝deep，并且需要拷贝的属性copy是有效的(非null,非undefined),
//并且需要拷贝copy的属性是纯粹的对象（{a:1}或者new object()）或者数组
if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
//20170614 huanhua 拷贝的是数组
if ( copyIsArray ) {
copyIsArray = false;
//20170614 huanhua如果需要扩展到的对象中不存在属性src = target[ name ],或者不是数组格式的，
//就重新用生成一个空的数组 [] 来装载扩展的数据，否则就用原来的属性来装载数据
clone = src && jQuery.isArray(src) ? src : [];

} else {
//20170614 huanhua如果需要扩展到的对象中不存在属性src = target[ name ],或者不是纯粹对象格式的，
//就重新用生成一个空的对象 {} 来装载扩展的数据，否则就用原来的属性来装载数据
clone = src && jQuery.isPlainObject(src) ? src : {};
}

// Never move original objects, clone them
//20170614 huanhua 递归扩展属性对象中的每一个属性
target[ name ] = jQuery.extend( deep, clone, copy );

// Don't bring in undefined values
//20170614 huanhua 其它的合并就浅拷贝，直接赋值或者添加属性
} else if ( copy !== undefined ) {
target[ name ] = copy;
}
}
}
}

// Return the modified object 20170614 huanhua 返回合并后的对象
return target;
};

javascript的继承有三种方式

1：原型继承。

2：类式继承。

3：拷贝继承。

Juqery采用的就是拷贝继承。

这只是个人的理解，有不对之处，望各位大神们指正。