澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

澳门新萄京官方网站:JavaScript的有的构思,之

2019-12-01 作者:www.8455.com   |   浏览(53)

 一、String到底是值类型还是引用类型

 

关于String为值类型还是引用类型的讨论一直没有平息,最近一直在研究性能方面的问题,今天再次将此问题进行一次明确。希望能给大家带来点帮助。 如果有错误请指出。

最近在研究lodash的源码,涉及到深 拷贝和浅拷贝的问题,由此,搜集网上的资料来研究了一番。

MSDN 中明确指出 String 是引用类型而不是值类型,但 String 表面上用起来却像是值类型,这又是什么原因呢? 

也许会有人这样解释C# 中浅拷贝与深拷贝区别:

来看下面例子:

  • 共同点: 都是在已有对象的基础上拷贝一份。
  • 不同点: 拷贝实例,还是拷贝引用
      首先分析两者的共同点和不同点。首先,深拷贝和浅拷贝都是基于一些复杂的数据类型,比如Object和Array,如果是基础数据类型,number,boolean等,就没什么区别了,这和引用类型和基础类型所在内存区域是堆内存还是栈内存有关。
      浅拷贝和深拷贝斗仙得分清是拷贝引用还是拷贝实例

首先从下面这个例子入手:

        浅拷贝是对引用类型拷贝地址,对值类型直接进行拷贝。

            //值类型
            int a = 1;
            int b = a;
            a = 2;
            Console.WriteLine("a is {0},b is {1}", a, b);

            //字符串
            string str1 = "ab";
            string str2 = str1;
            str1 = "abc";
            Console.WriteLine("str1 is {0},str2 is {1}", str1, str2);
            Console.Read();
    //值类型
    int a = 1;
    int b = a;
    a = 2;
    Console.WriteLine("a is {0},b is {1}", a, b);

    //引用类型
    string str1 = "ab";
    string str2 = str1;
    str1 = "abc";
    Console.WriteLine("str1 is {0},str2 is {1}", str1, str2);
    Console.Read();

不能说它完全错误,但至少还不够严谨。比如:string 类型咋说?

 

 var obj = {
     a: 1,
     b: 2,
 } 
 var obj1 = {}
 function simplecopy(p, c) {
     var c = c || {}
     for(var key in p) {
         c[key] = p[key]
     }
 }
 simplecopy(obj, obj1)
 obj1.a=3
 console.log(obj.a) //1
 console.log(obj1.a) //3
 console.log(obj === obj1) //false
 console.log(obj.a === obj1.a) //false

 

 

根据上面的例子:你觉得输出结果应该是什么?

以上就是拷贝实例,拷贝实例就是给新的对象分配一个新的内存空间,所以两个变量互不干扰,值类型,就是基础数据类型,simplecopy函数中把a和b两个基础数据类型,拷贝给了对象C,相当于重新分配了两个空间,所以,obj1和obj2以及其对象都是指向两种不同的地址。所以,===为false。

输出结果:

其实,我们可以通过实践来寻找答案。

 

var str1 =  {a: 1, b: 2 }
 var str2 = str1

 str2.a = 3
 console.log(str1.a) // 3
 console.log(str2.a) // 3
 console.log(str1.a === str2.a) //true
 //结果:
   //a is 2,b is 1
   //str1 is abc,str2 is ab

首先,定义以下类型:

输出结果:

以上就是拷贝引用,因为str1和str2都是对象,是引用类型。str2=str1,实际上是将str2指向str1的应用的地址,所以,str1和str2其指向的是同一块内存地址,所以,改变其值,就会互相干扰。

从运行结果可以看出:str2 的值还是 ab ,并没有随着 str1 值的改变而改变。如果string是引用类型,按理Str1和Str指针都指向同一内存地址,如果Str的内容发生改变,Str1应该也会相应变化。此例子,看着string更像是值类型。 但是MSDN却说String是引用类型。究其原因,是因为string对象是不可变的,包括长度和其中任何字符都是不可以改变的。

int 、string 、enum 、struct 、class 、int[ ] 、string[ ]

            //结果:
            //a is 2,b is 1
            //str1 is abc,str2 is ab

关于不可变数据类型,请参考:https://www.cnblogs.com/mushroom/p/4373951.html

代码如下:

str2依然是ab,并没有随str1的改变而改变。

