对于浅拷贝和深拷贝的理解

对于浅拷贝的理解

使用js在存入数组或对象是会在浏览器的栈空间存储指向堆空间的指针（及地址），而在堆空间存储真正的内容，访问时通过栈空间的地址来访问；

1. 浅拷贝拷贝的是栈空间内存地址，并不是拷贝的内容；
   比如:对于数组的拷贝

   var arr=["北京","上海","广州","深圳","成都"]
    var newArr=arr;
        newArr[3]="杭州";
        console.log(arr);//0:"北京"1:"上海"2:"广州"3 : "杭州" 4 :"成都"
        console.log(newArr);//0:"北京"1:"上海"2:"广州"3 : "杭州" 4 :"成都"

    

----更改了一处，但是两个数组都更改了；这种简单的赋值等于知识一种浅拷贝。

2. 对于数组深拷贝的方法

   1. 用数组的slice方法来进行拷贝

   2. 对于数组的slice方法的使用：
      （1）slice方法用于对数组的截取，返回的是一个截取后的数组，语法是:

      arrayObj.slice(starIndex,endIndex)

       

      
      参数说明：arrayObj--必填项，是需要从该数组中来截取数组；starInex--必填项，表示截取开始的位子的下标；endIndex--选填项，如果该项不填，则从开始位置截取到最后，如果starindex或endinex为负数，那么从结尾开始计数下标。

   3. 用concat方法，js的concat方法用于连接两个或多个数组，该方法不会改变原有数组，会返回连接后数组的副本，Arrayobj.concat(arrat1,array2,array3,...)，该方法会将数组中的元素取出，放入一个新数组中，返回改数组。

      var arr=[1,2,3,4];
      var arr1=["北京","上海"];
      var newArr=arr.concat(arr1);
      
      console.log("原数组:"+arr);
      console.log("新数组:"+newArr)
      //返回结果
      原数组:1,2,3,4
      新数组:1,2,3,4,北京,上海

       

   4. 采用递归函对数组进行深拷贝，如下：

      var arr=["a","s","d","f"];
      function deepCopy(arr,newArr) {
          newArr=newArr || [];
          for (var i in arr){
          if (typeof arr[i]==="object"){
              newArr[i]=arr[i].constructor===Array?[]:{};
              deepCopy(arr[i],newArr[i])
          }else {
              newArr[i]=arr[i]
          }
      }
      return newArr
      }
      var arr1=deepCopy(arr);
      arr1[3]="asdfed";
      console.log("原数组："+arr);
      console.log("新数组："+arr1);
      //返回结果
      原数组：a,s,d,f
      新数组：a,s,d,asdfed

       

   5. 同时也可以用jQuery中的extend属性进行拷贝

3. 对象的深拷贝的方法：比如以下代码

   function Test(){
            this.name="xiaohong";
            this.age=18;
            this.run=function () {
            console.log("i can run")
            }
        }
        var test=new Test();
        console.log(test.age);
        test.run();
        function NewTest() {
            this.name="xiaowang";
            this.age=20;
            this.sing=function () {
                console.log("i can sing")
            }
        }
        NewTest.prototype=new Test();
        var children = new NewTest();
        children.sing();
        children.run();
        console.log(children.age);
   
        console.log('----childre的属性----') ;
        for (var key in children){
            console.log(key) ;
         }
        //如果要过滤掉原型上的属性
        console.log('----childre的属性----') ;
        for (var key in children){
            if(children.hasOwnProperty(key)) {
            console.log(key);
        }
        }
        //所以对于一个对象的深拷贝
        var cloneObj={};
        for (var key in children){
            if(children.hasOwnProperty(key)) {
            cloneObj[key]=children[key]
            }
        }

    

   2. 同样也可以用递归的方法对对象进行深拷贝

      function deepCopy(obj,newObj) {
          newObj=newObj || {};
          for (var i in obj){
              if (typeof obj[i]==="object"){
                  newObj[i]=obj[i].constructor===Array?[]:{};
                  deepCopy(obj[i],newObj[i])
              }else {
                  newObj[i]=obj[i]
              }
          }
          return newObj
      }

       

   和数组递归方式的深拷贝原理一样