前言

说道拷贝大家可能联想到深拷贝和浅拷贝概念，然而在swift却很少涉及宝贝问题，即使swift下依然有copy和mutableCopy方法。但终其原因，创建单纯的swift类并不需要继承NSObject,而是使用swift类，另外很多牵扯拷贝问题的数组和字典，在swift对应于Array和Dictionary,不同于NSArray 和NSDictionary，swift的Array和Dictionary是值类型，赋值后并不需要担心其拷贝问题。

所以主要Objective-C中的深拷贝和浅拷贝。

什么是深拷贝？什么是浅拷贝???

深拷贝是深度拷贝，是拷贝一个实例对象到一个新的内存地址，

浅拷贝只是简单拷贝一个实例对象的指针。

官方文档提供了这样一个图

从图中可以看到，集合的

浅拷贝后的数组Array2和Array1 指向同一段内存区域而深拷贝Array2和Array1 分别指向不同的内存区域

从这一点来看我们刚刚所说的是正确的，

非集合拷贝

不可变字符串（NSString）

代码

  NSString *string = @"123";
    NSString *stringCopy = [string copy];
    NSMutableString *stringMutable = [string mutableCopy];
    NSLog(@"string addrerss:%p",string);
    NSLog(@"stringCopy addrerss:%p",stringCopy);
    NSLog(@"stringMutable addrerss:%p",stringMutable);

打印结果

• NSString 进行copy 只是对其指针拷贝
• NSString 进行 mutableCopy 是真正创建一份新的对象

不可变的字符串是存在内存常量，因此可以看到两处地址相差甚远

1.NSString 是不可变的，对其copy也仍然是相同的内容，因此copy后返回自身，所以仍然是相同的地址
2.mutableCopy 表明或许真的需要一份新的可能，因此返回一个新的对象

可变字符串（NSMutableString）

 NSMutableString *mString = [[NSMutableString alloc]initWithString:@"123"];
    NSString *mStringCopy = [mString copy];
    NSString *mStringMutable = [mString mutableCopy];
    NSLog(@"mString addrerss:%p",mString);
    NSLog(@"mStringCopy addrerss:%p",mStringCopy);
    NSLog(@"mStringMutable addrerss:%p",mStringMutable);
    NSLog(@"mStringCopy is mutable ? %@",[mStringCopy isKindOfClass:[NSMutableString class]] ? @"YES" : @"NO");
    NSLog(@"mStringMutable is mutable ? %@",[mStringMutable isKindOfClass:[NSMutableString class]] ? @"YES" : @"NO");

• NSMutableString 的copy 变成是一个不可变的字符串
• mutableCopy 返回的是一个可变的字符串
• NSMutableString 无论copy还是mutableCopy 地址都不一样

总结

1.自定义的类需要实现深拷贝和浅拷贝，只要实现NSCoping协议即可。
2.如果实现浅拷贝，只需要在copyWithZone:方法返回自身即可
3.深拷贝：取决于每一层对象的本身，这个需要完全拷贝。则每一层对象都应该实现copyWithZone:中创建好新的对象，如果每一层都做到了深拷贝，那么最外层就是完全拷贝。

集合类对象拷贝（copy/mutableCopy）

集合类不可变对象

    NSString *str1 = @"hello world";
    NSMutableString *str2 = [NSMutableString stringWithString:@"hello world"];
    NSArray *array1 = [NSArray arrayWithObjects: str1, str2, nil];
    NSArray *array2 = [array1 copy];
    NSArray *array3 = [array1 mutableCopy];
    
    NSLog(@"\n array1 = %p class = %@ \n", array1, [array1 class]);
    NSLog(@"\n array2 = %p class = %@ \n", array2, [array2 class]);
    NSLog(@"\n array3 = %p class = %@ \n", array3, [array3 class]);
    
    NSLog(@"\n\n======== 元素是String ======== ");
    NSLog(@"\n obj0 = %p class = %@ \n", array1[0], [array1[0] class]);
    NSLog(@"\n obj0 = %p class = %@ \n", array2[0], [array2[0] class]);
    NSLog(@"\n obj0 = %p class = %@ \n", array3[0], [array3[0] class]);
   
    NSLog(@"\n\n======== 元素是mutableString ========");
    NSLog(@"\n obj1 = %p class = %@ \n", array1[1], [array1[1] class]);
    NSLog(@"\n obj1 = %p class = %@ \n", array2[1], [array2[1] class]);
    NSLog(@"\n obj1 = %p class = %@ \n", array3[1], [array3[1] class]);