浅拷贝

浅拷贝分成两类.

  • 一个是简单的引用拷贝,这个简单,普通的赋值就可以了。
  • 还有一个是源对象拷贝实例,其嵌套有子对象的话,就是拷贝引用
      如果一个对象没有嵌套子对象的话,那么就是源对象的实例拷贝,这里自己写了一个浅拷贝方法,就是上文的simplecopy,上文的obj1和obj2都是没有嵌套子对象的对象,它的属性就是基本数据类型,所以,它的拷贝就是实例拷贝,两个对象指向不同的地址,其属性也指向不同的地址。但是如果,一个对象嵌套了一个子对象,对其子对象进行赋值,那么就是,引用赋值,指向的是同一个地址。
var stu1 = {
     name: "xiaoming",
     info: {
         score: 12,
         school: "第一小学"
     }
 }
var stu2 = {}
 simplecopy(stu1, stu2)
 console.log(stu1)
 console.log(stu2)
 stu2.info.score = 21
 console.log(stu1)  // 其中的info.score值是21
 console.log(stu1)  // 其中的info.score值是21

澳门新萄京官方网站 1

testpng.png


String的不变性

string 对象称为不可变的(只读),因为一旦创建了该对象,就不能修改该对象的值。有的时候看来似乎修改了,实际是string经过了特殊处理,每次改变值时都会建立一个新的string对象,变量会指向这个新的对象,而原来的还是指向原来的对象,所以不会改变。这也是string效率低下的原因。如果经常改变string的值则应该使用StringBuilder而不使用string。

在例子中str1=”ab”,这时在内存中就将“ab”存下来,如果再创建字符串对象,其值也等于“ab”,str2=”ab”,则并非再重新分配内存空间,而是将之前保存的“ab”的地址赋给str2的引用,这就能印证例子2中的结果。而当str1=”abc”其值发生改变时,这时检查内存,发现不存在此字符串,则重新分配内存空间,存储“abc”,并将其地址赋给str1,而str2依然指向“ab”的地址。可以印证例子中的结果。

    //枚举
    public enum myEnum
    { _1 = 1, _2 = 2 }
 
    //结构体
    public struct myStruct
    {
        public int _int;
        public myStruct(int i)
        { _int = i; }
    }
 
    //类
    class myClass
    {
        public string _string;
        public myClass(string s)
        { _string = s; }
    }
 
    //ICloneable:创建作为当前实例副本的新对象。
    class DemoClass : ICloneable
    {
        public int _int = 1;
        public string _string = "1";
        public myEnum _enum = myEnum._1;
        public myStruct _struct = new myStruct(1);
        public myClass _class = new myClass("1");
        //数组
        public int[] arrInt = new int[] { 1 };
        public string[] arrString = new string[] { "1" };
 
        //返回此实例副本的新对象
        public object Clone()
        {
            //MemberwiseClone:返回当前对象的浅表副本(它是Object对象的基方法)
            return this.MemberwiseClone();
        }
    }

如果string是引用类型,按理Str1和Str指针都指向同一内存地址,如果Str的内容发生改变,Str1应该也会相应变化。

深拷贝

至于深拷贝,简单说就是弥补了浅拷贝的缺憾,将被拷贝对象中的子对象遍历一遍,赋值给空对象,然后在进行浅拷贝,原理就是这样,上段代码

function deepCopy(p, c) {
     var c = c || {}
     for(var i in p) {
         if(typeof p[i] === 'object') {
             c[i] = (p[i].constructor === 'Array' ? [] : {})
             deepCopy(c[i], p[i])
         } else {
             c[i] = p[i]
         } 
     }
 }
 deepCopy(stu1, stu2)
 console.log(stu1)
 console.log(stu2)

结论

String是引用类型,只是编译器对其做了特殊处理。

 

二、浅拷贝与深拷贝

也许会有人这样解释C# 中浅拷贝与深拷贝区别:

        浅拷贝是对引用类型拷贝地址,对值类型直接进行拷贝。

不能说它完全错误,但至少还不够严谨。比如:string 类型咋说?

 

其实,我们可以通过实践来寻找答案。

 

首先,定义以下类型:

 

int 、string 、enum 、struct 、class 、int[ ] 、string[ ]

 

