本文目录
深拷贝和浅拷贝的异同以及实现方式
相同点:
深拷贝和浅拷贝都是用于对复杂数据类型进行复制。
差异:
其区别在于深拷贝是对原数据进行递归复制,并存到一个新地址,从而使新老数据互不影响。
而浅拷贝只是对原数据的地址进行拷贝,从而会使新老数据相互影响。
常用实现方法:
深拷贝:
1.递归复制(全部适用)
function duplicate(obj) {
var newObj = null;
If(obj !== null && typeof(obj)==obj){
newObj=Obj instanceof Array?[]:{};
For (var i in obj){
newObj[i] = duplicate[i];
}
}else{
newObj = obj;
}
return newObj;
}
2.JSON.stringify(obj);
关于这个方法有一个缺点就是 不能拷贝function和undefine( 在火狐上直接报错error,而在谷歌上会直接忽略掉相关属性) 。因为这是通过把数据转化为字符串的形式赋值给一个新地址。
浅拷贝:
1.函数实现
function simpleDuplicate(obj){
Var newObj ={};
for(var I in obj){
If(obj.hasOwnProperity[i]){
newObj[i] = obj[i];
}
}
return newObj;
}
2.各种赋值、合并删除操作。
ios 深拷贝和浅拷贝的区别
一、概念与总结
1、浅拷贝
浅拷贝就是对内存地址的复制,让目标对象指针和源对象指向同一片内存空间,当内存销毁的时候,指向这片内存的几个指针需要重新定义才可以使用,要不然会成为野指针。
浅拷贝就是拷贝指向原来对象的指针,使原对象的引用计数+1,可以理解为创建了一个指向原对象的新指针而已,并没有创建一个全新的对象。
2、深拷贝
深拷贝是指拷贝对象的具体内容,而内存地址是自主分配的,拷贝结束之后,两个对象虽然存的值是相同的,但是内存地址不一样,两个对象也互不影响,互不干涉。
深拷贝就是拷贝出和原来仅仅是值一样,但是内存地址完全不一样的新的对象,创建后和原对象没有任何关系。
3、总结:
深拷贝就是内容拷贝,浅拷贝就是指针拷贝。本质区别在于:
是否开启新的内存地址
是否影响内存地址的引用计数
二、示例分析
在iOS中深拷贝与浅拷贝要更加的复杂,涉及到容器与非容器、可变与不可变对象的copy与mutableCopy。下面用示例逐一分析:
1、 非集合对象的copy与mutableCopy
1.1 不可变对象NSString
- (void) noMutableNSStringTest
{
NSString *str1 =@"test001";
NSMutableString *str2 = [str1 copy];
//copy返回的是不可变对象,str2不能被修改,因此会发生崩溃
//[str2 appendString:@"test"];
NSMutableString *str3 = [str1 mutableCopy];
[str3 appendString:@"modify"];
NSLog(@"str1:%p - %@ \r\n",str1,str1);
NSLog(@"str2:%p - %@ \r\n",str2,str2);
NSLog(@"str3:%p - %@ \r\n",str3,str3);
}
打印结果:
2017-07-2018:02:10.642beck.wang[1306:169414] str1:0x106abdbd0- test001 2017-07-2018:02:10.643beck.wang[1306:169414] str2:0x106abdbd0- test001 2017-07-2018:02:10.643beck.wang[1306:169414] str3:0x608000260940- test001modify
分析:str1、str2地址相同并且与str3地址不同,NSString的copy是浅拷贝,且copy返回的对象是不可变对象;mutableCopy是深拷贝。
1.2 可变对象NSMutableString
- (void) mutableNSStringTest
{
NSMutableString *mstr1 = [NSMutableString stringWithString:@"test002"];
NSMutableString *mstr2 = [mstr1 copy];
//copy返回的是不可变对象,mstr2不能被修改,因此会发生崩溃
//[str2 appendString:@"test"];
NSMutableString *mstr3 = [mstr1 mutableCopy];
[mstr3 appendString:@"modify"];
NSLog(@"mstr1:%p - %@ \r\n",mstr1,mstr1);
NSLog(@"mstr2:%p - %@ \r\n",mstr2,mstr2);
NSLog(@"mstr3:%p - %@ \r\n",mstr3,mstr3);
}
打印结果:
2017-07-2018:14:35.789beck.wang[1433:180881] mstr1:0x610000075e40- test002 2017-07-2018:14:35.790beck.wang[1433:180881] mstr2:0xa323030747365747- test002 2017-07-2018:14:35.790beck.wang[1433:180881] mstr3:0x610000074480- test002modify
分析:mstr1、mstr2、mstr3 地址都不同,NSMutableString对象copy与mutableCopy都是深拷贝,且copy返回的对象是不可变对象。
2、集合对象的copy与mutableCopy
2.1 不可变对象NSArray
- (void) mutableNSArrayTest
{
NSArray *arry1 = [[NSArray alloc] initWithObjects:@"value1",@"value2",nil];
NSArray *arry2 = [arry1 copy];
NSArray *arry3 = [arry1 mutableCopy];
NSLog(@"arry1:%p - %@ \r\n",arry1,arry1);
NSLog(@"arry2:%p - %@ \r\n",arry2,arry2);
NSLog(@"arry3:%p - %@ \r\n",arry3,arry3);
}
打印结果:
2017-07-2018:33:53.707beck.wang[1502:194476] arry1:0x60800003b480- (
value1,
value2
) 2017-07-2018:33:53.708beck.wang[1502:194476] arry2:0x60800003b480- (
value1,
value2
) 2017-07-2018:33:53.708beck.wang[1502:194476] arry3:0x60800004cd20- (
value1,
value2
)
分析:arry1、arry2 地址一样,arr3 地址不一样,NSArray的copy是浅拷贝,且copy返回的对象是不可变对象;mutableCopy是深拷贝。
2.2 可变对象NSMutableArray
- (void) NSMutableArrayTest
{
NSMutableArray *marry1 = [[NSMutableArray alloc] initWithObjects:@"value1",@"value2",nil];
NSMutableArray *marry2 = [marry1 copy];
//copy返回的是不可变对象,marry2不能被修改,因此会崩溃
//[marry2 addObject:@"value3"];
NSMutableArray *marry3 = [marry1 mutableCopy];
NSLog(@"marry1:%p - %@ \r\n",marry1,marry1);
NSLog(@"marry2:%p - %@ \r\n",marry2,marry2);
NSLog(@"marry3:%p - %@ \r\n",marry3,marry3);
}
打印结果:
2017-07-2018:55:43.243beck.wang[1577:204641] marry1:0x600000048d60- (
value1,
value2
) 2017-07-2018:55:43.244beck.wang[1577:204641] marry2:0x600000026000- (
value1,
value2
) 2017-07-2018:55:43.244beck.wang[1577:204641] marry3:0x6000000494b0- (
value1,
value2
)
分析:marry1、marry2、marr3 地址都不一样,NSMutableArray对象copy与mutableCopy都是深拷贝,且copy返回的对象是不可变对象。
特别注意的是 :对于集合类的可变对象来说,深拷贝并非严格意义上的深复制,只能算是 单层深复制 ,即虽然新开辟了内存地址,但是存放在内存上的值(也就是数组里的元素仍然之乡员数组元素值,并没有另外复制一份),这就叫做单层深复制。
举例说明:
- (void)singleNSMutableArrayTest
{
NSMutableArray *marry1 = [[NSMutableArray alloc] init];
NSMutableString *mstr1 = [[NSMutableString alloc]initWithString:@"value1"];
NSMutableString *mstr2 = [[NSMutableString alloc]initWithString:@"value2"];
[marry1 addObject:mstr1];
[marry1 addObject:mstr2];
NSMutableArray *marry2 = [marry1 copy];
NSMutableArray *marry3 = [marry1 mutableCopy];
NSLog(@"marry1:%p - %@ \r\n",marry1,marry1);
NSLog(@"marry2:%p - %@ \r\n",marry2,marry2);
NSLog(@"marry3:%p - %@ \r\n",marry3,marry3);
NSLog(@"数组元素地址:value1:%p - value2:%p \r\n",marry1[0],marry1[1]);
NSLog(@"数组元素地址:value1:%p - value2:%p \r\n",marry2[0],marry2[1]);
NSLog(@"数组元素地址:value1:%p - value2:%p \r\n",marry3[0],marry3[1]);
NSLog(@"\r\n------------------修改原值后------------------------\r\n");
[mstr1 appendFormat:@"aaa"];
NSLog(@"marry1:%p - %@ \r\n",marry1,marry1);
NSLog(@"marry2:%p - %@ \r\n",marry2,marry2);
NSLog(@"marry3:%p - %@ \r\n",marry3,marry3);
NSLog(@"数组元素地址:value1:%p - value2:%p \r\n",marry1[0],marry1[1]);
NSLog(@"数组元素地址:value1:%p - value2:%p \r\n",marry2[0],marry2[1]);
NSLog(@"数组元素地址:value1:%p - value2:%p \r\n",marry3[0],marry3[1]);
}
打印结果:
2017-07-2019:48:24.539beck.wang[1750:230132] marry1:0x60800004ae00- (
value1,
value2
) 2017-07-2019:48:24.539beck.wang[1750:230132] marry2:0x608000023f00- (
value1,
value2
) 2017-07-2019:48:24.539beck.wang[1750:230132] marry3:0x60800004abc0- (
value1,
value2
) 2017-07-2019:48:24.540beck.wang[1750:230132] 数组元素地址:value1:0x60800006df40- value2:0x60800006cb402017-07-2019:48:24.540beck.wang[1750:230132] 数组元素地址:value1:0x60800006df40- value2:0x60800006cb402017-07-2019:48:24.540beck.wang[1750:230132] 数组元素地址:value1:0x60800006df40- value2:0x60800006cb402017-07-2019:48:24.540beck.wang[1750:230132] ------------------修改原值后------------------------2017-07-2019:48:24.540beck.wang[1750:230132] marry1:0x60800004ae00- (
value1aaa,
value2
) 2017-07-2019:48:24.540beck.wang[1750:230132] marry2:0x608000023f00- (
value1aaa,
value2
) 2017-07-2019:48:24.540beck.wang[1750:230132] marry3:0x60800004abc0- (
value1aaa,
value2
) 2017-07-2019:48:24.541beck.wang[1750:230132] 数组元素地址:value1:0x60800006df40- value2:0x60800006cb402017-07-2019:48:24.541beck.wang[1750:230132] 数组元素地址:value1:0x60800006df40- value2:0x60800006cb402017-07-2019:48:24.541beck.wang[1750:230132] 数组元素地址:value1:0x60800006df40- value2:0x60800006cb40
分析:在修改原值之前,marry1、marry2、marr3 地址都不一样,很明显copy和mutableCopy都是深拷贝,但是从修改原值后的打印结果来看,这里的深拷贝只是单层深拷贝:新开辟了内存地址,但是数组中的值还是指向原数组的,这样才能在修改原值后,marry2 marr3中的值都修改了。另外,从打印的数组元素地址可以很明显的看出来,修改前后marry1、marry、marr3的数组元素地址都是一模一样的,更加佐证了这一点。
2.3 思维扩展:集合对象的完全深拷贝
2.2中提到了集合类的对象来说,深拷贝只是单层深拷贝,那有没有办法实现每一层都深拷贝呢?回答是肯定的,目前我们可以这么做:
(1)归档解档大法
- (void) deplyFullCopy
{
NSMutableArray *marry1 = [[NSMutableArray alloc] init];
NSMutableString *mstr1 = [[NSMutableString alloc]initWithString:@"value1"];
NSMutableString *mstr2 = [[NSMutableString alloc]initWithString:@"value2"];
[marry1 addObject:mstr1];
[marry1 addObject:mstr2];
NSData *data = [NSKeyedArchiver archivedDataWithRootObject:marry1];
NSArray *marray2 = [NSKeyedUnarchiver unarchiveTopLevelObjectWithData:data error:nil];
NSLog(@"marry1:%p - %@ \r\n",marry1,marry1);
NSLog(@"marry2:%p - %@ \r\n",marray2,marray2);
NSLog(@"数组元素地址:value1:%p - value2:%p \r\n",marry1[0],marry1[1]);
NSLog(@"数组元素地址:value1:%p - value2:%p \r\n",marray2[0],marray2[1]);
}
打印结果:
2017-07-2020:04:38.726beck.wang[1833:242158] marry1:0x600000048a00- (
value1,
value2
) 2017-07-2020:04:38.726beck.wang[1833:242158] marry2:0x600000049780- (
value1,
value2
) 2017-07-2020:04:38.726beck.wang[1833:242158] 数组元素地址:value1:0x600000066300- value2:0x6000000670002017-07-2020:04:38.726beck.wang[1833:242158] 数组元素地址:value1:0x600000066740- value2:0x600000066f40
分析:我们可以看到,开辟了新的内存地址的同时,数组元素的指针地址也不同了,实现了完全的深拷贝。
(2)- (instancetype)initWithArray:(NSArray<ObjectType> *)array copyItems:(BOOL)flag;
- (void) deplyFullCopy2
{
NSMutableArray *marry1 = [[NSMutableArray alloc] init];
NSMutableString *mstr1 = [[NSMutableString alloc]initWithString:@"value1"];
NSMutableString *mstr2 = [[NSMutableString alloc]initWithString:@"value2"];
[marry1 addObject:mstr1];
[marry1 addObject:mstr2];
NSArray *marray2 = [[NSArray alloc] initWithArray:marry1 copyItems:YES];
NSLog(@"marry1:%p - %@ \r\n",marry1,marry1);
NSLog(@"marry2:%p - %@ \r\n",marray2,marray2);
NSLog(@"数组元素地址:value1:%p - value2:%p \r\n",marry1[0],marry1[1]);
NSLog(@"数组元素地址:value1:%p - value2:%p \r\n",marray2[0],marray2[1]);
}
打印结果:
2017-07-2020:08:04.201beck.wang[1868:246161] marry1:0x610000050320- (
value1,
value2
) 2017-07-2020:08:04.202beck.wang[1868:246161] marry2:0x6100002214c0- (
value1,
value2
) 2017-07-2020:08:04.202beck.wang[1868:246161] 数组元素地址:value1:0x610000265600- value2:0x6100002664002017-07-2020:08:04.202beck.wang[1868:246161] 数组元素地址:value1:0xa003165756c61766- value2:0xa003265756c61766
分析:同上。
三、准则
No1:可变对象的copy和mutableCopy方法都是深拷贝(区别完全深拷贝与单层深拷贝) 。
No2:不可变对象的copy方法是浅拷贝,mutableCopy方法是深拷贝。
No3:copy方法返回的对象都是不可变对象。
万语千言汇成一张图
python3ide下载安卓
在Python中对象的赋值(=)其实就是对象的引用。即:当创建一个对象,把它赋值给另一个变量时,python并没有拷贝这个对象,只是拷贝了这个对象的引用而已。
Python中对象的拷贝分为:浅拷贝(copy)和深拷贝(deepcopy)。
浅拷贝:拷贝了最外围的对象本身,内部的元素都只是拷贝了一个引用而已。也就是,将原对象在内存中引用地址拷贝过来,然后让新的对象指向这个地址。可以使用“=”或列表自带的copy()函数(如list.copy()),或使用copy模块的copy()函数。
深拷贝:外围和内部元素都进行了拷贝对象本身,而不是引用。即把对象复制一遍,并且该对象中引用的其他对象也同时复制,完全得到一个新的一模一样的对象,对新对象里的值进行修改不会影响原有对象,新对象和原对象完全分离开。深拷贝只能使用copy模块中deepcopy()函数,使用前要导入:from copy import deepcopy。
Python中对象分为不可变对象 、可变对象。
不可变对象:一旦创建就不可修改的对象,例如:字符串、元组、数字
可变对象:可以修改的对象,例如:列表、字典。
其中Python中的切片可以应用于:列表、元组、字符串,但不能应用于字典。
而深浅拷贝,可应用于序列(列表、元组、字符串),也可应用于字典。
其中不可变对象,不管是深拷贝还是浅拷贝,地址值在拷贝后的值都是一样的。
以下以元组(不可变类型)为例
从上述示例可以看出:
不可变对象类型,没有被拷贝的说法,即便是用深拷贝,查看id的话也是一样的,如果对其重新赋值,也只是新创建一个对象,替换掉旧的而已。
所以不可变类型,不管是深拷贝还是浅拷贝,地址值和拷贝后的值都是一样的。
以下以列表(可变类型)为例
第一种方法:使用=号浅拷贝
输出结果:
第二种方法:使用copy浅拷贝
输出结果:
第三种方法:使用deepcopy深拷贝
输出结果:
从上述示例可以看出:
=浅拷贝:值相等,地址相等
copy浅拷贝:值相等,地址不相等
deepcopy深拷贝:值相等,地址不相等
总结:
1,深浅拷贝都是对源对象的复制,占用不同的内存空间。
2,不可变类型的对象,对于深浅拷贝毫无影响,最终的地址值和值都是相等的。
3,可变类型的对象,使用=浅拷贝时, 值相等,地址相等,对新对象里的值进行修改同时会影响原有对象;使用copy浅拷贝时值相等,地址不相等;使用deepcopy深拷贝时值相等,地址不相等。可以看出针对可变类型copy浅拷贝和deepcopy深拷贝,对新对象里的值进行修改不会影响原有对象。
深拷贝和浅拷贝如何实现
最近的学习中,仔细研究了下深拷贝和浅拷贝,下面就来简单的总结下。
首先我们了解下两种 数据类型 :
1、基本类型:像Number、String、Boolean等这种为基本类型
2、复杂类型:Object和Array
接着我们分别来了解下浅拷贝和深拷贝,深拷贝和浅拷贝是只针对Object和Array这样的复杂类型的。
浅拷贝 :
可以看出,对于对象或数组类型,当我们将a赋值给b,然后更改b中的属性,a也会随着变化。也就是说a和b指向了同一块内存,所以修改其中任意的值,另一个值都会随之变化,这就是浅拷贝。
深拷贝 :
刚刚我们了解了什么是浅拷贝,那么相应的,如果给b放到新的内存中,将a的各个属性都复制到新内存里,就是深拷贝。
也就是说,当b中的属性有变化的时候,a内的属性不会发生变化。
那么除了上面简单的赋值引用,还有哪些方法使用了 浅拷贝 呢?
Object.assign()
在MDN上介绍Object.assign():”Object.assign() 方法用于将所有可枚举的属性的值从一个或多个源对象复制到目标对象。它将返回目标对象。”
复制一个对象
可以看到,Object.assign()拷贝的只是属性值,假如源对象的属性值是一个指向对象的引用,它也只拷贝那个引用值。所以Object.assign()只能用于浅拷贝或是合并对象。这是Object.assign()值得注意的地方。
那么下面我们就来说说复杂的 深拷贝 。
jQuery.extend()
说到深拷贝,第一想到的就是jQuery.extend()方法,下面我们简单看下jQuery.extend()的使用。
jQuery.extend( [deep ], target, object1 [, objectN ] ),其中deep为Boolean类型,如果是true,则进行深拷贝。
我们还是用上面的数据来看下extend()方法。
通过上面的对比可以看出,当使用extend()进行深拷贝的时候,对象的所有属性都添加到target中了。
我们知道了extend()可以进行深拷贝,那么extend()是如何实现深拷贝的呢?
先来看下jQuery.extend()源码
主要看下关于深拷贝的部分,取第一个参数,如果是boolean类型的,就赋值给deep,下面如果deep为true(也就是进行深拷贝),就递归调用extend(),这样就将对象的所有属性都添加到了target中实现了深拷贝。
JSON.parse()和JSON.stringify()
上面的jQuery源码是否让你眼花缭乱?有没有什么办法无脑实现深拷贝呢?JSON.parse()和JSON.stringify()给了我们一个基本的解决办法。
可以看到改变targetCopy并没有改变原始的target,继承的属性也没有丢失,因此实现了基本的深拷贝。
但是用JSON.parse()和JSON.stringify()会有一个问题。
JSON.parse()和JSON.stringify()能正确处理的对象只有Number、String、Array等能够被json表示的数据结构,因此函数这种不能被json表示的类型将不能被正确处理。
上面的例子可以看出,hello这个属性由于是函数类型,使用JSON.parse()和JSON.stringify()后丢失了。
因此JSON.parse()和JSON.stringify()还是需要谨慎使用。
以上就是关于深拷贝和浅拷贝的方法 ,深拷贝与浅拷贝的实现一的全部内容,以及深拷贝和浅拷贝的方法 的相关内容,希望能够帮到您。