输出

2021-05-08 17:34:32.740896+0800 AlgorithmDemo[39309:14557776] 
 array1 = 0x102904180 class = __NSArrayI
 array2 = 0x102904180 class = __NSArrayI
 array3 = 0x102904260 class = __NSArrayM

======== 元素是String ======== 
 obj0 = 0x100008220 class = __NSCFConstantString
 obj0 = 0x100008220 class = __NSCFConstantString
 obj0 = 0x100008220 class = __NSCFConstantString

======== 元素是mutableString ========
 obj1 = 0x1028719b0 class = __NSCFString
 obj1 = 0x1028719b0 class = __NSCFString
 obj1 = 0x1028719b0 class = __NSCFString

由打印可得：

• 集合类不可变对象的copy为浅拷贝
• mutableCopy为深拷贝
• 无论copy还是mutableCopy集合内元素都是浅拷贝

集合类可变对象

    NSString *str1 = @"hello world";
    NSMutableString *str2 = [NSMutableString stringWithString:@"hello world"];
    NSMutableArray *array1 = [NSMutableArray arrayWithObjects: str1, str2, nil];
    NSMutableArray *array2 = [array1 copy];
    NSMutableArray *array3 = [array1 mutableCopy];
    
    NSLog(@"\n array1 = %p class = %@ \n", array1, [array1 class]);
    NSLog(@"\n array2 = %p class = %@ \n", array2, [array2 class]);
    NSLog(@"\n array3 = %p class = %@ \n", array3, [array3 class]);
    
    NSLog(@"\n\n======== 元素是mutableString ========");
    NSLog(@"\n obj0 = %p class = %@ \n", array1[0], [array1[0] class]);
    NSLog(@"\n obj0 = %p class = %@ \n", array2[0], [array2[0] class]);
    NSLog(@"\n obj0 = %p class = %@ \n", array3[0], [array3[0] class]);
    
    
    NSLog(@"\n\n======== 元素是String ======== ");
    NSLog(@"\n obj1 = %p class = %@ \n", array1[1], [array1[1] class]);
    NSLog(@"\n obj1 = %p class = %@ \n", array2[1], [array2[1] class]);
    NSLog(@"\n obj1 = %p class = %@ \n", array3[1], [array3[1] class]);

输出:

2021-05-08 17:40:01.757406+0800 AlgorithmDemo[40202:14563979] 
 array1 = 0x1006046e0 class = __NSArrayM
 array2 = 0x100604860 class = __NSArrayI
 array3 = 0x100604890 class = __NSArrayM

======== 元素是mutableString ========
 obj0 = 0x100008220 class = __NSCFConstantString
 obj0 = 0x100008220 class = __NSCFConstantString
 obj0 = 0x100008220 class = __NSCFConstantString

======== 元素是String ======== 
 obj1 = 0x100604510 class = __NSCFString
 obj1 = 0x100604510 class = __NSCFString
 obj1 = 0x100604510 class = __NSCFString

结论

• 集合类可变对象的mutableCopy和copy都是深拷贝
• 但集合内元素是浅拷贝

总结

非集合类对象只有不可变对象的copy是浅拷贝,其它都是深拷贝 集合类且集合内元素都是浅拷贝

也可换个方式总结：

• copy： 对不可变对象是浅拷贝，可变对象是深拷贝
• mutableCopy： 始终是深拷贝
• 无论深浅拷贝，集合对象内元素都是浅拷贝

集合里面元素拷贝（copyItems: ）

集合浅拷贝

集合浅拷贝的方式很多，当创建一个浅拷贝时，之前集合里面的每个对象都会收到retain的消息，使其引用计数加1，并将其指针拷贝到新的集合中。

  NSArray *shaoolwCopyArray = [someArray copyWithZone:nil];
  NSDictionary *shaoolwCopyDict = [[NSDictionary alloc]initWithDictionary:someDict copyItems: NO];

