精华内容
下载资源
问答
  • 1、浅拷贝 2、深拷贝 二、实现方式 1、浅拷贝的实现方式 1.1 Object.assign(target,source)方法 1.2 Array.prototype.concat()方法 1.3 Array.prototype.slice(start,end)方法 2、深拷贝的实现方式 2.1 JSON.parse...
  • js中的浅拷贝和深拷贝,只是针对复杂数据类型(Objcet,Array)的复制问题。简单来讲浅拷贝和深拷贝都可以实现在原有对象的基础上再生成一份的作用。但是根据新生成的对象能否影响到原对象可以分为浅拷贝和深拷贝。 ...
  • 深拷贝和浅拷贝

    2021-01-08 16:38:10
    深拷贝和浅拷贝,也叫做层次复制和浅层次复制 如对数组或者对象进行拷贝: 浅拷贝原理:只是将数组的内存地址复制给另一个变量,实际还是同一个内存地址空间,对任何一个变量修改元素,都是在修改同一个内存地址...
  • C++之深拷贝和浅拷贝

    2015-09-09 19:06:07
    通过简短的代码和图片来说明C++中深拷贝和浅拷贝的区别和概念。
  • 面试题:深拷贝和浅拷贝(超级详细,有内存图)

    万次阅读 多人点赞 2019-08-07 13:07:34
    深拷贝和浅拷贝是经常在面试中会出现的,主要考察你对基本类型和引用类型的理解深度。我在无数次的面试中,应聘者还没有一个人能把这个问题回答情况,包括很多机构的培训老师。这篇文章会让你把基本类型和引用类型...

    这篇文章竟然写了一上午,亲,请怀着感恩的心阅读!!

     

           深拷贝和浅拷贝是经常在面试中会出现的,主要考察你对基本类型和引用类型的理解深度。我在无数次的面试中,应聘者还没有一个人能把这个问题回答情况,包括很多机构的培训老师。这篇文章会让你把基本类型和引用类型的区别搞得清清楚楚,搞清楚这两者的区别,你对任何编程语言的都不怕,因为,这不是js一门语言,是任何编程语言中都需要掌握的知识,而且,在任何编程语言中,两者都是一样的。

     

    深拷贝和浅拷贝主要是针对对象的属性是对象(引用类型)

    一、基本类型和引用类型的区别

    1、先了解内存

       任何编程语言的内存分区几乎都是一样的

     

           内存是存储数据的,不同类型的数据要存储在不同的区域,即分类存放,不同的区域作用和功能也不一样。就像你家里的衣柜一样,也分了不同的区域:如挂西装的区域,放袜子的区域等等,我相信每个人都会把这两个东西放在不同的区域。要不然,当你西装革履地参加一个高档的宴会,手塞在裤兜里,掏出来一只臭袜子,是不是很尴尬!!!哈哈!!!

     

    以下为内存的分区图。内存分为四个区域:栈区(堆栈),堆区,全局静态区,只读区(常量区和代码区)。

     

    https://blog.csdn.net/jiang7701037/article/details/98728249

     

        2、基本类型和引用类型在内存上存储的区别

    现在只看栈区和堆区,不管其它区域,也假定只是局部变量。

     

    以上函数testf在调用时,

           1)、 定义局部变量 age,由于age是局部变量,所以在栈中申请内存空间,起名为age,又由于给age赋的值250是基本类型,所以,值直接存储在栈中。

           2)、定义局部变量arr,由于arr是局部变量,所以在栈中申请空间,但是arr的内存中存储的是什么?由于给arr赋的值不是基本类型,而是引用类型(new出来的),所以,先在堆中申请空间存放数据 12,23,34,。再把堆区的地址赋给arr。

     

    3、到底什么是基本类型和引用类型

          1)、基本类型:就是值类型,即在变量所对应的内存区域存储的是值,如:上面的age变量所对应的内存存储的就是值250.

          2)、引用类型:就是地址类型。

       何为地址:地址就是编号,要地址何用,就是为了容易找到。每个人的家里为什么要有一个唯一的地址,就是在邮寄时,能够找到你家。

    比如:我们最早的超市存包的格子,每个格子都有个编号,你存包时,服务员会把你的东西放在某个格子里,再把这个格子的编号给你(一个牌子)。你购物完毕取包时,直接给服务员你的牌子(有编号),服务员根据你的编号就会找到你的包。这个编号就是格子的地址。内存也是一样的,每个内存都有一个编号,方便cpu查找。要不然,浩瀚的内存海洋,cpu要找到数据靠啥找。

    以上的变量arr就是引用类型,arr所对应的内存中存储着地址,真正的数据是在地址对应的内存区域里,就像,你填写简历时,会在简历的那张纸上写上你家的地址。简历上写你家地址的地方就相当于arr。而你家是根据这个地址可以找到的。简历上写你家地址的地方就相当于引用着你家(可以想象一根无形的线牵引着你家,在简历上的这根无形的线,顺藤摸瓜就能找到你家)。所以叫做引用类型。

       二、基本类型和引用类型在赋值时内存的变化

    你可以认为,赋值就是在拷贝。

    1、基本类型:

    2、引用类型:

     

    如果给arr[0]赋值的话,arr1[0]的值也会发生变化,因为,arr和arr1保存着相同的地址,它门两个引用的数据是共享的。就像你在很多地方(简历的那张纸,户口本上的那张纸)会写上你的家庭地址。这么多张纸都引用着你家。根据一张纸上找到你家,给你家放上一百万的现金(数据改变了,相当于arr[0]=10),再根据另外一张纸的地址也找到了你家,你发现你一百万在(不要给我说被人拿了)

     

    如果在上面的基础上增加一句代码:arr[0]=10;那么内存将会有如下变化:

    ​​

    三、基本类型和引用类型作为函数参数的区别(这个可以不看)

    1、基本类型作为函数的参数

    2、引用类型作为函数的参数:

    四、深拷贝和浅拷贝:

       终于说到了深拷贝和浅拷贝。

    其实在第二点已经说到了拷贝,所谓拷贝,就是赋值。把一个变量赋给另外一个变量,就是把变量的内容进行拷贝。把一个对象的值赋给另外一个对象,就是把一个对象拷贝一份。

    1、基本类没有问题,

    因为,基本类型赋值时,赋的是数据(所以,不存在深拷贝和浅拷贝的问题)。

           如:

        Var x = 100;

        Var y = x; //此时x和y都是100;

       如果要改变y的值,x的值不会改变。

     

    2、引用类型有问题

      因为,引用类型赋值时,赋的值地址(就是引用类型变量在内存中保存的内容),强烈建议把前面的第二点(基本类型和引用类型在赋值时内存的变化)多看几遍,以保证理解深刻。这样,一劳永逸,以后在碰到任何跟引用类型有关的话题(如:继承时,父类的属性是引用类型)都没有问题。

          如:

    var arr1 = new Array(12,23,34)

    Var arr2 = arr1;//这就是一个最简单的浅拷贝

     

    如果要改变arr2所引用的数据:arr2[0]=100时,那么arr1[0]的值也是100。

            原因就是 arr1和arr2引用了同一块内存区域(以上的第二点中有体现)。

            

    这是最简单的浅拷贝,因为,只是把arr1的地址拷贝的一份给了arr2,并没有把arr1的数据拷贝一份。所以,拷贝的深度不够

             

    3、用json对象的方式(也是引用类型)来演示浅拷贝和深拷贝

       

    1)、定义一个json对象(对象的属性也是对象)

    var p = {
    	"id":"007",
    	"name":"刘德华",
    	"books":new Array("三国演义","红楼梦","水浒传")//这是引用类型
    }

     

    内存图:

     

    2)、把该对象p进行复制一份

    • (一)浅拷贝
    var p2 = {};
    for(let key in p){
    	p2[key] = p[key];	
    }
    p2.books[0] ="四国";
    console.log(p2);
    console.log(p);

    在控制台中打印的结果(p和p2的books[0]都变成了“四国”):

    内存:

     

    • (二)深拷贝(初步)
    var p2 = {};
    for(let key in p){
    	if(typeof p[key]=='object'){
    		p2[key]=[];//因为,我上面写的是数组,所以,暂时赋值一个空数组.
    		for(let i in p[key]){
    			p2[key][i] = p[key][i]
    		}
    	}else{
    		p2[key] = p[key];
    	}
    }
    p2.books[0] ="四国";
    console.log(p2);
    console.log(p);

    在控制台中打印的结果(只有p2的books[0]变成了“四国”)

    内存:

     

      (三)深拷贝(最终)

    3.1、深拷贝_如果属性都是json对象,那么用递归的方式

     

    //如果对象的属性是对象(引用类型),属性的属性也是引用类型,即层层嵌套很多.怎么办,只能递归

    //如下对象,要复制:

    var p = {
    	"id":"007",
    	"name":"刘德华",
    	"wife":{
    		"id":"008",
    		"name":"刘德的妻子",
    		"address":{
    			"city":"北京",
    			"area":"海淀区"
    		}
    	}
    }
    
    //写函数
    function copyObj(obj){
    	let newObj={};
    	for(let key in obj){
    		if(typeof obj[key] =='object'){//如:key是wife,引用类型,那就递归
    			newObj[key] = copyObj(obj[key])
    		}else{//基本类型,直接赋值
    			newObj[key] = obj[key];
    		}
    	}
    	return newObj;
    }
    
    let pNew = copyObj(p);
    pNew.wife.name="张三疯";
    pNew.wife.address.city = "香港";
    console.log(pNew);
    console.log(p);

     

    3.2、深拷贝_如果属性是数组等非键值对的对象

          就得单独处理:要么给数组增加一个自我复制的函数(建议这样做),要么单独判断。

    //给数组对象增加一个方法,用来复制自己
    Array.prototype.copyself = function(){
    	let arr = new Array();
    	for(let i in this){
    		arr[i]  = this[i]
    	}
    	return arr;
    }
    
    var p = {
    	"id":"007",
    	"name":"刘德华",
    	"books":new Array("三国演义","红楼梦","水浒传")//这是引用类型
    }
    
    function copyObj(obj){
    	let newObj={};
    	for(let key in obj){
    		if(typeof obj[key] =='object'){//如:key是wife,引用类型,那就递归
    			newObj[key] = obj[key].copyself();
    		}else{//基本类型,直接赋值
    			newObj[key] = obj[key];
    		}
    	}
    	return newObj;
    }
    
    var pNew = copyObj(p);
    pNew.books[0] = "四国";
    console.log(pNew);
    console.log(p);  

    这篇文章竟然写了一上午,亲,请怀着感恩的心阅读

    展开全文
  • 主要介绍了Java中的深拷贝(深复制)和浅拷贝(浅复制)介绍,需要的朋友可以参考下
  • 拷贝和浅拷贝一、如何区分深拷贝和浅拷贝二、举例加深理解深拷贝和浅拷贝三、图文理解四、哪些方法是浅拷贝,如何进行深拷贝 一、如何区分深拷贝和浅拷贝 内在的区别:浅拷贝就是简单的把指向别人的值的一个指针...

    一、如何区分深拷贝和浅拷贝

    • 内在的区别:浅拷贝就是简单的把指向别人的值的一个指针给复制过来,深拷贝就是实实在在的把别人的值给复制过来。
    • 直接显示出来的区别:浅拷贝就是双方不是独立的,还会互相影响;深拷贝是不会影响到彼此,是独立的个体。

    深拷贝与浅拷贝的存在主要还是受拷贝的数据类型所影响的。当拷贝的是js基本数据类型时,都会是深拷贝;如果拷贝的是js引用数据类型时,简单的赋值过来的时候就是浅拷贝,需要做一些特殊处理让它变成深拷贝。

    如果不理解上面所说的就需要先好好理解下什么是基本数据类型,什么是引用数据类型,可以先看看下面这篇博客https://blog.csdn.net/Sunday97/article/details/84869727

    二、举例加深理解深拷贝和浅拷贝

    首先了解下js的数据类型:

    • js的六大数据类型:Number, String, Boolean, Undefined , Null , Object
    • 基本数据类型:Number,String,Boolean,Undefined, Null
    • 引用数据类型:Object , Array, Function
    //当拷贝的是基本数据类型时
    var a = 1;
    var b = a;
    a = 2;
    console.log(a,b);//2 1
    
    //当拷贝的是引用数据类型时
    var a = [1,2,3];
    var b = a;
    a[0] = 2;
    console.log(a,b);//[2,2,3] [2,2,3]
    

    三、图文理解

    基本类型的值存储在栈内存中,引用类型的值存储在堆内存中。
    如果不理解栈内存和堆内存,可以先看下面这篇文章:
    https://blog.csdn.net/Sunday97/article/details/108485921

    • 当b拷贝a,a是基本类型的值时,给a与b分配的是独立的空间,互不影响

    在这里插入图片描述

    • 当b拷贝a,a是引用类型的值时,b拷贝过来的是一个指针,这个指针指向a的值。当改变a的值时,改变的是堆内存中的值,栈内存中的指针指向并没有改变,都指向的是同一个值,所以改变某个变量的值时,对另一个复制了它的变量也会产生影响。
      在这里插入图片描述

    四、哪些方法是浅拷贝,如何进行深拷贝

    1、浅拷贝

    浅拷贝可以简单理解为,发生在栈中的拷贝行为,只能拷贝基本值和引用值的地址。

    • ES6 定义了 Object.assign() 方法来实现浅拷贝。
    	let a = {
    	    name:"huangQian",
    	    like:{
    	       fruit:"apple",
    	       color:"white"
    	    }
    	}
    	let b = Object.assign({},a);
    	console.log(a,b)
    

    在这里插入图片描述
    会发现拷贝过来了,a和b一模一样。

    现在对a进行更改,看看b的变化:

    let a = {
    	    name:"huangQian",
    	    like:{
    	       fruit:"apple",
    	       color:"white"
    	    }
    	}
    	let b = Object.assign({},a);
    	a.name = "nicole";
    	a.like.color = "black";
    	console.log(a,b)
    

    在这里插入图片描述
    会发现b中属于基本数据类型的name属性的值没有发生改变,但是属于引用数据类型的like里面的数值发生了和a一样的变化,因为指向了同一个地址。

    • 数组的slice()concat() 方法也属于浅拷贝
    let a = [1,2,[3,4]];
    let b = a.slice(0);
    console.log(a,b);//[1,2,[3,4]]  [1,2,[3,4]]
    
    a[0] = 2;
    a[2][0] = 4;
    console.log(a,b)//[2,2,[4,4]]  [1,2,[4,4]]
    

    2、深拷贝

    深拷贝可以简单理解为,同时发生在栈中和堆中的拷贝行为,除了拷贝基本值和引用值的地址之外,地址指向的堆中的对象也会发生拷贝。

    • JSON.stringify() 可以间接实现深拷贝

    将需要深拷贝的对象序列化为一个 JSON 字符串,然后根据这个字符串解析出一个结构和值完全一样的新对象

    let a = {
    	    name:"huangQian",
    	    like:{
    	       fruit:"apple",
    	       color:"white"
    	    }
    	}
    let b = JSON.parse(JSON.stringify(a));
    console.log(a,b);
    

    在这里插入图片描述

    let a = {
    	    name:"huangQian",
    	    like:{
    	       fruit:"apple",
    	       color:"white"
    	    }
    	}
    let b = JSON.parse(JSON.stringify(a));
    a.name = "nicole";
    a.like.color = "black";
    console.log(a,b);
    

    在这里插入图片描述
    会发现改变a的值,不会对b产生任何影响

    ⚠️这种方法需要保证对象是安全的,例如属性值不能是 undefined、symbol、函数、日期和正则。

    • 使用 $.extend() 方法实现深拷贝

    $.extend() 方法属于 jquery 的方法。这个方法实现深拷贝的基本思路是:如果是基本值或除了对象或数组之外的引用值,直接赋值;如果是对象或数组就需要进行递归,直到递归到基本值或除了对象或数组之外的引用值为止。

    用原生js来表达它的思路就可以写成如下代码:

    function deepCopy(originObj) {
        var resultObj = Array.isArray(originObj)?[]:{};
        for(var key in originObj) {
           var isObj = Object.prototype.toString.call(originObj[key]) ===[object Object];//是否是对象
           if(isObj || Array.isArray(originObj[key])) //如果是对象或者数组,再走一遍函数
           {
               deepCopy(originObj[key]);
           } else {
               resultObj[key] = originObj[key]
           }
        }
        return resultObj;
    }
    
    展开全文
  • 主要介绍了java中的深拷贝和浅拷贝(clone()方法的重写、使用序列化实现真正的深拷贝),文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Java深入理解深拷贝和浅拷贝区别

    万次阅读 多人点赞 2019-02-13 23:31:47
    一、拷贝的引入 (1)、引用拷贝 创建一个指向对象的引用变量的拷贝。 Teacher teacher = new Teacher("Taylor",26); Teacher otherteacher = teacher; System.out.println(teacher); System.out.println...

    欢迎大家关注我的公众号【老周聊架构】,Java后端主流技术栈的原理、源码分析、架构以及各种互联网高并发、高性能、高可用的解决方案。

    一、拷贝的引入

    (1)、引用拷贝

    创建一个指向对象的引用变量的拷贝。

    public class QuoteCopy {
        public static void main(String[] args) {
            Teacher teacher = new Teacher("riemann", 28);
            Teacher otherTeacher = teacher;
            System.out.println(teacher);
            System.out.println(otherTeacher);
        }
    }
    
    class Teacher {
        private String name;
        private int age;
    
        public Teacher(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    

    输出结果:

    com.test.Teacher@28a418fc
    com.test.Teacher@28a418fc
    

    结果分析:由输出结果可以看出,它们的地址值是相同的,那么它们肯定是同一个对象。teacherotherTeacher只是引用而已,他们都指向了一个相同的对象Teacher(“riemann”,28)。 这就叫做引用拷贝

    在这里插入图片描述

    (2)、对象拷贝

    创建对象本身的一个副本。

    public class ObjectCopy {
        public static void main(String[] args) throws CloneNotSupportedException {
            Teacher teacher = new Teacher("riemann", 28);
            Teacher otherTeacher = (Teacher) teacher.clone();
            System.out.println(teacher);
            System.out.println(otherTeacher);
        }
    }
    
    class Teacher implements Cloneable {
        private String name;
        private int age;
    
        public Teacher(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public Object clone() throws CloneNotSupportedException {
            Object object = super.clone();
            return object;
        }
    }
    

    输出结果:

    com.test.Teacher@28a418fc
    com.test.Teacher@5305068a
    

    结果分析:由输出结果可以看出,它们的地址是不同的,也就是说创建了新的对象, 而不是把原对象的地址赋给了一个新的引用变量,这就叫做对象拷贝。

    在这里插入图片描述

    注:深拷贝和浅拷贝都是对象拷贝

    二、浅拷贝

    (1)、定义

    被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象。即对象的浅拷贝会对“主”对象进行拷贝,但不会复制主对象里面的对象。”里面的对象“会在原来的对象和它的副本之间共享。

    简而言之,浅拷贝仅仅复制所考虑的对象,而不复制它所引用的对象。

    (2)、浅拷贝实例

    public class ShallowCopy {
        public static void main(String[] args) throws CloneNotSupportedException {
            Teacher teacher = new Teacher();
            teacher.setName("riemann");
            teacher.setAge(28);
    
            Student student1 = new Student();
            student1.setName("edgar");
            student1.setAge(18);
            student1.setTeacher(teacher);
    
            Student student2 = (Student) student1.clone();
            System.out.println("-------------拷贝后-------------");
            System.out.println(student2.getName());
            System.out.println(student2.getAge());
            System.out.println(student2.getTeacher().getName());
            System.out.println(student2.getTeacher().getAge());
    
            System.out.println("-------------修改老师的信息后-------------");
            // 修改老师的信息
            teacher.setName("jack");
            System.out.println("student1的teacher为: " + student1.getTeacher().getName());
            System.out.println("student2的teacher为: " + student2.getTeacher().getName());
    
        }
    }
    
    class Teacher implements Cloneable {
        private String name;
        private int age;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    
    class Student implements Cloneable {
        private String name;
        private int age;
        private Teacher teacher;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public Teacher getTeacher() {
            return teacher;
        }
    
        public void setTeacher(Teacher teacher) {
            this.teacher = teacher;
        }
    
        public Object clone() throws CloneNotSupportedException {
            Object object = super.clone();
            return object;
        }
    }
    

    输出结果:

    -------------拷贝后-------------
    edgar
    18
    riemann
    28
    -------------修改老师的信息后-------------
    student1的teacher为: jack
    student2的teacher为: jack
    

    结果分析: 两个引用student1student2指向不同的两个对象,但是两个引用student1student2中的两个teacher引用指向的是同一个对象,所以说明是浅拷贝

    在这里插入图片描述

    三、深拷贝

    (1)、定义

    深拷贝是一个整个独立的对象拷贝,深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。

    简而言之,深拷贝把要复制的对象所引用的对象都复制了一遍。

    (2)、深拷贝实例

    public class DeepCopy {
        public static void main(String[] args) throws CloneNotSupportedException {
            Teacher teacher = new Teacher();
            teacher.setName("riemann");
            teacher.setAge(28);
    
            Student student1 = new Student();
            student1.setName("edgar");
            student1.setAge(18);
            student1.setTeacher(teacher);
    
            Student student2 = (Student) student1.clone();
            System.out.println("-------------拷贝后-------------");
            System.out.println(student2.getName());
            System.out.println(student2.getAge());
            System.out.println(student2.getTeacher().getName());
            System.out.println(student2.getTeacher().getAge());
    
            System.out.println("-------------修改老师的信息后-------------");
            // 修改老师的信息
            teacher.setName("jack");
            System.out.println("student1的teacher为: " + student1.getTeacher().getName());
            System.out.println("student2的teacher为: " + student2.getTeacher().getName());
        }
    }
    
    class Teacher implements Cloneable {
        private String name;
        private int age;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }
    
    class Student implements Cloneable {
        private String name;
        private int age;
        private Teacher teacher;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public Teacher getTeacher() {
            return teacher;
        }
    
        public void setTeacher(Teacher teacher) {
            this.teacher = teacher;
        }
    
        public Object clone() throws CloneNotSupportedException {
            // 浅复制时:
            // Object object = super.clone();
            // return object;
    
            // 改为深复制:
            Student student = (Student) super.clone();
            // 本来是浅复制,现在将Teacher对象复制一份并重新set进来
            student.setTeacher((Teacher) student.getTeacher().clone());
            return student;
    
        }
    }
    

    输出结果:

    -------------拷贝后-------------
    edgar
    18
    riemann
    28
    -------------修改老师的信息后-------------
    student1的teacher为: jack
    student2的teacher为: riemann
    

    结果分析:
    两个引用student1student2指向不同的两个对象,两个引用student1student2中的两个teacher引用指向的是两个对象,但对teacher对象的修改只能影响student1对象,所以说是深拷贝

    在这里插入图片描述

    展开全文
  • 浅谈深拷贝和浅拷贝

    千次阅读 2020-12-30 10:05:20
    深拷贝和浅拷贝说起深拷贝和浅拷贝,首先我们来看两个栗子// 栗子1var a = 1,b=a;console.log(a);console.log(b)b = 2;console.log(a);console.log(b)// 栗子2var obj1 = {x: 1, y: 2}, obj2 = obj1;console.log(obj...

    深拷贝和浅拷贝

    说起深拷贝和浅拷贝,首先我们来看两个栗子

    // 栗子1

    var a = 1,b=a;

    console.log(a);

    console.log(b)

    b = 2;

    console.log(a);

    console.log(b)

    // 栗子2

    var obj1 = {x: 1, y: 2}, obj2 = obj1;

    console.log(obj1) //{x: 1, y: 2}

    console.log(obj2) //{x: 1, y: 2}

    obj2.x = 2; //修改obj2.x

    console.log(obj1) //{x: 2, y: 2}

    console.log(obj2) //{x: 2, y: 2}

    按照惯性思维,栗子1中obj1应该跟a一样,不会因另外一个值的改变而改变的啊,而这里却是obj1跟着obj2的改变而改变了?同样都是变量,怎么就表现不一样了呢?难道存在等级上的优劣?此处需要沉思一小会。要解决这个问题,就要引入一个JS中基本类型和引用类型的概念了。

    基本类型和引用类型

    ECMAScript变量包含两种不同数据类型的值:基本类型值和引用类型值。基本类型值指的是那些保存在栈内存中的简单数据段,即这种值完全保存在内存中的一个位置。而引用类型值是指那些保存堆内存中的对象,意思是变量中保存的实际上只是一个指针,这个指针指向内存中的另一个位置,该位置保存对象。

    两类数据的保存方式

    从上图可以看到,栈内存主要用于存

    展开全文
  • 变量-引用-对象(可变对象,不可变对象)-切片-拷贝(浅拷贝深拷贝) 【变量-对象-引用】 在Python中一切都是对象,比如说:3, 3.14, ‘Hello’, [1,2,3,4],{‘a’:1}…… 甚至连type其本身都是对象,type对象 Python...
  • 理解深拷贝和浅拷贝之前需要弄懂一些基础概念,内存中存储的变量类型分为值类型和引用类型。 1、值类型赋值的存储特点, 将变量内的数据全部拷贝一份, 存储给新的变量。 例如:var num = 123 ;var num1=num; 表示...
  • 深拷贝和浅拷贝的区别

    千次阅读 2020-08-27 11:19:12
    拷贝和浅拷贝 值类型 vs 引用类型 赋值 vs 浅拷贝 vs 深拷贝 对象赋值 浅拷贝 深拷贝 浅拷贝代码实现 深拷贝代码实现 深度遍历式拷贝 利用反序列化实现深拷贝拷贝和浅拷贝 浅拷贝(shallowCopy)...
  • 文章目录1、深拷贝浅拷贝概览2、赋值、深拷贝浅拷贝区别3、浅拷贝实现方式3.1 Object.assign()3.2 Array.prototype.concat()3.3 Array.prototype.slice()4、深拷贝实现方式4.1 JSON.parse(JSON.stringify(arr))...
  • 深拷贝和浅拷贝区别是什么?

    万次阅读 多人点赞 2019-06-18 15:44:47
    拷贝和浅拷贝区别是什么? 复制一个 Java 对象 浅拷贝:复制基本类型的属性;引用类型的属性复制,复制栈中的变量 和 变量指向堆内存中的对象的指针,不复制堆内存中的对象。 深拷贝:复制基本类型的属性;...
  • 深拷贝和浅拷贝一些例子
  • 今天小编就为大家分享一篇关于Java Clone深拷贝浅拷贝的两种实现方法,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • iOS深拷贝和浅拷贝

    千次阅读 2018-08-01 16:53:35
    一:概念 浅拷贝:指针拷贝,不会创建一个新的对象。浅拷贝简单点说就是对内存地址的复制,让...深拷贝和浅拷贝的本质是内存地址是否相同 二:各种类型的对象深拷贝浅拷贝 1.非容器类对象(比如像NSString,N...
  • 本文主要介绍了javascript深拷贝和浅拷贝的相关知识。具有很好的参考价值,下面跟着小编一起来看下吧
  • JS深拷贝和浅拷贝

    千次阅读 2021-01-21 23:01:40
    浅拷贝只是拷贝一层,更深层次对象级别的只拷贝引用。 浅拷贝是拷贝的内存地址,使新对象指向拷贝对象的内存地址。深拷贝是重新开辟一块内存空间,用来存放sources对象的值。 浅拷贝可以用for in 来实现,也可用es6...
  • 在.net类库中,对象克隆广泛存在于各种类型的实现中,凡是实现了ICloneable接口的类型都具备克隆其对象实例的能力。所以本文讲述的深拷贝和浅拷贝也是在实现ICloneable接口的基础上进行的
  • 在使用JavaScript对数组进行操作的时候,我们经常需要将数组进行备份,事实证明如果只是简单的将它赋予其他变量,那么我们只要更改其中的任何一个,然后其他的也会跟着改变,这就导致了问题的发生。
  • 深拷贝和浅拷贝的区别及实现方法

    千次阅读 2021-03-09 19:51:33
    简述深拷贝和浅拷贝的区别以及实现方法
  • 浅拷贝: 拷贝父对象,但是不会拷贝对象的内部的子对象。 深拷贝: 拷贝父对象. 以及其内部的子对象 在之前的文章中,提到可变对象不可变对象,接下来也是以这两者的区别进行展开 直接赋值 对于可变对象不可变对象,...
  • 浅拷贝 首先我们使用两种方式来拷贝对象,一种是切片,另外一种是工厂方法。然后使用id函数来看看它们的标示符 复制代码 代码如下: # encoding=UTF-8   obj = [‘name’,[‘age’,18]] a=obj[:] b=list(obj) for x ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 98,887
精华内容 39,554
关键字:

深拷贝和浅拷贝

友情链接: Teigha_Net_4.00_10.rar