代码如下:

    //枚举
    public enum myEnum
    { _1 = 1, _2 = 2 }

    //结构体
    public struct myStruct
    {
        public int _int;
        public myStruct(int i)
        { _int = i; }
    }

    //类
    class myClass
    {
        public string _string;
        public myClass(string s)
        { _string = s; }
    }

    //ICloneable:创建作为当前实例副本的新对象。
    class DemoClass : ICloneable
    {
        public int _int = 1;
        public string _string = "1";
        public myEnum _enum = myEnum._1;
        public myStruct _struct = new myStruct(1);
        public myClass _class = new myClass("1");
        //数组
        public int[] arrInt = new int[] { 1 };
        public string[] arrString = new string[] { "1" };

        //返回此实例副本的新对象
        public object Clone()
        {
            //MemberwiseClone:返回当前对象的浅表副本(它是Object对象的基方法)
            return this.MemberwiseClone();
        }
    }

注意:

ICloneable 接口:支持克隆,即用与现有实例相同的值创建类的新实例。

MemberwiseClone 方法:创建当前 System.Object 的浅表副本。

 

接下来,构建实例A ,并对实例A 克隆产生一个实例B
然后,改变实例B 的值,并观察实例A 的值会不会被改变。

代码如下:

class 浅拷贝与深拷贝
{
    static void Main(string[] args)
    {
        DemoClass A = new DemoClass();
        //创建实例A的副本 --> 新对象实例B
        DemoClass B = (DemoClass)A.Clone();

        B._int = 2;
        Console.WriteLine(" int tt  A:{0}  B:{1}", A._int, B._int);

        B._string = "2";
        Console.WriteLine(" string t  A:{0}  B:{1}", A._string, B._string);

        B._enum = myEnum._2;
        Console.WriteLine(" enum tt  A:{0}  B:{1}", (int)A._enum, (int)B._enum);

        B._struct._int = 2;
        Console.WriteLine(" struct t  A:{0}  B:{1}", 
                          A._struct._int, B._struct._int);

        B._class._string = "2";
        Console.WriteLine(" class tt  A:{0}  B:{1}", 
                          A._class._string, B._class._string);

        B.arrInt[0] = 2;
        Console.WriteLine(" intArray t  A:{0}  B:{1}", 
                          A.arrInt[0], B.arrInt[0]);

        B.arrString[0] = "2";
        Console.WriteLine(" stringArray t  A:{0}  B:{1}", 
                          A.arrString[0], B.arrString[0]);

        Console.ReadKey();
    }
}

结果如下:

澳门新萄京官方网站 2

从最后的输出结果,我们得知:

对于内部的Class 对象和数组,则Copy 一份地址。[ 改变B 时,A也被改变了 ]

而对于其它内置的int / string / enum / struct / object 类型,则Copy 一份值。

 

有一位网友说:string 类型虽然是引用类型,但是很多情况下.Net 把string 做值类型来处理,我觉得string 应该也是按照值类型处理的。

这说明他对string 类型还不够了解。

可以肯定的是:string 一定是引用类型。那它为什么是深拷贝呢?

如果你看一下string 类型的源代码就知道了:

//表示空字符串。此字段为只读。
public static readonly string Empty;

答案就在于 string 是 readonly 的,当改变 string 类型的数据值时,将重新分配了内存地址。

澳门新萄京官方网站,浅拷贝:给对象拷贝一份新的对象。

浅拷贝的定义 —— 只对值类型(或string)类型分配新的内存地址。

深拷贝:给对象拷贝一份全新的对象。

深拷贝的定义 —— 对值类型分配新的内存地址,引用类型、以及引用类型的内部字段分配的新的地址。

我是这么定义的:浅拷贝,换汤不换药。

 

三、Clone()方法

例如我有一个简单的类:

class People
{
    public int _age;
    public string _name;
    public People(int Age,string Name)
    {
    _age = Age;
    _name = Name;
    }
}

常见的赋值语句,如:

People Mike = new People(12,"Mike");
People Mike2 = Mike;

这是浅复制,共享同一块内存,类似指针,即Mike2与Mike对象同时指向了Mike新建时所申请的内存。
现在我为People类增加一个Clone()方法:

class People
{
    public int _age;
    public string _name;
    public People(int Age,string Name)
    {
        _age = Age;
     _name = Name;
    }
    public object Clone()
    {
        People MySelf = new People(this._age,this._name);
        return MySelf;    }
}

