//
// creates 'clone' method on context object
//
//  var 
//     clon = Object.clone( anyValue );
//
!((function (propertyName, definition) {
    this[propertyName] = definition();
}).call(
    Object,
    "clone",
    function () {
        function isfn(fn) {
            return typeof fn === "function";
        }

        function isobj(o) {
            return o === Object(o);
        }

        function isarray(o) {
            return Object.prototype.toString.call(o) === "[object Array]";
        }

        function fnclon(fn) {
            return function () {
                fn.apply(this, arguments);
            };
        }

        function owns(obj, p) {
            return obj.hasOwnProperty(p);
        }

        function isemptyobj(obj) {
            for (var p in obj) {
                return false;
            }
            return true;
        }

        function isObject(o) {
            return Object.prototype.toString.call(o) === "[object Object]";
        }
        return function (input) {
            if (isfn(input)) {
                return fnclon(input);
            } else if (isobj(input)) {
                var cloned = {};
                for (var p in input) {
                    owns(Object.prototype, p)
                    || (
                        isfn(input[p])
                        && ( cloned[p] = function () { return input[p].apply(input, arguments); } )
                        || ( cloned[p] = input[p] )
                    );
                }
                if (isarray(input)) {
                    cloned.length = input.length;
                    "concat every filter forEach indexOf join lastIndexOf map pop push reduce reduceRight reverse shift slice some sort splice toLocaleString toString unshift"
                    .split(" ")
                    .forEach(
                      function (methodName) {
                        isfn( Array.prototype[methodName] )
                        && (
                            cloned[methodName] =
                            function () {
                                return Array.prototype[methodName].apply(cloned, arguments);
                            }
                        );
                      }
                    );
                }
                return isemptyobj(cloned)
                       ? (
                          isObject(input)
                          ? cloned
                          : input
                        )
                       : cloned;
            } else {
                return input;
            }
        };
    }
));
//

根据MDN：

如果要浅层复制，请使用Object.assign（｛｝，a）对于“深度”复制，请使用JSON.parse（JSON.stringify（a））

不需要外部库，但您需要首先检查浏览器兼容性。

如果在对象中不使用Dates、functions、undefined、regExp或Infinity，那么一个非常简单的一行代码就是JSON.parse（JSON.stringify（object））：

常量a={string：'字符串'，编号：123，bool:false，nul：空，date:new date（），//字符串化undef：未定义，//丢失inf:无限，//强制为“null”}控制台日志（a）；console.log（类型a.date）；//日期对象constclone=JSON.parse（JSON.stringify（a））；console.log（克隆）；console.log（clone.date的类型）；//.toISOString（）的结果

这适用于包含对象、数组、字符串、布尔值和数字的所有类型的对象。

另请参阅本文，了解浏览器的结构化克隆算法，该算法在向工作人员发布消息时使用。它还包含一个用于深度克隆的功能。

如果你对一个浅拷贝没有问题，underscore.js库有一个克隆方法。

y = _.clone(x);

或者你可以像

copiedObject = _.extend({},originalObject);

一个特别不优雅的解决方案是使用JSON编码对没有成员方法的对象进行深度复制。方法是对目标对象进行JSON编码，然后通过对其进行解码，获得所需的副本。您可以解码任意次数，以制作任意数量的副本。

当然，函数不属于JSON，因此这只适用于没有成员方法的对象。

这种方法非常适合我的用例，因为我将JSON blob存储在一个键值存储中，并且当它们在JavaScript API中作为对象公开时，每个对象实际上都包含对象的原始状态的副本，因此我们可以在调用方对公开的对象进行变异后计算增量。

var object1 = {key:"value"};
var object2 = object1;

object2 = JSON.stringify(object1);
object2 = JSON.parse(object2);

object2.key = "a change";
console.log(object1);// returns value

我已经在标量对象的情况下尝试过这一点，它对我很有用：

function binder(i) {
  return function () {
    return i;
  };
}

a=1;
b=binder(a)(); // copy value of a into b

alert(++a); // 2
alert(b); // still 1

当做