数组浅拷贝

代码

 NSArray *someArray = @[@222];
 NSArray *shaoolwCopyArray = [someArray copyWithZone:nil];
 NSLog(@"someArray addrerss:%p",someArray);
 NSLog(@"shaoolwCopyArray addrerss:%p",shaoolwCopyArray);

打印后的地址

浅拷贝的数组所指向的地址是一样的

这是因为对于数组我们只调用了它的copyWithZone方法，由于是不可变的数组，返回了自身，所以浅拷贝前后不可变数组内存地址不变

字典浅拷贝

代码

 
    NSDictionary *someDict = @{@"11":@"22"};
    NSDictionary *shaoolwCopyDict = [[NSDictionary alloc]initWithDictionary:someDict copyItems: NO];
    NSLog(@"someDict addrerss:%p",someDict);
    NSLog(@"shaoolwCopyDict addrerss:%p",shaoolwCopyDict);

打印后的地址

字典所指向的内存地址发生了变化，其内部元素的地址不变。

而对于字典来说，shaoolwCopyDict是通过alloc和init 创建的，因此在内存中开辟了一段新的内存空间,所以浅拷贝前后字典的内存地址发生了变化.但对于之前字典中的对象，只是拷贝其内存地址，

如果代码改变一下

NSDictionary *someDict = @{@"11":@"22"};
NSDictionary *shaoolwCopyDict = [someDict copy];

打印结果

NSDictionary 它是不可变的使用copy 之后返回自身

浅拷贝总结

浅拷贝并不是自身的浅拷贝，而是对于其内部元素的浅拷贝

集合深拷贝

对于深拷贝将copyItems:换成YES就是深拷贝了。

在深拷贝中，系统会向集合中的每一个元素对象发送一个copyWithZone：消息，改消息是来自与NSCopying协议，如果有对象没有实现改协议方法，那么就会导致崩溃，如果实现了改方法，那么会根据该方法的具体实现。

数组深拷贝

数组深拷贝（元素不可变NSString）
代码

 NSString *str = @"2222";
    NSArray *someArray = @[str];
    NSArray *shaoolwCopyArray = [someArray copyWithZone:nil];
    NSArray *deepCopyArray = [[NSArray alloc]initWithArray:someArray copyItems:YES];
    NSLog(@"someArray addrerss:%p",someArray);
    NSLog(@"shaoolwCopyArray addrerss:%p",shaoolwCopyArray);
    NSLog(@"deepCopyArray addrerss:%p",deepCopyArray);
    NSLog(@"someArray[0] addrerss:%p",someArray[0]);
    NSLog(@"shaoolwCopyArray[0] addrerss:%p",shaoolwCopyArray[0]);
    NSLog(@"deepCopyArray[0] addrerss:%p",deepCopyArray[0]);

猜测结果shaoolwCopyArray和deepCopyArray应该是不一样的，这是因为deepCopyArray是通过alloc ，init 创建的，但最起码这两个数组的首元素地址是不一样的，运行后发现结果

运行结果

前三行与我们猜测的一致。但后面三行却 打印了相同的地址，然后后面也打印了一样的，明明采用了深浅拷贝，出现的结果确是相同的内存地址。

原因

集合类型的深拷贝会对每个元素调用copyWithZone:方法，

这就意味着刚刚后面三行打印的结果取决于该方法，在深拷贝时对于第一个元素调用了
NSString的copyWithZone:，但由于NSString是不可变的，对于其深拷贝创建一个新的内存是无意的，所以我们也可以猜测NSString的copyWithZone:返回的是self.所以浅拷贝时直接拷贝元素地址，而深拷贝时通过copyWithZone:方法来获取元素地址，两个结果是一样的。

数组深拷贝（元素可变NSMutableString）

将数组里面的NSString元素改变为NSMutableString

