克隆对象的简单递归方法。也可以使用lodash.clone。

让克隆=（obj）=>{let obj2=Array.isArray（obj）？[] : {};for（设k为obj）{obj2[k]=（obj[k]===“对象”的类型）？克隆（obj[k]）：obj[k]；}返回obj2；}让w＝{name:“Apple”，类型：[“Fuji”，“Gala”]}；设x=克隆（w）；w.name=“橙色”；w.types=[“Navel”]；console.log（x）；console.log（w）；

如果您正在使用TypeScript，需要支持较旧的web浏览器（因此无法使用Object.assign），并且没有使用内置有克隆方法的库，那么您可以在几行代码中使自己成为组合助手。它结合了对象，如果只有一个，就克隆它。

/** Creates a new object that combines the properties of the specified objects. */
function combine(...objs: {}[]) {
    const combined = {};
    objs.forEach(o => Object.keys(o).forEach(p => combined[p] = o[p]));
    return combined;
}

这里许多同行针对深度克隆提出的解决方案JSON.parse（JSON.stringify（orig_obj）有几个问题，我发现这些问题如下：

它在复制原始对象中未定义值的条目时丢弃这些条目，如果有一些值，如Infinity、NaN等，它们将在复制时转换为null，如果原始对象中存在Date类型，则它将在克隆对象中字符串化（typeof Date_entry-->string）。

找到了一种克隆对象的有效方法，它在各种场景中都很适合我。请看一看下面的代码，因为它已经解决了JSON.parse（…）的所有上述缺陷，但最终实现了正确的深度克隆：

var orig_obj = {
  string: 'my_str',
  number: 123,
  bool: false,
  nul: null,
  nested : {
    value : true
  },
  nan : NaN,
  date: new Date(), 
  undef: undefined,
  inf: Infinity,
}
console.log("original_obj before modification: ", orig_obj, "\n");
console.log(typeof orig_obj.date, "\n");

var clone_obj = Object.assign({}, orig_obj);

//this below loop will help in deep cloning and solving above issues
for(let prop in orig_obj) {
    if(typeof orig_obj[prop] === "object") {
        if(orig_obj[prop] instanceof Date)
            clone_obj[prop] = orig_obj[prop];
        else {
            clone_obj[prop] = JSON.parse(JSON.stringify(orig_obj[prop]));
        }
    }
}

console.log("cloned_obj before modification: ", orig_obj, "\n");

clone_obj.bool = true;
clone_obj.nested.value = "false";

console.log("original_obj post modification: ", orig_obj, "\n");
console.log("cloned_obj post modification: ", clone_obj, "\n");
console.log(typeof clone_obj.date);

我不知道这在哪些情况下不起作用，但它给了我一个数组的副本。我觉得它很可爱：）希望它有帮助

copiedArr = origArr.filter(function(x){return true})

好的，这可能是浅层复制的最佳选择。If遵循了许多使用赋值的示例，但它也保留了继承和原型。它也很简单，适用于大多数类数组和对象，但有构造函数要求或只读财产的对象除外。但这意味着它对于TypedArrays、RegExp、Date、Maps、Set和Object版本的原语（Boolean、String等）失败得很惨。

function copy ( a ) { return Object.assign( new a.constructor, a ) }

其中a可以是任何Object或类构造的实例，但对于使用专门的getter和setter或具有构造函数要求的对象来说，它同样不可靠，但对于更简单的情况来说，它很难。它也能处理争论。

您也可以将其应用于原语以获得奇怪的结果，但是。。。除非它最终成为有用的黑客，谁在乎呢。

基本内置对象和数组的结果。。。

> a = { a: 'A', b: 'B', c: 'C', d: 'D' }
{ a: 'A', b: 'B', c: 'C', d: 'D' }
> b = copy( a )
{ a: 'A', b: 'B', c: 'C', d: 'D' }
> a = [1,2,3,4]
[ 1, 2, 3, 4 ]
> b = copy( a )
[ 1, 2, 3, 4 ]

由于平均get/setter、构造函数必需的参数或只读财产，以及对父亲的冒犯，因此失败。

> a = /\w+/g
/\w+/g
> b = copy( a )  // fails because source and flags are read-only
/(?:)/
> a = new Date ( '1/1/2001' )
2000-12-31T16:00:00.000Z
> b = copy( a )  // fails because Date using methods to get and set things
2017-02-04T14:44:13.990Z
> a = new Boolean( true )
[Boolean: true]
> b = copy( a )  // fails because of of sins against the father
[Boolean: false]
> a = new Number( 37 )
[Number: 37]
> b = copy( a )  // fails because of of sins against the father
[Number: 0]
> a = new String( 'four score and seven years ago our four fathers' )
[String: 'four score and seven years ago our four fathers']
> b = copy( a )  // fails because of of sins against the father
{ [String: ''] '0': 'f', '1': 'o', '2': 'u', '3': 'r', '4': ' ', '5': 's', '6': 'c', '7': 'o', '8': 'r', '9': 'e', '10': ' ', '11': 'a', '12': 'n', '13': 'd', '14': ' ', '15': 's', '16': 'e', '17': 'v', '18': 'e', '19': 'n', '20': ' ', '21': 'y', '22': 'e', '23': 'a', '24': 'r', '25': 's', '26': ' ', '27': 'a', '28': 'g', '29': 'o', '30': ' ', '31': 'o', '32': 'u', '33': 'r', '34': ' ', '35': 'f', '36': 'o', '37': 'u', '38': 'r', '39': ' ', '40': 'f', '41': 'a', '42': 't', '43': 'h', '44': 'e', '45': 'r', '46': 's' } 

不同的

仅复制顶层：｛…object｝和object.assign（｛｝，object）

让objA={a： “键a”，b：{c： “键c”，}}let objB=Object.assign（｛｝，objA）；//或｛…objB｝//更改对象BobjB.a=“更改objA.a（顶部）”console.log（“objA.a（top）无更改：\n”+JSON.stringify（objA，false，2））；objB.b.c=“更改应仅适用于objB.b.c，但在objA.b.c中”console.log（“objA.a.c第二级已更改：\n”+JSON.stringify（objA，false，2））；

对于深度复制，请使用旧浏览器的structuredClone（）2022或JSON.parse（JSON.stringify（object）），无需黑客即可轻松完成。

让objA={a： “键a”，b：{c： “键c”，}}让objB=typeof structuredClone==“函数”？structuredClone（objA）：JSON.parse（JSON.stringify（objB））；//更改对象BobjB.a=“更改objA.a（顶部）”objB.b.c=“更改应该只针对objB.c，但它在objA.c中”console.log（“objA没有更改：\n”+JSON.stringify（objA，false，2））；