复制代码代码如下所示：


obj1 = { {一：A、B B}；
obj2 = { x：{ XXX：'xxx，YYY：'yyy}，Y Y }；

美元。延长（真实、obj1，obj2）；

警报（obj1。X.XXX）； / / XXX

obj2.x.xxx = 'zzz；
警报（obj2。X.XXX）； / / ZZZ
警报（obj1。X.XXX）； / / XXX


美元。延长（真实、obj1，obj2）是指在obj2属性扩展对象obj1，和第一个参数设置为true，表示深切的复制。
虽然没有X的属性在obj1，膨胀后，以此不仅有X的属性，而且在obj2修改X属性不会影响在obj1 X属性的值，即深层复制。

浅复制的实现

如果只需要浅拷贝，则可以使用类似的方法。
复制代码代码如下所示：
= { $
扩展：函数（目标，选项）{
对于（选项中的名称）{
目标{ }选项= { }；
}
将目标；
}
}；

也就是说，只需将选项中的属性复制到目标中，我们仍然可以用类似的代码进行测试，但结果是不同的（假设我们的JS名为jQuery扩展名js）：
复制代码代码如下所示：


obj1 = { {一：A、B B}；
obj2 = { x：{ XXX：'xxx，YYY：'yyy}，Y Y }；
为延长（obj1，obj2）；
警报（obj1。X.XXX）； / / XXX
obj2.x.xxx = 'zzz；
警报（obj2。X.XXX）； / / ZZZ
警报（obj1。X.XXX）； / / ZZZ


以此具有X属性

深度复制的实现

如果我们想要实现一个深度拷贝，当对象是数组或对象时，应该递归调用扩展：
复制代码代码如下所示：
= { $
扩展：函数（深，目标，选项）{
对于（选项中的名称）{
复制=选项{名称}；
如果（深拷贝是数组）{
目标{ }扩展名（深，{，副本）；
} else if（深拷贝实例对象）{
目标{ }扩展名（深，{，副本）；
{人}
目标{ }选项= { }；
}
}
将目标；
}
}；

具体分为三种情况：
当1。属性是一个数组，目标{ }被初始化为空数组，然后递归地调用扩展。
当2。属性是一个对象，目标{ }被初始化为一个空对象，然后递归地调用扩展名；
三.否则，直接复制属性。

测试代码如下所示：
复制代码代码如下所示：


obj1 = { {一：A、B B}；
obj2 = { x：{ XXX：'xxx，YYY：'yyy}，Y Y }；
美元。延长（真实、obj1，obj2）；
警报（obj1。X.XXX）； / / XXX
obj2.x.xxx = 'zzz；
警报（obj2。X.XXX）； / / ZZZ
警报（obj1。X.XXX）； / / XXX


现在，如果指定为深拷贝，修改不会影响obj1 obj2。然而，仍然有一些问题的代码，例如，是阵列可以在IE5是不相容的。实际上在jQuery实现更复杂。

更完整的实现

下面的实现更接近于（在jQuery中）：
复制代码代码如下所示：
$ =函数（）{（）
无功copyisarray，
object.prototype.tostring toString =，
有自己的= object.prototype.hasownproperty；

class2type = { {
{ }：'boolean对象布尔，
{ }：若干的对象编号，
{ }'String'对象的字符串，
{ }：'function的目标函数，
{ }：'array的对象数组，
{ }：'date对象的日期，
{ }：'regexp的正则表达式对象，
{ }：'object对象
}，

类型=功能（obj）{
返回obj = null字符串（obj）：class2type { tostring.call（obj）} | |对象；
}，

iswindow =功能（obj）{
返回对象类型的对象，对象在setInterval目标；
}，

ISArray = array.isarray功能（obj）{ | |
返回类型（obj）=阵；
}，

isplainobject =功能（obj）{
如果（obj类型（obj）| |！！= =对象| | | | obj.nodetype iswindow（obj））{
返回false；
}

如果（obj.constructor！hasown.call（obj，构造函数）
hasown.call（obj.constructor.prototype，isprototypeof ））{
返回false；
}

无功的关键；
对于（关键在obj）{
}

返回键=定义的| | hasown.call（obj，关键）；
}，

扩展=函数（深，目标，选项）{
对于（选项中的名称）{
目标= { }；
复制=选项{名称}；

如果（目标=复制）{继续}；

如果（深拷贝）
（isplainobject（复印件）| |（copyisarray = ISArray（副本））））{
如果（copyisarray）{
copyisarray = false；
钢骨混凝土（SRC）克隆= ISArray SRC：{ }；

{人}
钢骨混凝土（SRC）克隆= isplainobject SRC：{ }；
}

目标{扩展名（深，克隆，复制）；
否则如果}（副本）！=未定义的）{
目标{ } =复制；
}
}

将目标；
}；

返回{扩展：扩展}；
（}）；

第一个是$ =（…）{（}）；这种写作可以理解为与下面的类似。
复制代码代码如下所示：
函数（）{…}；
$ =函数（）；

即执行函数立即将结果赋给美元。这种方法可以使用功能来管理行动的范围，避免局部变量或局部影响整个地区的功能。此外，我们只想让用户呼叫美元。延长（）和隐藏内部实现的功能，所以只有对象返回的是包含在扩展：
复制代码代码如下所示：
返回{扩展：扩展}；

接下来，让我们看看扩展函数和前一个函数之间的区别。
复制代码代码如下所示：
如果（目标=复制）{继续}；

这是为了避免无限循环，而属性复制与目标相同，即将自身复制到自己的属性中，这可能导致不可预知的循环。

然后是判断一个对象是否是数组的方法。
复制代码代码如下所示：
类型=功能（obj）{
返回obj = null字符串（obj）：class2type { tostring.call（obj）} | |对象；
}，
ISArray = array.isarray功能（obj）{ | |
返回类型（obj）=阵；
}

如果浏览器内置的array.isarray实施，它将使用浏览器的方式实现，否则会把对象的字符串是否是{对象数组}。

最后，看一句句子的isplainobject实施：
复制代码代码如下所示：
如果（obj类型（obj）| |！！= =对象| | | | obj.nodetype iswindow（obj））{
返回false；
}

如果obj.nodetype定义，这意味着这是一个DOM元素；此代码表明，以下四种情况不作深拷贝：
1。对象未定义；
2。字符串不为{对象对象}；
三.obj是一个DOM元素；
4。obj是窗口。
DOM和窗口难以复制的原因可能是因为它们包含了太多的属性。特别是对于窗口对象，全局域中声明的所有变量都是它们的属性，更不用说内置属性了。

下一个是与构造函数相关的测试：
复制代码代码如下所示：
如果（obj.constructor！hasown.call（obj，构造函数）
hasown.call（obj.constructor.prototype，isprototypeof ））{
返回false；
}

如果对象有一个构造函数，但它不是一个属性，它表明构造函数继承了原型，它不深复制。这可以用下面的代码组合的理解：
复制代码代码如下所示：
无功的关键；
对于（关键在obj）{
}
返回键=定义的| | hasown.call（obj，关键）；

这些代码用来检查对象的属性是否都是自属性的，因为遍历对象的属性时，它首先会从它的属性开始遍历，所以我们只需要检查最后一个属性是否是它自己的。
这表明，如果对象是通过原型构造函数或属性继承的，则不是对象的深层复制；这也可能考虑到对象的类型可以是复杂的、处理的，为了避免引入不确定性或复制大量的属性并花费大量的时间，可以从函数名中看出。深拷贝，只有plainobject 。
如果我们使用以下代码进行测试：
复制代码代码如下所示：


函数o（）{
this.yyy = 'yyy；
}

函数x（）{
this.xxx = 'xxx；
}

x.prototype =新的O（）；

x =新的x（）；

obj1 = { {一：A、B B}；
obj2 = { x x }；
美元。延长（真实、obj1，obj2）；

警报（obj1。x.yyy）； / / XXX
obj2.x.yyy = 'zzz；
警报（obj1。x.yyy）； / / ZZZ


正如你所看到的，这种情况并不能造成深刻的影响。
总之，jQuery中扩展（）的实现考虑到了浏览器兼容性的兼容性，避免了低性能和避免不可预知的错误。