代码

    NSMutableString *str = [[NSMutableString alloc]initWithString:@"2222"];
       NSArray *someArray = @[str];
       NSArray *shaoolwCopyArray = [someArray copyWithZone:nil];
       NSArray *deepCopyArray = [[NSArray alloc]initWithArray:someArray copyItems:YES];
       NSLog(@"someArray addrerss:%p",someArray);
       NSLog(@"shaoolwCopyArray addrerss:%p",shaoolwCopyArray);
       NSLog(@"deepCopyArray addrerss:%p",deepCopyArray);
       NSLog(@"someArray[0] addrerss:%p",someArray[0]);
       NSLog(@"shaoolwCopyArray[0] addrerss:%p",shaoolwCopyArray[0]);

运行结果

集合完全拷贝

就是对对象的每一层都是重新创建的实例变量，不存在指针拷贝

例子(数组的归档解挡)

在对数组的归档解挡时就是完全深拷贝

NSArray *trueDeepCopyArray = [NSKeyedUnarchiver unarchiveObjectWithData:[NSKeyedArchiver archivedDataWithRootObject:oldArray]];

三种集合拷贝总结
浅拷贝

在浅拷贝操作时，对于被拷贝对象的每一层都是指针拷贝

深拷贝

在深拷贝操作时，对于被拷贝对象，至少有一层是深拷贝

完全拷贝

在完全拷贝操作时，对于被拷贝对象，每一层都是深拷贝

面试题

copy 修饰符

一般用于修饰字符串和block以及一些字典和数组。

copy 修饰（字符串/字典/数组）
看下面的例子

打印结果是NO，如果把copy换成strong就变成YES了

copy修饰符分析

在使用copy时，会对属性的setter方法进行判断，对属性copy,根据属性是否为可变，

• 可变返回一个新的不可变对象，即创建一个新不可变字符串
• 而对于不可变返回自身self，即为可变字符串。

strong修饰符分析

strong 则是对其引用，并没有执行copy方法

数组，字典，字符串，原理是一样的

对于NSString 作为不可变的字符串来说

1.修饰符copy返回的是自身，执行copy方法仍然返回自身。
2.strong 修饰也是返回自身，

NSString 不可变的对象，使用strong和copy是一样的

copy 修饰（block）

在ARC中如果引用外部变量赋值时便会自动拷贝到内存中

ARC 下使用block 使用copy/strong无异

这是为什么，数组浅拷贝不变，而字典浅拷贝发生了变化？？？

这是因为对于数组我们只调用了它的copyWithZone方法，由于是不可变的数组，返回了自身，所以浅拷贝前后数组内存地址不变，而对于字典来说，shaoolwCopyDict是通过alloc和init
创建的，因此在内存中开辟了一段新的内存空间。但对于之前字典中的对象，只是拷贝其内存地址，所以浅拷贝前后字典的内存地址发生了变化，

案例题（copyItems: 方法的讨论）

假设有一个Person类它有一个属性name，放入可变数组/或者不可变数组，数组发生深浅拷贝

代码

  Person *a = [[Person alloc]init];
   a.name = @"阿里巴巴";
    
    Person *b = [[Person alloc]init];
    b.name = @"今日头条";
    
    NSMutableArray *mutA  = [NSMutableArray arrayWithObjects:a,b, nil];
    NSMutableArray *mutB = [mutA mutableCopy];


//  Personerson

@interface Person : NSObject

@property (nonatomic, copy) NSString *name;

@end

mutA 与 mutB 地址是否一样

 NSLog(@"mutA addrerss:%p",mutA);
 NSLog(@"mutB addrerss:%p",mutB);

答案

mutA addrerss:0x60000371bba0
mutB addrerss:0x60000371be10
深拷贝数组地址不一样

mutA 与 mutB 里面元素的地址是否一样

  NSLog(@"mutA[0] addrerss:%p",mutA[0]);
  NSLog(@"mutB[0] addrerss:%p",mutB[0]);

答案

mutA[0] addrerss:0x600003f6c3d0
mutB[0] addrerss:0x600003f6c3d0

里面元素的地址一样

mutA 与 mutB 当改变mutB 里面元素的name值，mutA 里面的值改变不

因为 mutA  与 mutB 里面的元素地址是一样的，所以改变 mutB 里面的值， mutA  也会被改变。