很明显,调用Clone()方法返回的对象是一个全新的对象,是新实例化出来的对象但是与原对象在值上相等。

People Mike = new People(12,"Mike");
People Mike2 = Mike;
People Mike3 = Mike.Clone() as People;

Mike2与Mike3在值上相等,但实际是完全独立的对象。

Mike2._name = "Jone";
//执行上述代码后,Mike的_name属性跟着改变了,而Mike3不变。

 

注意:

此例子,看着string更像是值类型。 

ICloneable 接口:支持克隆,即用与现有实例相同的值创建类的新实例。

但是MSDN却说String是引用类型,

MemberwiseClone 方法:创建当前 System.Object 的浅表副本。

引用类型包括: 
String

 

所有数组,即使其元素是值类型

接下来,构建实例A ,并对实例A 克隆产生一个实例B
然后,改变实例B 的值,并观察实例A 的值会不会被改变。

类类型,如 Form

代码如下:

委托

class 浅拷贝与深拷贝
{
    static void Main(string[] args)
    {
        DemoClass A = new DemoClass();
        //创建实例A的副本 --> 新对象实例B
        DemoClass B = (DemoClass)A.Clone();
 
        B._int = 2;
        Console.WriteLine(" int tt  A:{0}  B:{1}", A._int, B._int);
 
        B._string = "2";
        Console.WriteLine(" string t  A:{0}  B:{1}", A._string, B._string);
 
        B._enum = myEnum._2;
        Console.WriteLine(" enum tt  A:{0}  B:{1}", (int)A._enum, (int)B._enum);
 
        B._struct._int = 2;
        Console.WriteLine(" struct t  A:{0}  B:{1}", 
                          A._struct._int, B._struct._int);
 
        B._class._string = "2";
        Console.WriteLine(" class tt  A:{0}  B:{1}", 
                          A._class._string, B._class._string);
 
        B.arrInt[0] = 2;
        Console.WriteLine(" intArray t  A:{0}  B:{1}", 
                          A.arrInt[0], B.arrInt[0]);
 
        B.arrString[0] = "2";
        Console.WriteLine(" stringArray t  A:{0}  B:{1}", 
                          A.arrString[0], B.arrString[0]);
 
        Console.ReadKey();
    }
}

可参考:

结果如下:

查看具体引用是否相同

澳门新萄京官方网站 3

澳门新萄京官方网站:JavaScript的有的构思,之String以至浅拷贝与深拷贝。如果Net能够查看内存地址就容易了,但不允许,只能通过间接方法来实现,看下面:

从最后的输出结果,我们得知:

        static void TestRefAddress()
        {
            String str1 = "abc";
            String str2 = "abc";
            int a = 1;
            int b = 1;
            StringBuilder strb1 = new StringBuilder("abc");
            StringBuilder strb2 = new StringBuilder("abc");
            Console.WriteLine("Reference equal for string: "   Object.ReferenceEquals(str1, str2)); //结果true
            Console.WriteLine("Reference equal for int: "   Object.ReferenceEquals(a, b)); //结果false
            Console.WriteLine("Reference equal for StringBuilder: "   Object.ReferenceEquals(strb1, strb2)); //结果false
            Console.WriteLine("Value equal for string: "   str1.Equals(str2)); //结果true,类似于值类型
            Console.Read();
        }

对于内部的Class 对象和数组,则Copy 一份地址。[ 改变B 时,A也被改变了 ]

结果为何出现如此情况,分析如下:

而对于其它内置的int / string / enum / struct / object 类型,则Copy 一份值。

    Console.WriteLine("Reference equal for string: "   Object.ReferenceEquals(str1, str2)); //结果true,不同对象,但引用地址相同
    Console.WriteLine("Reference equal for int: "   Object.ReferenceEquals(a, b)); //结果false,值类型装箱操作造成
    Console.WriteLine("Reference equal for StringBuilder: "   Object.ReferenceEquals(strb1, strb2)); //结果false,不同对象,引用地址不同
    Console.WriteLine("Value equal for string: "   str1.Equals(str2)); //结果true,类似于值类型

 

由第一条结果,可以判定不同的String的,相同的值,其引用地址相同,再由第四条结果,str1.Equals(str2),两者结合,可得出结论,两个String,如果赋值为同一个值,在内存中只有一个字符串存在,两个引用的地址相同。由此引出String的不变性。

