数组及对象的深拷贝与浅拷贝

深拷贝

拷贝后，一个变量发生变化不会影响另一个数据

var a = 123;
var b = a;
 b = 'new str';
console.log(a,b);

浅拷贝

任意一个发生改变另一个也会发生改变
var arr = [1];
var copy_arr = arr;

  copy_arr.push("new string");
  arr.push("new string");

  console.log(arr);
  console.log(copy_arr);

内存分为 栈 和 堆
拷贝执行在栈中完成的
基本类型数据存放在栈中；应用类型数据存放在堆中
变量在栈中；赋值为数据；或者指针
arr 存放的是 数据在堆中的地址；
copy_arr 拷贝的地址，
所有arr copy_arr 指向同一个数据。所以是浅拷贝
基本类型数据拷贝；是深拷贝

数据对象深拷贝

单一结构的数组 对象

拷贝的目的 复制数据
浅拷贝原因因为只有一个数据；内存中只有一个地址
在堆中开辟一个空间；形成一个新的地址。
—> 多个地址 多个数据；彼此不影响

var arr = [1, 2, 2, 2, 23, 3];
 // var copy_arr = arr // 浅拷贝；拷贝地址
var copy_arr = [];
arr.forEach(function (item) {
copy_arr.push(item);
 });

数组深拷贝

var copy_arr1 = arr.concat();
 console.log(copy_arr1);
arr.push("123");
console.log(copy_arr, arr);

对象深拷贝

var obj = {
    name: "aa",
};
//   var copy_obj = obj
//   copy_obj.tast = '测试浅拷贝'

var copy_obj = {};
for (var x in obj) {
   copy_obj[x] = obj[x];
}
copy_obj.tast = '测试深拷贝'
console.log(obj, copy_obj);

for_深拷贝

var arr = [1, 2, [1, [1, 2, 3, [1, 2, 2, [1, 2, 20]]]], [1, 2, 2, 2]];
var res = [];
for (var i = 0; i < arr.length; i++) {
  // 验证数据；是否为数组？
  // 如果是数组，必能直接添加
  var data1 = arr[i];
  if (Array.isArray(arr[i])) {
      var res1 = [];
      for (var j = 0; j < data1.length; j++) {
           var data2 = arr[i][j];
               if (Array.isArray(arr[i][j])) {
                   var res2 = [];
                      for (var k = 0; k < data2.length; k++) {
                   res2.push(data2[k]);
                 }
                 // res1 完成内部拷贝
                 res1.push(res2);
               } else {
                res1.push(data2);
             }
           }
          // res1 完成内部拷贝
          res.push(res1);
        } else {
         res.push(data1);
         }
     }
res[2].push("1111");
res[2][1].push("123");
console.log(arr, res);

简化后代码

// deepCopy_array 作用 深拷贝多层嵌套数组
// 多层数据拷贝中
 // 最外层数组；最后拷贝完毕
 // 最内侧数组，最先拷贝完毕
function deepCopy_array(array) {
        var res = [];
        // 深拷贝
        for (var i = 0; i < array.length; i++) {
          // array[i] 可能是数组
          if (Array.isArray(array[i])) {
            // 递归 自己方法体内；调用自己
            var arr = deepCopy_array(array[i]);
            res.push(arr);
          } else {
            res.push(array[i]);
          }
        }
        return res;
      }
var copy_arr = deepCopy_array(arr);
copy_arr[2].push("111");
copy_arr[2][1].push("11");
console.log(arr, copy_arr);

对象深拷贝

var obj = {
            name:'aaa',
            age:123,
            obj:{
                name:'123',
                age:234
            }
        }
        var res = {}
        for(var x in obj){

            if(obj[x].constructor === Object){
                var res1 = {}
                for(var i in obj[x]){
                    var res1[i] = obj[x][i];
                }
            }
            res[x] = obj[x]
        }
console.log(res);