mutA 与 mutB 当改变mutB 里面元素的name值时，mutA 的值不变

copyItems: 等于YES

 NSMutableArray *mutA  = [NSMutableArray arrayWithObjects:a,b, nil];
    NSMutableArray *mutB = [[NSMutableArray alloc] initWithArray:mutA copyItems:YES];

// Person 
- (id)copyWithZone:(NSZone *)zone {
    Person *person = [[Person allocWithZone:zone] init];
    person.name = self.name;
    return person;
}

copyItems: 等于YES 系统会向集合中的每一个元素对象发送一个copyWithZone：消息 而在copyWithZone: 的时候我创建了一个新对象，

数组的归档解挡

#import "Person.h"

@implementation Person

- (instancetype)initWithCoder:(NSCoder *)aDecoder {
    if (self = [super init]) {
        self.name = [aDecoder decodeObjectForKey:@"name"];
     }
    return self;
}

- (void)encodeWithCoder:(NSCoder *)aCoder {
    [aCoder encodeObject:self.name forKey:@"name"];
}

@end

什么是深浅拷贝？如何实现深浅拷贝

首先，先了解深浅拷贝的含义：

浅拷贝就是通过赋值的方式进行拷贝，那为什么说这是浅拷贝呢？就是因为赋值的方式只会把对象的表层赋值给一个新的对象，如果里面有属性值为数组或者对象的属性，那么就只会拷贝到该属性在栈空间的指针地址，新对象的这些属性数据就会跟旧对象公用一份，也就是说两个地址指向同一份数据，一个改变就会都改变。

深拷贝则不会出现上述问题，引用数据类型，地址跟数据都会拷贝出来。

浅拷贝

让我们先来看看浅拷贝，代码走你

let person = {
  uname: '张三',
  age: 22,
  sex: '男',
  arr: ['小明', '大大', '小小'],
  obj: {
    index: 1,
    name: '三和'
  },
  say: function () {
    console.log('hello javascript')
  }
}
let son = { ...person }
person.arr.push('小王')
console.log(son)
console.log(person)

控制台打印结果

一个对象的属性是引用类型，那么改变该属性值里面的内容，另外的拷贝对象也会改变，因此这种拷贝是浅拷贝

深拷贝

1.通过递归函数来实现深拷贝

let person = {
  uname: '张三',
  age: 22,
  sex: '男',
  arr: ['小明', '大大', '小小'],
  obj: {
    index: 1,
    name: '三和'
  },
  say: function () {
    console.log('hello javascript')
  }
}
let son = {}

function myCopy(newObj, obj) {
  for(let key in obj) {
    if (obj[key] instanceof Array) {
      newObj[key] = []
      myCopy(newObj[key], obj[key])
    } else if (obj[key] instanceof Object) {
      newObj[key] = {}
      myCopy(newObj[key], obj[key])
    } else {
      newObj[key] = obj[key]
    }
  }
}

// 调用递归函数
myCopy(son, person)

person.arr.push('小王')
console.log(son)
console.log(person)

控制台打印结果

2.通过 json 反序列化实现深拷贝

let person = {
  uname: '张三',
  age: 22,
  sex: '男',
  arr: ['小明', '大大', '小小'],
  obj: {
    index: 1,
    name: '三和'
  },
  say: function () {
    console.log('hello javascript')
  }
}

function myCopy(obj) {
  let _obj = JSON.stringify(obj)
  let newObj = JSON.parse(_obj)
  return newObj
}

let son = myCopy(person)

person.arr.push('小王')
console.log(son)
console.log(person)

控制台打印结果

3.通过 jQuery 封装的方法($.extend())实现深拷贝

必须先引入 jQuery
第一个参数必须是 true

let person = {
  uname: '张三',
  age: 22,
  sex: '男',
  arr: ['小明', '大大', '小小'],
  obj: {
    index: 1,
    name: '三和'
  },
  say: function () {
    console.log('hello javascript')
  }
}

let son = {}

$.extend(true, son, person) // 通过 $.extend() 方法实现深拷贝
// 第一个参数必须是 true

person.arr.push('小王')
console.log(son)
console.log(person)

