本文详细解析 JavaScript 中对象浅拷贝与深拷贝的区别。通过简单赋值、Object.assign() 实现浅拷贝；利用 JSON.parse()、递归算法及 Object.create() 实现深拷贝。重点分析各方法的局限性，如构造函数丢失、正则处理及循环引用问题，并提供改进代码与 jQuery.extend 参考。
深拷贝与浅拷贝的核心区别
对象在 JavaScript 中的拷贝操作主要分为深拷贝与浅拷贝两种，二者核心区别在于对嵌套对象引用的处理方式不同。
浅拷贝仅复制对象的第一层属性引用，不复制嵌套对象本身；而深拷贝则递归复制对象及其引用的所有层级对象，确保新对象完全独立。
浅拷贝的实现方式
一. 浅拷贝的实现
实现浅拷贝的方法相对直接，通常只需使用基础的赋值语句即可达成。
1.1 方法一：简单的复制语句
/* ================ 浅拷贝 ================ */
function simpleClone(initalObj) {
var obj = {};
for ( var i in initalObj) {
obj[i] = initalObj[i];
}
return obj;
}客户端调用
/* ================ 客户端调用 ================ */
var obj = {
a: "hello",
b: {
a: "world",
b: 21
},
c: ["Bob", "Tom", "Jenny"],
d: function() {
alert("hello world");
}
}
var cloneObj = simpleClone(obj); // 对象拷贝
console.log(cloneObj.b); // {a: "world", b: 21}
console.log(cloneObj.c); // ["Bob", "Tom", "Jenny"]
console.log(cloneObj.d); // function() { alert("hello world"); }
// 修改拷贝后的对象
cloneObj.b.a = "changed";
cloneObj.c = [1, 2, 3];
cloneObj.d = function() { alert("changed"); };
console.log(obj.b); // {a: "changed", b: 21} // // 原对象所引用的对象被修改了
console.log(obj.c); // ["Bob", "Tom", "Jenny"] // 原对象所引用的对象未被修改
console.log(obj.d); // function() { alert("hello world"); } // 原对象所引用的函数未被修改1.2 方法二：Object.assign()
Object.assign() 方法用于将多个源对象的自身可枚举属性复制到目标对象，并返回该目标对象。需要注意的是，该方法执行的是浅拷贝，即仅复制属性的引用而非对象实体。
var obj = { a: {a: "hello", b: 21} };
var initalObj = Object.assign({}, obj);
initalObj.a.a = "changed";
console.log(obj.a.a); // "changed"深拷贝的多种实现方案
二. 深拷贝的实现
实现深拷贝有多种途径，包括最简单的 JSON.parse() 方法、常用的递归拷贝逻辑，以及 ES5 规范中的 Object.create() 方法。
2.1 方法一：使用 JSON.parse() 方法
实现深拷贝的一种简便方式是使用 JSON.parse()，具体实现如下：
/* ================ 深拷贝 ================ */
function deepClone(initalObj) {
var obj = {};
try {
obj = JSON.parse(JSON.stringify(initalObj));
}
return obj;
}
/* ================ 客户端调用 ================ */
var obj = {
a: {
a: "world",
b: 21
}
}
var cloneObj = deepClone(obj);
cloneObj.a.a = "changed";
console.log(obj.a.a); // "world"这种方式代码简洁且易于使用。
然而，该方法存在显著缺陷：它会丢弃原对象的 constructor 属性。这意味着无论原对象的构造函数是什么，经过此方式深拷贝后，新对象的构造函数将变为 Object。
此方法仅能正确处理 Number、String、Boolean、Array 及扁平对象等能被 JSON 直接表示的数据结构。RegExp 等对象无法通过此方式实现深拷贝。
2.2 方法二：递归拷贝
具体代码如下：
/* ================ 深拷贝 ================ */
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;
}上述代码确实能够实现深拷贝功能。但当遇到两个对象相互引用的情况时，会导致无限递归死循环。
为避免相互引用导致的死循环，应在遍历过程中检测是否存在相互引用。若检测到，则跳过该属性以退出当前循环。
改进后的代码如下：
/* ================ 深拷贝 ================ */
function deepClone(initalObj, finalObj) {
var obj = finalObj || {};
for (var i in initalObj) {
var prop = initalObj[i];
// 避免相互引用对象导致死循环，如initalObj.a = initalObj的情况
if(prop === obj) {
continue;
}
if (typeof prop === 'object') {
obj[i] = (prop.constructor === Array) ? [] : {};
arguments.callee(prop, obj[i]);
} else {
obj[i] = prop;
}
}
return obj;
}2.3 方法三：使用Object.create()方法
直接执行 var newObj = Object.create(oldObj) 即可达到深拷贝的效果。
/* ================ 深拷贝 ================ */
function deepClone(initalObj, finalObj) {
var obj = finalObj || {};
for (var i in initalObj) {
var prop = initalObj[i];
// 避免相互引用对象导致死循环，如initalObj.a = initalObj的情况
if(prop === obj) {
continue;
}
if (typeof prop === 'object') {
obj[i] = (prop.constructor === Array) ? [] : Object.create(prop);
} else {
obj[i] = prop;
}
}
return obj;
}jQuery.extend 深拷贝参考
三. 参考：jQuery.extend()方法的实现
jQuery.js 库中的 jQuery.extend() 方法也实现了对象的深拷贝。以下展示官方源码供参考。
官方链接地址：https://github.com/jquery/jquery/blob/master/src/core.js。
jQuery.extend = jQuery.fn.extend = function() {
var options, name, src, copy, copyIsArray, clone,
target = arguments[ 0 ] || {},
i = 1,
length = arguments.length,
deep = false;
// Handle a deep copy situation
if ( typeof target === "boolean" ) {
deep = target;
// Skip the boolean and the target
target = arguments[ i ] || {};
i++;
}
// Handle case when target is a string or something (possible in deep copy)
if ( typeof target !== "object" && !jQuery.isFunction( target ) ) {
target = {};
}
// Extend jQuery itself if only one argument is passed
if ( i === length ) {
target = this;
i--;
}
for ( ; i < length; i++ ) {
// Only deal with non-null/undefined values
if ( ( options = arguments[ i ] ) != null ) {
// Extend the base object
for ( name in options ) {
src = target[ name ];
copy = options[ name ];
// Prevent never-ending loop
if ( target === copy ) {
continue;
}
// Recurse if we're merging plain objects or arrays
if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
( copyIsArray = jQuery.isArray( copy ) ) ) ) {
if ( copyIsArray ) {
copyIsArray = false;
clone = src && jQuery.isArray( src ) ? src : [];
} else {
clone = src && jQuery.isPlainObject( src ) ? src : {};
}
// Never move original objects, clone them
target[ name ] = jQuery.extend( deep, clone, copy );
// Don't bring in undefined values
} else if ( copy !== undefined ) {
target[ name ] = copy;
}
}
}
}
// Return the modified object
return target;
};本文主要介绍 JavaScript 中关于深拷贝的内容，其他相关信息可查看本站以往发表的文章。