浅拷贝

前面已经提到，在定义一个对象或数组时，变量存放的往往只是一个地址。当我们使用对象拷贝时，如果属性是对象或数组时，这时候我们传递的也只是一个地址。因此子对象在访问该属性时，会根据地址回溯到父对象指向的堆内存中，即父子对象发生了关联，两者的属性值会指向同一内存空间。

/**
 * 浅拷贝copy，只深拷贝了第一级的数值
 */
var a = { key: "111" }
function copy(p) {
  var c = {};
  for (var i in p) {
    c[i] = p[i];
  }
  return c;
}
a.key1 = 1
a.key2 = ["xiao", "xiao"] //引用类型是浅拷贝，结果相同
var b = copy(a)
b.key = "22" //数值部分是深拷贝，结果不同
b.key3 = "333";
b.key2.push("xiao")
console.log(a)
console.log(b)

输出结果：

{ key: '111', key1: 1, key2: [ 'xiao', 'xiao', 'xiao' ] }
{ key: '22',
  key1: 1,
  key2: [ 'xiao', 'xiao', 'xiao' ],
  key3: '333' }

上述语句输入结果的原因是：
key1的值属于基本类型，所以拷贝的时候传递的就是该数据段；
但是key2的值是堆内存中的对象，所以key2在拷贝的时候传递的是指向key2对象的地址，无论复制多少个key2，其值始终是指向父对象的key2对象的内存空间。
用下图来表示内存中语句的赋值过程如下：

image.png

/**
 * ES6实现只深拷贝第一级的方法
 */
//1: Object.assign()
var a = { name: "暖风" }
var b = Object.assign({}, a);
b.age = 18;
console.log(a.age);//undefined
console.log("-------------")

//2: 数组
var a = [1, 2, 3];
var b = a.slice();
b.push(4);
console.log(a)//[ 1, 2, 3 ]
console.log(b)//[ 1, 2, 3, 4 ]
var a = [{ "k": [1, 2] }]
var b = a.slice();
b[0].k = [1, 2]
console.log(a)//[ { k: [ 1, 2 ] } ]
console.log(b)//[ { k: [ 1, 2 ] } ]
console.log("-------------")

//3: concat
var a = [1, 2, 3];
var b = a.concat();
b.push(4);
console.log(a)//[ 1, 2, 3 ]
console.log(b)//[ 1, 2, 3, 4 ]
var a = [{ "k": [1, 2] }]
var b = a.slice();
b[0].k = [1, 2]
console.log(a)//[ { k: [ 1, 2 ] } ]
console.log(b)//[ { k: [ 1, 2 ] } ]
console.log("-------------")

//4 :...
var a = [1, 2, 3];
var b = [...a];
b.push(4)
console.log(a)//[ 1, 2, 3 ]
console.log(b)//[ 1, 2, 3, 4 ]
var a = [{ "k": [1, 2] }];
var b = [...a];
console.log(a)//[ { k: [ 1, 2 ] } ]
console.log(b)//[ { k: [ 1, 2 ] } ]

深拷贝

或许以上并不是我们在实际编码中想要的结果，我们不希望父子对象之间产生关联，那么这时候可以用到深拷贝。既然属性值类型是数组和或象时只会传址，那么我们就用递归来解决这个问题，把父对象中所有属于对象的属性类型都遍历赋给子对象即可。测试代码如下：

/**
 * 深拷贝实现方法
 */
var a = { key1: "11111" }
function _copy(p, c) {
  var c = c || {};
  for (var i in p) {
    if (typeof p[i] === "object") {
      c[i] = (p[i].constructor === Array) ? [] : {}
      _copy(p[i], c[i]);
    } else {
      c[i] = p[i]
    }
  }
  return c;
}
a.key2 = ["小", "小"]
var b = {}
b = _copy(a, b);
b.key1 = "22"
b.key2.push("大");
console.log(a)
console.log(b)

输出结果：

{ key1: '11111', key2: [ '小', '小' ] }
{ key1: '22', key2: [ '小', '小', '大' ] }

好了，我们看下图内存中的赋值过程：

image.png

• 原始类型：在栈中，因为占据空间是固定的，可以将他们存在较小的内存中-栈中，这样便于迅速查询变量的值
• 引用类型：存在堆中，栈中存储的变量，只是用来查找堆中的引用地址。
  这是因为：引用值的大小会改变，所以不能把它放在栈中，否则会降低变量查寻的速度。相反，放在变量的栈空间中的值是该对象存储在堆中的地址。地址的大小是固定的，所以把它存储在栈中对变量性能无任何负面影响

2、不同的内存分配带来不同的访问机制
在javascript中是不允许直接访问保存在堆内存中的对象的，所以在访问一个对象时，首先得到的是这个对象在堆内存中的地址，然后再按照这个地址去获得这个对象中的值，这就是传说中的按引用访问。而原始类型的值则是可以直接访问到的。

3、复制变量时的不同

• 原始值：在将一个保存着原始值的变量复制给另一个变量时，会将原始值的副本赋值给新变量，此后这两个变量是完全独立的，他们只是拥有相同的value而已。
• 引用值：在将一个保存着对象内存地址的变量复制给另一个变量时，会把这个内存地址赋值给新变量，
  也就是说这两个变量都指向了堆内存中的同一个对象，他们中任何一个作出的改变都会反映在另一个身上。
  （这里要理解的一点就是，复制对象时并不会在堆内存中新生成一个一模一样的对象，只是多了一个保存指向这个对象指针的变量罢了）。多了一个指针

4、参数传递的不同（把实参复制给形参的过程）
首先我们应该明确一点：ECMAScript中所有函数的参数都是按值来传递的。
但是为什么涉及到原始类型与引用类型的值时仍然有区别呢？还不就是因为内存分配时的差别。

• 原始值：只是把变量里的值传递给参数，之后参数和这个变量互不影响。
• 引用值：对象变量它里面的值是这个对象在堆内存中的内存地址，这一点你要时刻铭记在心！
  因此它传递的值也就是这个内存地址，这也就是为什么函数内部对这个参数的修改会体现在外部的原因了，因为它们都指向同一个对象。

参考博客：https://www.cnblogs.com/c2016c/articles/9328725.html