控制台打印结果

从三种深拷贝的方法打印结果中可以发现一个问题，那就是在三个 person 对象中，都定义了一个 say 方法，前两种拷贝方法，都无法拷贝对象里面的方法，第三种方法却可以，所以使用的时候应该考虑到这个因素

---

今天的分享就到这里了

1：数据类型：

① 基本数据类型：Number、string、null、undefined、boolean
② 引用数据类型： Object =>{object、Array、Function}

2：栈(stack)、堆(heap)：

① 基本数据类型是直接存储在栈中的数据，栈的存取速度比堆要快，存在栈中的数据大小是确定的
问：为什么基本数据类型存储在栈中？ 存储结构不一样，引用数据类型一般占空间大
答：(http://www.javashuo.com/article/p-gkhlbedc-gg.html)
问：基本数据类型一定存在栈中么？
答：(https://www.cnblogs.com/linliquan/p/11273932.html)
② 引用数据类型存储的是该对象在栈中引用，真实的数据存放在堆内存里

3：基本数据类型和引用数据类型最大的区别：传值和传址

 
let arr = [1, 2, 3, 4, 5] //原数据（引用数据类型）
let arr1 = arr 
  console.log(arr,'arr')   //[1,2,3,4,5] 'arr'
  console.log(arr1,'arr1') //[1,2,3,4,5] 'arr1'
let arr2 = arr[2] 
  console.log(arr2,'arr2') //3 arr2
arr1[2] = 33
  console.log(arr1,'arr1-1')   //[1,2,33,4,5] 'arr1-1'
	console.log(arr,'arr-1')   //[1,2,33,4,5] 'arr-1'
arr2 = 4
	console.log(arr2,'arr2-1') //4 arr2-1
  console.log(arr,'arr-2') //[1,2,33,4,5] 'arr-2'

4：深浅拷贝：针对引用数据类型

① 浅拷贝：只复制指向某个对象的指针而不复制对象本身，新旧对象还是共享同一块内存。
② 深拷贝：指源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。

5：对象的直接赋值和浅拷贝的区别：

① 直接赋值：将一个对象赋值给一个新的对象的时候，赋的其实是该对象在栈中的地址，而不是堆中的数据。
也就是一个对象的改变就会改变另外一个对象。
② 浅拷贝：会创建一个对象，再去遍历原始对象，如果原对象的属性值是基础类型，那么就拷贝基础类型，
如果是引用类型，则拷贝的是指针。

let arr =[11,22,33,44,55]
let arr1 = arr //直接赋值
let arr2 = [...arr] //扩展运算符实现浅拷贝：...arr=>11,22,33,44,55

6：浅拷贝的实现方式：

① Object.assign():可以把任意多个的源对象自身的可枚举属性拷贝给目标对象，然后返回目标对象。
注：当object只有一层的时候，是深拷贝

let query = {name:'原数据',content:['前端','学习']}
let query1 = Object.assign({}, query)
console.log(query,'query') //{name：'原数据',content:['前端','学习']} query
console.log(query1,'query1') //{name：'原数据',content:['前端','学习']} query1
query1.name = '浅拷贝'
query1.content[1] = '浅拷贝学习'
console.log(query,'query-1') //{name：'原数据',content:['前端','浅拷贝学习']} query-1
console.log(query1,'query1-1') //{name：'浅拷贝',content:['前端','浅拷贝学习']} query1-1

② Array.prototype.concat()

let query = [1,3,{userName:'浅拷贝'}]
let query1 = query.concat()
query1[1] = 33
query1[2].userName = 'concat'
console.log(query,'query')//[1,3,{userName:'concat'}]
console.log(query1,'query1')//[1,33,{userName:'concat'}]

③ Array.prototype.slice()

let query = [1,3,{userName:'浅拷贝'}]
let query1 = query.slice(0)
query1[1] = 33
query1[2].userName = 'concat'
console.log(query,'query')//[1,3,{userName:'concat'}]
console.log(query1,'query1')//[1,33,{userName:'concat'}]

说明：Array的slice和concat方法不修改原数组，只会返回一个浅复制了原数组中的元素的一个新数组。
浅拷贝的方式有很多：for…in 等等

var person = {
	name: "浅拷贝",
	age: 111,
	sex: '保密'
};
var person2 = {};
for (var key in person1) {
	person2[key] = person1[key];
}
console.log(person2) //{name: "浅拷贝", age: 111, sex: '保密'}

7：深拷贝的实现方式：

① JSON.parse(JSON.stringify()): 用JSON.stringify将对象转成JSON字符串，再用JSON.parse()把字符串解析成对象， 一去一来，新的对象产生了，而且对象会开辟新的栈，实现深拷贝。
说明：JSON.parse(JSON.stringify())自身存在小问题:比如：不能处理函数，
因为 JSON.stringify() 方法是将一个JavaScript值(对象或者数组)转换为一个JSON字符串，不能接受函数。
另外还有 将undefined,’ ',empty 都转换为null，

let arr = ['深拷贝',' ','',null,undefined, ,{userName:'深拷贝1'},function(){}]
let arr1 = JSON.parse(JSON.stringify(arr))
console.log(arr1,'arr1')
arr1[6].userName = '拷贝'
console.log(arr,'arr') 
console.log(arr1,'arr1-1')

• 如果对象中存在循环引用的情况也无法正确实现深拷贝。

const a = {
    b: 1,
}
a.c = a;
JSON.parse(JSON.stringify(a));

• 如果 data 里面有时间对象，则JSON.stringify后再JSON.parse的结果，时间将只是字符串的形式。而不是时间对象。

const a = {
    b: new Date(1536627600000),
}
console.log(a) //{b: Tue Sep 11 2018 09:00:00 GMT+0800 (GMT+08:00)}
console.log(JSON.parse(JSON.stringify(a)))//{b: '2018-09-11T01:00:00.000Z'}

• 如果 data 里有RegExp、Error对象，则序列化的结果将只得到空对象；

const a = {
    b: new RegExp(/\d/),
    c: new Error('错误')
}
console.log(a) //
console.log(JSON.parse(JSON.stringify(a)))
 

• 如果 data 里有NaN、Infinity和-Infinity，则序列化的结果会变成null

const a = {
    b: NaN,
    c: 1.7976931348623157E+10308,
    d: -1.7976931348623157E+10308,
}
console.log(JSON.parse(JSON.stringify(a)))//{b: null, c: null, d: null}

② 手写递归方法：
递归方法实现深度克隆原理：遍历对象、数组直到里边都是基本数据类型，然后再去复制，就是深度拷贝。

function deepClone(target){
    if(target !== null && typeof target === 'object'){ //判断 target 是不是引用类型。     
       let result = Object.prototype.toString.call(target) === "[object Array]" ? [] : {};
        for (let k in target){
           //hasOwnProperty表示是否有自己的属性。这个方法会查找一个对象是否有某个属性，但是不会去查找它的原型链。 
            if (target.hasOwnProperty(k)) {
                result[k] = deepClone(target[k])
            }
        }
        return result;
    }else{
        return target;
    }
}

• hasOwnProperty(链接跳转至详情：https://blog.csdn.net/i_dont_know_a/article/details/84324051)

/**ruoyi
 * This is just a simple version of deep copy
 * Has a lot of edge cases bug
 * If you want to use a perfect deep copy, use lodash's _.cloneDeep
 */
function deepCopy(source) {
        if (!source && typeof source !== 'object') {  判断source 是不是引用类型。
          throw new Error('error arguments', 'deepClone')
        }
        const targetObj = source.constructor === Array ? [] : {} 
        Object.keys(source).forEach((keys) => {
          if (source[keys] && typeof source[keys] === 'object') {
            targetObj[keys] = deepCopy(source[keys])
          } else {
            targetObj[keys] = source[keys]
          }
        })
        return targetObj
      }
      //   测试
      var obj = {
        //原数据，包含字符串、对象、函数、数组等不同的类型
        name: 'test',
        main: {
          a: 1,
          b: 2,
        },
        fn: function () {},
        friends: [1, 2, 3, [22, 33]],
      }
      let query = deepCopy(obj)
      query.friends[2]=4
console.log(obj)
console.log(query)

function deepClone(target) {
    // 获取数据类型
    function getType(target) {
        return Object.prototype.toString.call(target)
    }
    //判断数据是不是引用类型
    function isObject(target) {
        return target !== null && (typeof target === 'object' || typeof target === 'function');
    }
    //处理不需要遍历的应引用类型数据
    function handleOherData(target) {
        const type = getType(target);
        switch (type) {
            case "[object Date]":
                return new Date(target)
            case "[object RegExp]":
                return cloneReg(target)
            case "[object Function]":
                return cloneFunction(target)

        }
    }
    //拷贝Symbol类型数据
    function cloneSymbol(targe) {
        const a = String(targe); //把Symbol字符串化
        const b = a.substring(7, a.length - 1); //取出Symbol()的参数
        return Symbol(b); //用原先的Symbol()的参数创建一个新的Symbol
    }
    //拷贝正则类型数据
    function cloneReg(target) {
        const reFlags = /\w*$/;
        const result = new target.constructor(target.source, reFlags.exec(target));
        result.lastIndex = target.lastIndex;
        return result;
    }
    //拷贝函数
    function cloneFunction(targe) {
        //匹配函数体的正则
        const bodyReg = /(?<={)(.|\n)+(?=})/m;
        //匹配函数参数的正则
        const paramReg = /(?<=\().+(?=\)\s+{)/;
        const targeString = targe.toString();
        //利用prototype来区分下箭头函数和普通函数，箭头函数是没有prototype的
        if (targe.prototype) { //普通函数
            const param = paramReg.exec(targeString);
            const body = bodyReg.exec(targeString);
            if (body) {
                if (param) {
                    const paramArr = param[0].split(',');
                    //使用 new Function 重新构造一个新的函数
                    return new Function(...paramArr, body[0]);
                } else {
                    return new Function(body[0]);
                }
            } else {
                return null;
            }
        } else { //箭头函数
            //eval和函数字符串来重新生成一个箭头函数
            return eval(targeString);
        }
    }
    /**
     * 遍历数据处理函数
     * @array 要处理的数据
     * @callback 回调函数，接收两个参数 value 每一项的值 index 每一项的下标或者key。
     */
    function handleWhile(array, callback) {
        let index = -1;
        const length = array.length;
        while (++index < length) {
            callback(array[index], index);
        }
    }
    function clone(target, map) {
        if (isObject(target)) {
            let result = null;
            if (getType(target) === "[object Array]") {
                result = []
            } else if (getType(target) === "[object Object]") {
                result = {}
            } else if (getType(target) === "[object Map]") {
                result = new Map();
            } else if (getType(target) === "[object Set]") {
                result = new Set();
            }

            // 解决循环引用
            if (map.has(target)) {
                return map.get(target);
            }
            map.set(target, result);

            if (getType(target) === "[object Map]") {
                target.forEach((value, key) => {
                    result.set(key, clone(value, map));
                });
                return result;
            } else if (getType(target) === "[object Set]") {
                target.forEach(value => {
                    result.add(clone(value, map));
                });
                return result;
            } else if (getType(target) === "[object Object]" || getType(target) === "[object Array]") {
                const keys = getType(target) === "[object Array]" ? undefined : Object.keys(target);

                function callback(value, key) {
                    if (keys) {
                        // 如果keys存在则说明value是一个对象的key，不存在则说明key就是数组的下标。
                        key = value
                    }
                    result[key] = clone(target[key], map)
                }
                handleWhile(keys || target, callback)
            } else {
                result = handleOherData(target)
            }
            return result;
        } else {
            if (getType(target) === "[object Symbol]") {
                return cloneSymbol(target)
            } else {
                return target;
            }
        }
    }
    let map = new WeakMap;
    const result = clone(target, map);
    map = null;
    return result
}

loadsh:_.cloneDeep()
jQuery中extend( )

let obj = {
    childs: ['Jack', 'Tom'],
    age: 45
}
let newObj = $.extend(true, {}, obj)
newObj.childs[0] = 'Jone'
console.log(newObj.childs[0]) //----'Jone'
console.log(obj.childs[0]) //-----'Jack'

8.总结：