精华内容
下载资源
问答
  • 拷贝与深拷贝区别

    2020-11-05 17:59:32
    简单的说就是A复制了B之,后当我们去改变A的时候B也跟着改变了,那么就说明是浅拷贝,如果B没有改变,那么就说明是深拷贝。 栗子???? let A = ['cindy','lily']; A = B; A[0] = 'newcindy'; console.log(B) // ['...

    什么是浅拷贝与深拷贝?

    简单的说就是A复制了B之,后当我们去改变A的时候B也跟着改变了,那么就说明是浅拷贝,如果B没有改变,那么就说明是深拷贝。

    栗子🌰

    let A = ['cindy','lily'];
    A = B;
    A[0] = 'newcindy';
    console.log(B) //  ['newcindy','lily'];
    

    是不是很奇怪?明明是在复制之后改变A的为什么B会跟着变化呢?hhhh继续看下面的解释

    基本数据类型和引用数据类型

    基本数据类型:Number , String , Null , Undefined , Boolean;
    基本类型-----键值存储在栈内存中
    在这里插入图片描述

    当复制基本类型的时候在内存区里面会在栈区开辟一个新的空间
    所以当你此时修改a=2,对b并不会造成影响,因为此时的b已自食其力,翅膀硬了,不受a的影响了。当然,let a=1,b=a;虽然b不受a影响,但这也算不上深拷贝,因为深拷贝本身只针对较为复杂的object类型数据。

    引用数据类型:Array , Objext , Function

    引用数据类型 ---- 键存在栈内存中,值存在于堆内存中,但是栈内存会提供一个引用的地址指向堆内存中的值,我们以上面浅拷贝的例子画个图:

    在这里插入图片描述

    当b=a进行拷贝时,其实复制的是a的引用地址,而并非堆里面的值。
    当我们 **a[0]=1 **时进行数组修改时,由于a与b指向的是同一个地址,所以自然b也受了影响,这就是所谓的浅拷贝了。

    在这里插入图片描述
    在这里插入图片描述

    那,要是在堆内存中也开辟一个新的内存专门为b存放值,就像基本类型那样,岂不就达到深拷贝的效果了
    在这里插入图片描述

    这里就抛出本篇文章的核心问题:如何实现对引用数据类型进行拷贝时希望它开辟新的堆空间,而非引用原地址的堆空间。及所谓的深拷贝。

    5. 深拷贝,是拷贝对象各个层级的属性(占坑)

    举个板栗说明下:

    let a=[1,2,3,4];
    let b=a.slice();
    a[0]=2;
    console.log(b); // [1,2,3,4]
    

    那是不是说 slice 方法也是深拷贝了,毕竟b也没受a的影响,上面说了,深拷贝是会拷贝所有层级的属性,还是这个例子,我们把a 再改改(添加了一个双层数组)

    let a=[0,1,[2,3],4];
    let b=a.slice();
    a[0]=1;
    a[2][0]=1;
    console.log(b);// [0,1,[1,3],4]
    

    拷贝的不彻底啊,b对象的一级属性确实不受影响了,但是二级属性还是没能拷贝成功,仍然脱离不了a的控制,说明slice根本不是真正的深拷贝。

    第一层的属性确实深拷贝,拥有了独立的内存,但更深的属性却仍然公用了地址,所以才会造成上面的问题。

    同理,concat 方法与 slice 也存在这样的情况,他们都不是真正的深拷贝,而是属于浅拷贝,他们其实是披着羊(qian)皮(kao)的(bei)狼。这里需要注意。

    那如何实现真正的深拷贝?继续看下面

    5. 实现深拷贝的几种常见方法

    1 使用递归去复制所有层级属性。

    function deepClone(obj) {
        let objClone = Array.isArray(obj) ? [] : {};
        if (obj && typeof obj === "object") {
            for (key in obj) {
                if (obj.hasOwnProperty(key)) {
                    //判断ojb子元素是否为对象,如果是,递归复制
                    if (obj[key] && typeof obj[key] === "object") {
                        objClone[key] = deepClone(obj[key]);
                    } else {
                        //如果不是,简单复制
                        objClone[key] = obj[key];
                    }
                }
            }
        }
        return objClone;
    }
    // 测试代码
    let a = [1, 2, [1,5], 4],
        b = deepClone(a);
    a[0] = 2;
    a[2][0] = 5;
    console.log(a, b);
    

    借用JSON对象的 parse和stringify

    var a = [1, 2, [1,5], 4];
    var b = JSON.stringify(a);
    b = JSON.parse(b);
    a[0] = 2;
    a[2][0] = 5;
    console.log(a, b);
    

    可以看到,这下b是完全不受a的影响了。这里方法属于投机取巧,但是也确实可以实现深拷贝

    附带说下,JSON.stringify与JSON.parse除了实现深拷贝,还能结合localStorage实现对象数组存储。

    展开全文
  • 用自己的语言描述就是 是不是真正获取了一个对象复制的实体,而不是引用 假设现在有俩个数组A 和B var a = { myname: 'yana' }; var b = a; b.myname = '小雅'; console.log(b.myname); // 小雅 console.log(a.my...

    深拷贝和浅拷贝的区别

    用自己的语言描述就是 是不是真正获取了一个对象复制的实体,而不是引用
    假设现在有俩个数组A 和B

    var a = {
        myname: 'yana'
    };
    var b = a;
    b.myname = '小雅';
    console.log(b.myname);    // 小雅
    console.log(a.myname);    // 小雅
    
    
    var a = ['myname', 'yana'];
    var b = a;
    b[1] = '小雅';
    console.log(a);    // ["myname", "小雅"]
    console.log(b);    // ["myname", "小雅"]

    可以看出,对于对象或者数组类型,我们将a赋值给b,然后更改b中的属性,a也会随着变化,也就是其实这俩指向了同一块内存,所以修改其任意的值,另一个值都会随之变化,这就是浅拷贝。。
    说明浅拷贝,拿人手短

    刚刚我们了解了什么是浅拷贝,那么相应的,如果给b放到新的内存中,将a的各个属性都复制到新的内存中,就是深拷贝,也就是说,当b中的属性变化的时候,a的属性不会发生变化。自食其力。

    转载于:https://www.cnblogs.com/lml-lml/p/9580081.html

    展开全文
  • JavaScript的浅拷贝

    2017-10-30 18:06:31
    注:拷贝简单来说就是对象数据的复制,对象引用的复制不叫拷贝.var o={name:"小陈".age:18}; var p=o;//这不是任何拷贝 在讨论深浅拷贝时,一定要考虑对象的属性是不是引用类型 浅拷贝的代码实现var car={name:"阿斯顿...

    什么是浅拷贝?

    只针对当前对象的属性进行的拷贝叫浅拷贝

    注:拷贝简单来说就是对象数据的复制,对象引用的复制不叫拷贝.

    var o={name:"小陈".age:18};
    var p=o;//这不是任何拷贝

    在讨论深浅拷贝时,一定要考虑对象的属性是不是引用类型

    浅拷贝的代码实现
    var car={name:"奇瑞qq"};
    var student={name:"小陈",age:18,car:car};
    var lightCopy={};
    lightCopy.name=student.name;
    lightCopy.age=student.age;
    lightCopy.car=student.car;

    流程图如下:
    这里写图片描述
    为什么是浅拷贝?

    因为从上图中很容易看出lightCopy.car存放的对象的引用地址和student.car指向的是同一个car对象,即lightCopy和student对象并未完全从内存中独立,他们两者还有牵连,谁修改car对象都会引起另一个对象中的car对象发生变化,所以是浅拷贝

    进一步升级代码
    • 利用面向对象的思想,让对象有一个shallowCopy方法,完成浅拷贝
    var car={name:"奇瑞qq"};
    var p={
        name:"小陈";
        age:18;
        sex:"男";
        car:car;
        shallowCopy:function(){
            var temp={};
            for(var k in this){
                temp[k]=this[k];
            }
            return temp;
        }
    }
    var copyStudent=p.shallowCopy();

    好了,是时候看看啥是深拷贝了,点此传送什么深拷贝

    展开全文
  • Java语言的一个优点就是取消了指针的概念,但也导致了许多程序员在编程中常常忽略了对象与引用的区别,本文会试图澄清这一概念。并且由于Java不能通过简单的赋值来解决对象复制的问题,在开发过程中,也常常要要应用...
      Java语言的一个优点就是取消了指针的概念,但也导致了许多程序员在编程中常常忽略了对象与引用的区别,本文会试图澄清这一概念。并且由于Java不能通过简单的赋值来解决对象复制的问题,在开发过程中,也常常要要应用clone()方法来复制对象。本文会让你了解什么是影子clone与深度clone,认识它们的区别、优点及缺点。 

          看到这个标题,是不是有点困惑:Java语言明确说明取消了指针,因为指针往往是在带来方便的同时也是导致代码不安全的根源,同时也会使程序的变得非常复杂难以理解,滥用指针写成的代码不亚于使用早已臭名昭著的"GOTO"语句。Java放弃指针的概念绝对是极其明智的。但这只是在Java语言中没有明确的指针定义,实质上每一个new语句返回的都是一个指针的引用,只不过在大多时候Java中不用关心如何操作这个"指针",更不用象在操作C++的指针那样胆战心惊。唯一要多多关心的是在给函数传递对象的时候。

    1. package com.zoer.src;  
    2.   
    3. public class ObjRef {  
    4.     Obj aObj = new Obj();  
    5.     int aInt = 11;  
    6.   
    7.     public void changeObj(Obj inObj) {  
    8.         inObj.str = "changed value";  
    9.     }  
    10.   
    11.     public void changePri(int inInt) {  
    12.         inInt = 22;  
    13.     }  
    14.   
    15.     public static void main(String[] args) {  
    16.         ObjRef oRef = new ObjRef();  
    17.   
    18.         System.out.println("Before call changeObj() method: " + oRef.aObj);  
    19.         oRef.changeObj(oRef.aObj);  
    20.         System.out.println("After call changeObj() method: " + oRef.aObj);  
    21.   
    22.         System.out.println("==================Print Primtive=================");  
    23.         System.out.println("Before call changePri() method: " + oRef.aInt);  
    24.         oRef.changePri(oRef.aInt);  
    25.         System.out.println("After call changePri() method: " + oRef.aInt);  
    26.   
    27.     }  
    28. }  
    1. package com.zoer.src;  
    2.   
    3. public class Obj {  
    4.   
    5.     String str = "init value";  
    6.   
    7.     public String toString() {  
    8.         return str;  
    9.     }  
    10. }  
          这段代码的主要部分调用了两个很相近的方法,changeObj()和changePri()。唯一不同的是它们一个把对象作为输入参数,另一个把Java中的基本类型int作为输入参数。并且在这两个函数体内部都对输入的参数进行了改动。看似一样的方法,程序输出的结果却不太一样。changeObj()方法真正的把输入的参数改变了,而changePri()方法对输入的参数没有任何的改变。 

          从这个例子知道Java对对象和基本的数据类型的处理是不一样的。和C语言一样,当把Java的基本数据类型(如int,char,double等)作为入口参数传给函数体的时候,传入的参数在函数体内部变成了局部变量,这个局部变量是输入参数的一个拷贝,所有的函数体内部的操作都是针对这个拷贝的操作,函数执行结束后,这个局部变量也就完成了它的使命,它影响不到作为输入参数的变量。这种方式的参数传递被称为"值传递"。而在Java中用对象作为入口参数的传递则缺省为"引用传递"也就是说仅仅传递了对象的一个"引用"这个"引用"的概念同C语言中的指针引用是一样的。当函数体内部对输入变量改变时,实质上就是在对这个对象的直接操作。 

          除了在函数传值的时候是"引用传递",在任何用"="向对象变量赋值的时候都是"引用传递"。就是类似于给变量再起一个别名。两个名字都指向内存中的同一个对象。
          在实际编程过程中,我们常常要遇到这种情况:有一个对象A,在某一时刻A中已经包含了一些有效值,此时可能会需要一个和A完全相同新对象B,并且此后对B任何改动都不会影响到A中的值,也就是说,A与B是两个独立的对象,但B的初始值是由A对象确定的。在Java语言中,用简单的赋值语句是不能满足这种需求的。要满足这种需求虽然有很多途径,但实现clone()方法是其中最简单,也是最高效的手段。
          Java的所有类都默认继承java.lang.Object类,在java.lang.Object类中有一个方法clone()。JDK API的说明文档解释这个方法将返回Object对象的一个拷贝。要说明的有两点:一是拷贝对象返回的是一个新对象,而不是一个引用。二是拷贝对象与用new操作符返回的新对象的区别就是这个拷贝已经包含了一些原来对象的信息,而不是对象的初始信息。
          怎样应用clone()方法? 

          一个很典型的调用clone()代码如下: 

    1. public class CloneClass implements Cloneable {  
    2.     public int aInt;  
    3.   
    4.     public Object clone() {  
    5.         CloneClass o = null;  
    6.         try {  
    7.             o = (CloneClass) super.clone();  
    8.         } catch (CloneNotSupportedException e) {  
    9.             e.printStackTrace();  
    10.         }  
    11.         return o;  
    12.     }  
    13. }  
          有三个值得注意的地方,一是希望能实现clone功能的CloneClass类实现了Cloneable接口,这个接口属于java.lang包,java.lang包已经被缺省的导入类中,所以不需要写成java.lang.Cloneable。另一个值得请注意的是重载了clone()方法。最后在clone()方法中调用了super.clone(),这也意味着无论clone类的继承结构是什么样的,super.clone()直接或间接调用了java.lang.Object类的clone()方法。下面再详细的解释一下这几点。      应该说第三点是最重要的,仔细观察一下Object类的clone()一个native方法,native方法的效率一般来说都是远高于java中的非native方法。这也解释了为什么要用Object中clone()方法而不是先new一个类,然后把原始对象中的信息赋到新对象中,虽然这也实现了clone功能。对于第二点,也要观察Object类中的clone()还是一个protected属性的方法。这也意味着如果要应用clone()方法,必须继承Object类,在Java中所有的类是缺省继承Object类的,也就不用关心这点了。然后重载clone()方法。还有一点要考虑的是为了让其它类能调用这个clone类的clone()方法,重载之后要把clone()方法的属性设置为public
           那么clone类为什么还要实现Cloneable接口呢?稍微注意一下,Cloneable接口是不包含任何方法的!其实这个接口仅仅是一个标志,而且这个标志也仅仅是针对Object类中clone()方法的,如果clone类没有实现Cloneable接口,并调用了Object的clone()方法(也就是调用了super.Clone()方法),那么Object的clone()方法就会抛出CloneNotSupportedException异常。 
          以上是clone的最基本的步骤,想要完成一个成功的clone,还要了解什么是"影子clone"和"深度clone"。 
          什么是影子clone? 
    1. package com.zoer.src;  
    2.   
    3. class UnCloneA {  
    4.     private int i;  
    5.   
    6.     public UnCloneA(int ii) {  
    7.         i = ii;  
    8.     }  
    9.   
    10.     public void doublevalue() {  
    11.         i *= 2;  
    12.     }  
    13.   
    14.     public String toString() {  
    15.         return Integer.toString(i);  
    16.     }  
    17. }  
    18.   
    19. class CloneB implements Cloneable {  
    20.     public int aInt;  
    21.     public UnCloneA unCA = new UnCloneA(111);  
    22.   
    23.     public Object clone() {  
    24.         CloneB o = null;  
    25.         try {  
    26.             o = (CloneB) super.clone();  
    27.         } catch (CloneNotSupportedException e) {  
    28.             e.printStackTrace();  
    29.         }  
    30.         return o;  
    31.     }  
    32. }  
    33.   
    34. public class ObjRef {  
    35.     public static void main(String[] a) {  
    36.         CloneB b1 = new CloneB();  
    37.         b1.aInt = 11;  
    38.         System.out.println("before clone,b1.aInt = " + b1.aInt);  
    39.         System.out.println("before clone,b1.unCA = " + b1.unCA);  
    40.   
    41.         CloneB b2 = (CloneB) b1.clone();  
    42.         b2.aInt = 22;  
    43.         b2.unCA.doublevalue();  
    44.         System.out.println("=================================");  
    45.         System.out.println("after clone,b1.aInt = " + b1.aInt);  
    46.         System.out.println("after clone,b1.unCA = " + b1.unCA);  
    47.         System.out.println("=================================");  
    48.         System.out.println("after clone,b2.aInt = " + b2.aInt);  
    49.         System.out.println("after clone,b2.unCA = " + b2.unCA);  
    50.     }  
    51. }  

           输出结果:

    before clone,b1.aInt = 11
    before clone,b1.unCA = 111
    =================================
    after clone,b1.aInt = 11
    after clone,b1.unCA = 222
    =================================
    after clone,b2.aInt = 22
    after clone,b2.unCA = 222

           输出的结果说明int类型的变量aInt和UnCloneA的实例对象unCA的clone结果不一致,int类型是真正的被clone了,因为改变了b2中的aInt变量,对b1的aInt没有产生影响,也就是说,b2.aInt与b1.aInt已经占据了不同的内存空间,b2.aInt是b1.aInt的一个真正拷贝。相反,对b2.unCA的改变同时改变了b1.unCA,很明显,b2.unCA和b1.unCA是仅仅指向同一个对象的不同引用!从中可以看出,调用Object类中clone()方法产生的效果是:先在内存中开辟一块和原始对象一样的空间,然后原样拷贝原始对象中的内容对基本数据类型,这样的操作是没有问题的,但对非基本类型变量,我们知道它们保存的仅仅是对象的引用,这也导致clone后的非基本类型变量和原始对象中相应的变量指向的是同一个对象。 

           大多时候,这种clone的结果往往不是我们所希望的结果,这种clone也被称为"影子clone"。要想让b2.unCA指向与b2.unCA不同的对象,而且b2.unCA中还要包含b1.unCA中的信息作为初始信息,就要实现深度clone。
           怎么进行深度clone? 
           把上面的例子改成深度clone很简单,需要两个改变:一是让UnCloneA类也实现和CloneB类一样的clone功能(实现Cloneable接口,重载clone()方法)。二是在CloneB的clone()方法中加入一句o.unCA = (UnCloneA)unCA.clone(); 

    1. package com.zoer.src;  
    2.   
    3. class UnCloneA implements Cloneable {  
    4.     private int i;  
    5.   
    6.     public UnCloneA(int ii) {  
    7.         i = ii;  
    8.     }  
    9.   
    10.     public void doublevalue() {  
    11.         i *= 2;  
    12.     }  
    13.   
    14.     public String toString() {  
    15.         return Integer.toString(i);  
    16.     }  
    17.   
    18.     public Object clone() {  
    19.         UnCloneA o = null;  
    20.         try {  
    21.             o = (UnCloneA) super.clone();  
    22.         } catch (CloneNotSupportedException e) {  
    23.             e.printStackTrace();  
    24.         }  
    25.         return o;  
    26.     }  
    27. }  
    28.   
    29. class CloneB implements Cloneable {  
    30.     public int aInt;  
    31.     public UnCloneA unCA = new UnCloneA(111);  
    32.   
    33.     public Object clone() {  
    34.         CloneB o = null;  
    35.         try {  
    36.             o = (CloneB) super.clone();  
    37.         } catch (CloneNotSupportedException e) {  
    38.             e.printStackTrace();  
    39.         }  
    40.         o.unCA = (UnCloneA) unCA.clone();  
    41.         return o;  
    42.     }  
    43. }  
    44.   
    45. public class CloneMain {  
    46.     public static void main(String[] a) {  
    47.         CloneB b1 = new CloneB();  
    48.         b1.aInt = 11;  
    49.         System.out.println("before clone,b1.aInt = " + b1.aInt);  
    50.         System.out.println("before clone,b1.unCA = " + b1.unCA);  
    51.   
    52.         CloneB b2 = (CloneB) b1.clone();  
    53.         b2.aInt = 22;  
    54.         b2.unCA.doublevalue();  
    55.         System.out.println("=================================");  
    56.         System.out.println("after clone,b1.aInt = " + b1.aInt);  
    57.         System.out.println("after clone,b1.unCA = " + b1.unCA);  
    58.         System.out.println("=================================");  
    59.         System.out.println("after clone,b2.aInt = " + b2.aInt);  
    60.         System.out.println("after clone,b2.unCA = " + b2.unCA);  
    61.     }  
    62. }  

    输出结果:

    before clone,b1.aInt = 11
    before clone,b1.unCA = 111
    =================================
    after clone,b1.aInt = 11
    after clone,b1.unCA = 111
    =================================
    after clone,b2.aInt = 22
    after clone,b2.unCA = 222

          可以看出,现在b2.unCA的改变对b1.unCA没有产生影响。此时b1.unCA与b2.unCA指向了两个不同的UnCloneA实例,而且在CloneB b2 = (CloneB)b1.clone();调用的那一刻b1和b2拥有相同的值,在这里,b1.i = b2.i = 11。 

            要知道不是所有的类都能实现深度clone的。例如,如果把上面的CloneB类中的UnCloneA类型变量改成StringBuffer类型,看一下JDK API中关于StringBuffer的说明,StringBuffer没有重载clone()方法,更为严重的是StringBuffer还是一个final类,这也是说我们也不能用继承的办法间接实现StringBuffer的clone。如果一个类中包含有StringBuffer类型对象或和StringBuffer相似类的对象,我们有两种选择:要么只能实现影子clone,要么就在类的clone()方法中加一句(假设是SringBuffer对象,而且变量名仍是unCA): o.unCA = new StringBuffer(unCA.toString()); //原来的是:o.unCA = (UnCloneA)unCA.clone(); 

           还要知道的是除了基本数据类型能自动实现深度clone以外,String对象是一个例外,它clone后的表现好象也实现了深度clone,虽然这只是一个假象,但却大大方便了我们的编程。 
           Clone中String和StringBuffer的区别 
           应该说明的是,这里不是着重说明String和StringBuffer的区别,但从这个例子里也能看出String类的一些与众不同的地方。 
           下面的例子中包括两个类,CloneC类包含一个String类型变量和一个StringBuffer类型变量,并且实现了clone()方法。在StrClone类中声明了CloneC类型变量c1,然后调用c1的clone()方法生成c1的拷贝c2,在对c2中的String和StringBuffer类型变量用相应的方法改动之后打印结果: 

    1. package com.zoer.src;  
    2.   
    3. class CloneC implements Cloneable {  
    4.     public String str;  
    5.     public StringBuffer strBuff;  
    6.   
    7.     public Object clone() {  
    8.         CloneC o = null;  
    9.         try {  
    10.             o = (CloneC) super.clone();  
    11.         } catch (CloneNotSupportedException e) {  
    12.             e.printStackTrace();  
    13.         }  
    14.         return o;  
    15.     }  
    16.   
    17. }  
    18.   
    19. public class StrClone {  
    20.     public static void main(String[] a) {  
    21.         CloneC c1 = new CloneC();  
    22.         c1.str = new String("initializeStr");  
    23.         c1.strBuff = new StringBuffer("initializeStrBuff");  
    24.         System.out.println("before clone,c1.str = " + c1.str);  
    25.         System.out.println("before clone,c1.strBuff = " + c1.strBuff);  
    26.   
    27.         CloneC c2 = (CloneC) c1.clone();  
    28.         c2.str = c2.str.substring(05);  
    29.         c2.strBuff = c2.strBuff.append(" change strBuff clone");  
    30.         System.out.println("=================================");  
    31.         System.out.println("after clone,c1.str = " + c1.str);  
    32.         System.out.println("after clone,c1.strBuff = " + c1.strBuff);  
    33.         System.out.println("=================================");  
    34.         System.out.println("after clone,c2.str = " + c2.str);  
    35.         System.out.println("after clone,c2.strBuff = " + c2.strBuff);  
    36.     }  
    37. }  

    执行结果:

    1. <span style="font-family:'Microsoft YaHei';"><span style="font-size:16px;">before clone,c1.str = initializeStr  
    2. before clone,c1.strBuff = initializeStrBuff  
    3. =================================  
    4. after clone,c1.str = initializeStr  
    5. after clone,c1.strBuff = initializeStrBuff change strBuff clone  
    6. =================================  
    7. after clone,c2.str = initi  
    8. after clone,c2.strBuff = initializeStrBuff change strBuff clone  
    9. </span></span>  

            打印的结果可以看出,String类型的变量好象已经实现了深度clone,因为对c2.str的改动并没有影响到c1.str!难道Java把Sring类看成了基本数据类型?其实不然,这里有一个小小的把戏,秘密就在于c2.str = c2.str.substring(0,5)这一语句!实质上,在clone的时候c1.str与c2.str仍然是引用,而且都指向了同一个String对象。但在执行c2.str = c2.str.substring(0,5)的时候,它作用相当于生成了一个新的String类型,然后又赋回给c2.str。这是因为String被Sun公司的工程师写成了一个不可更改的类(immutable class),在所有String类中的函数都不能更改自身的值。

    展开全文
  • Java中clone方法为浅拷贝,也就是复制了引用,如果拷贝的对象改变了,所有的都会变掉 如果是这样的话,那我使用原型模式拷贝A创建一个新的对象B,当我改动A时,是不是B也会受影响,这样是不是会不符合我需要的...
  • 1、传递引用与拷贝 在正式学习深浅拷贝之前,我们先要弄清什么...所谓拷贝就是把a的数值复制后在内存中另开辟一个空间进行存储; 那么如果b=a是拷贝a的值的话,那么他们的内存地址应该是不同的,来验证一下: ''' id
  • 你还在用 Windows 的“复制”“粘贴”命令吗?我晕,这都什么年代了,拷贝一部电影你要用多长时间?更可怕的是,拷贝几十部电影呢?没关系,慢慢坐着等吧,先玩其他的东东,糟糕,死机了!强行关闭程序,拷贝到 99% ...
  • ** 单机的redis并发大概在5万--6万左右。...这个时候master就会把一些数据提交slave,让slave去处理,那么这个过程就是全量的数据复制; 那么这个数据就rdb文件,master会把rdb文件拷贝一份新的放在磁盘里面,放在.
  • 软件介绍: 你还在用 Windows 的“复制”“粘贴”命令吗?我晕,这都什么年代了,拷贝一部电影你要用多长时间?更可怕的是,拷贝几十部电影呢?没关系,慢慢坐着等吧,先玩其他的东东,糟糕,死机了!强行关闭程序,...
  • 这点就不如人家VMWare做的好,人家会问你是不是拷贝的呀什么的,多温柔体贴。而这时候,VirtualBox简直就是一刁蛮任性的公主,让人头疼。 没办法,顺着她吧,想办法解决问题。 任何头脑正常的人都会想到,把这个...
  • 这点就不如人家VMWare做的好,人家会问你是不是拷贝的呀什么的,多温柔体贴。而这时候,VirtualBox简直就是一刁蛮任性的公主,让人头疼。 没办法,顺着她吧,想办法解决问题。 任何头脑正常的人都会想到,把这个硬盘...
  • 简解原型模式很好理解,就是对自身进行拷贝,原形就是自身,原型模式可以理解为对自身的一种备份吧。java可以实现多接口,运行时拷贝也可以做许多变换,这里面还是很有学问的 ∩_∩。二。用途原型模式用途,举个例子...
  • 碟中碟xx批处理

    2012-10-31 16:01:54
    然后复制到有需要破解的dzd文档目录,用鼠标双击那个批处理文件,会有一个DOS命令行界面一闪而过,然后自动关闭消失,之后,你会看到这个目录下的dzd文档的修改日期都变成当前日期了,也就是被破解改写了,可以拷贝...
  • 再从文章中拷贝代码粘贴在自己的项目里看看是不是能解决问题。解决了最好,要是没有解决的话就继续再找。这种状态持续了很久:不停地四处找代码借以解决自己的项目需求和技术难点。在这个过程中自己的进步微乎其微,...
  • PS如何快速的去掉斑点和将皮肤变白(磨皮) 作者:张福林 日期:2019年3月29日 ...进入通道面板后只选中通道蓝,然后将其拖向创建新通道,拷贝一份新的通道蓝(Ctrl+J是不能复制通道的)创建新通道在最下面删除当...
  • 开博

    千次阅读 2011-01-31 16:16:00
    刚开始学编程的时候,遇到问题就到处找答案,看看别人的文章,拷贝下来代码粘贴在自己的项目里看看是不是能解决问题。解决了最好,要是没有解决的话就继续再找。就这么持续了很长一段时间,我依旧是在不停地找代码...
  • 因为我原来的svn采用是最简单的eclipse插件安装方式,就是把插件解压后, 把features目录下的内容复制到eclipse下的features中 ,把plugins目录下的所有文件和目录复制到eclipse\plugins目录下。这样安装subclipse...
  • 时候总是先解压文件,换句话说,就是要释放许多东西到系统的临时文件佳里,再换句话说就是拷贝好多 临时文件先到系统里,这总浪费时间吧?然后在安装结束之后还要去删除这些文件,这又要浪费时间吧? 而我把他做成...
  • 另外可以使用concat从一个数组中复制一个副本出来。数组本身提供了很多方法让开发者使用来操作数组。 - length 数组的长度 - toString 可以返回一个以,拼接的字符串,相当于是调用了下join(','...
  • 图床教程

    2020-12-08 23:55:00
    <div><h1>图床教程 ...选复制图片地址</code></p> <p><img alt="网页图_图床01" src="http://ovdtbcicu.bkt.clouddn.com/%E7%BD%91%E9%A1%B5%E5%9B%BE_%E5%9B%BE%E5%BA%8A01.png" /></p> 得到:...
  •  关于APE格式转换,APE是无损格式的一种,也就是说,如果设备条件和方法都比较好的话,它的音质可以和正版CD完全一样.千千自带APE的编码器的有几个选项,但出来的APE文件的音质是相同的,不同的是转换的快慢和体积...
  •  再打开,是不是就好了.  三安装例子  1 诺基亚手机 安装MP手机浏览器JAVA程序  安装 JAVA程序先要传输软件,安装的步骤如下:  (1)先下载 JAVA程序 ;  (2)就是选择"Java加载器",手机显示"请插上电缆,然后...
  • 极品五笔7.0(优化版)

    2010-11-02 20:09:19
    其实不要担心,极品五笔输入法的自定义词库文件名为JPWB.EMB,在平时,将此文件作一个备份,在使用时只需将它重新拷贝到目标文件夹下就可以了(JPWB.EMB实际存放的位置与登录系统的用户名相关,Win2000/Xp/2003系统...
  • 计算机应用技术 实用手册 Xnllz 2011.7.29 ...1.STANDARD CMOS SETUP(标准CMOS设定)用来设定日期、时间、软硬盘规格、工作类类型。...5.PNP/PCI Configurations 即插即用与PCI设备设定,一般为默认。...
  • 假如你是双内存,而且是不同品牌的内存条混插或者买了二手内存时,出现这个问题,这时,你就要检查是不是内存出问题了或者和其它硬件不兼容。 如果都没有,那就从软件方面排除故障了。 先简单说说原理:内存有个存放...
  • 一个进程池的服务器程序 ... 流程大概如下: 1,父进程listen,创建pipe(下面所有父子进程之间的通信都用该pipe) 2,父进程预fork n个子进程 3,各个子进程accept(listenfd),即所有子进程竞争accept请求。...
  • // 之所以要slice复制一份出来是因为有的cb执行过程中又会往callbacks中加入内容 // 比如$nextTick的回调函数里又有$nextTick // 这些是应该放入到下一个轮次的nextTick去执行的, // 所以拷贝一份当前的,遍历...

空空如也

空空如也

1 2
收藏数 37
精华内容 14
关键字:

拷贝是不是就是复制