有一位网友说:string 类型虽然是引用类型,但是很多情况下.Net 把string 做值类型来处理,我觉得string 应该也是按照值类型处理的。

String的不变性

这说明他对string 类型还不够了解。

string最为显著的一个特点就是它具有恒定不变性:我们一旦创建了一个string,在managed heap 上为他分配了一块连续的内存空间,我们将不能以任何方式对这个string进行修改使之变长、变短、改变格式。所有对这个string进行各项操作(比如调用ToUpper获得大写格式的string)而返回的string,实际上另一个重新创建的string,其本身并不会产生任何变化。
string   对象称为不可变的(只读),因为一旦创建了该对象,就不能修改该对象的值。有的时候看来似乎修改了,实际是string经过了特殊处理,每次改变值时都会建立一个新的string对象,变量会指向这个新的对象,而原来的还是指向原来的对象,所以不会改变。这也是string效率低下的原因。

可以肯定的是:string 一定是引用类型。那它为什么是深拷贝呢?

String的不变,并非说string不能改变,而是其值不能改变。

如果你看一下string 类型的源代码就知道了:

在例子中str1="ab",这时在内存中就将“ab”存下来,如果再创建字符串对象,其值也等于“ab”,str2="ab",则并非再重新分配内存空间,而是将之前保存的“ab”的地址赋给str2的引用,这就能印证例子2中的结果。而当str1="abc"其值发生改变时,这时检查内存,发现不存在此字符串,则重新分配内存空间,存储“abc”,并将其地址赋给str1,而str2依然指向“ab”的地址。可以印证例子1中的结果。

//表示空字符串。此字段为只读。
public static readonly string Empty;

 

答案就在于 string 是 readonly 的,当改变 string 类型的数据值时,将重新分配了内存地址。

结论:

澳门新萄京官方网站:JavaScript的有的构思,之String以至浅拷贝与深拷贝。 

String是引用类型,只是编译器对其做了特殊处理。

下面引用一段网友的代码:Vseen[ Aloner ] 的个人陋见:

 

public class Student
{
   // 这里用“字段”,其实应当是属性。
   public string Name;
   public int Age;
   //自定义类 Classroom
   public Classroom Class;
}
浅拷贝:Student A 浅拷贝出 Student B,Name和Age拥有新的内存地址,但引用了同一个 Classroom。
深拷贝:Student A 浅拷贝出 Student B,Name和Age拥有新的内存地址,并且A.Classroom 的内存地址不等于 B.Classroom。
 
其实俗点讲,有点像:
 
public object Clone()
{
   Student B = new Student();
   B.Name = this.Name;
   B.Age = this.Age;
   //浅拷贝
   B.Class = this.Class;
   //深拷贝
   B.Class = new Classromm();
   B.Class.Name = this.Class.Name;
   B.Class.Teacher = this.Class.Teacher;
   //根据情况,对Teacher 进行判定要进行的是深拷贝,还是浅拷贝。
}

关于讨论:

 

 

浅拷贝:给对象拷贝一份新的对象。

浅拷贝的定义 —— 只对值类型(或string)类型分配新的内存地址。

深拷贝:给对象拷贝一份全新的对象。

深拷贝的定义 —— 对值类型分配新的内存地址,引用类型、以及引用类型的内部字段分配的新的地址。

我是这么定义的:浅拷贝,换汤不换药。

 

注意:

1、在 .NET 程序中,应该避免使用 ICloneable 接口。

      因为通过该接口无法判断究竟是浅拷贝还是深拷贝,这会造成误解或误用。

 

2、深拷贝应该复制该对象本身及通过该对象所能到达的完整的对象图,浅拷贝只复制对象本身(就是该对象所表示的在堆中的一块连续地址中的内容)。

 

个人愚见:

Clone :深层拷贝,拷贝到了指针指向的内存块的值。

 

浅拷贝:仅仅拷贝了指针的内容。(只是给一个对象多起了个名字,所以,当改变拷贝的某个属性的时候,原对象的对应属性亦会改变)。

 

本文由澳门新萄京官方网站发布于www.8455.com,转载请注明出处:澳门新萄京官方网站:JavaScript的有的构思,之

关键词: