js数据类型以及深拷贝、浅拷贝

js数据类型

基本数据类型（值类型）： Number、String、Boolean、Undefined、Null、Symbol（es6新增独一无二的值） 和 BigInt（es10新增）；

引用数据类型: Object。包含Object、Array、 function、Date、RegExp。

---

栈堆存储

值类型存储：主要针对（Number、String、Boolean）三种数据。直接存储在栈中，占据空间小、大小固定，属于被频繁使用数据，所以放入栈中存储。

引用类型堆栈存储： 主要针对Object、Array这两种引用数据以及null， 同时存储在栈和堆中，占据空间大、大小不固定。引用数据类型在栈中存储了指针，该指针指向堆中该实体的起始地址。当解释器寻找引用值时，会首先检索其在栈中的地址，取得地址后从堆中获得实体。

var obj = {name:100}
var a = obj
a.name = 200
console.log(obj == a)	// true 

备注：
引用类型存储把值存储在堆内存中，堆内存是从下往上存储。生成唯一内存地址。然后在栈内存中把地址赋值给变量。栈内存是从上往下存储的。之所以如此划分内存主要考虑到特别大的对象进行值传递时的效率问题。

深拷贝与浅拷贝

只有当拷贝引用数据类型时，拷贝才存在浅拷贝与深拷贝之分。

1.浅拷贝： 将原对象或原数组的引用直接赋给新对象，新数组，新对象／数组只是原对象的一个引用
2.深拷贝： 创建一个新的对象和数组，将原对象的各项属性的“值”（数组的所有元素）拷贝过来，是“值”而不是“引用”

为什么要使用深拷贝？

当我们在改变新的数组（对象）的时候，不改变原数组（对象）

浅拷贝(只拷贝第一级数组元素)

数组

浅拷贝就是指创建一个新对象，该对象拥有原始对象第一层属性的精确拷贝。即：如果原始对象的属性是基本类型数据，则拷贝的就是基本数据类型的值；如果原始对象的属性是引用类型，则拷贝的是内存地址。当原始对象的引用类型属性发生改变时，拷贝对象的对应属性值也会发生变化。这里需要强调一下，浅拷贝与赋值是有所区别的，赋值时与原数据指向同一对象，而浅拷贝则指向了不同对象。
1. 直接遍历

var arr = [1, 2, 3, 4];
function copy (arr) {
   let newArray = []
   for(let item of arr) {
      newArray.push(item);
   }
   return  newArray;
}
var copyArray = copy(arr);
copyArray[0] = 100;
console.log(arr); // [1, 2, 3, 4]
console.log(copyArray); // [100, 2, 3, 4]

2. slice()数组方法

当slice()不带任何参数的时候，默认返回一个长度和原数组相同的新数组
var array = [1, 2, 3, 4];
var copyArray = array.slice();
copyArray[0] = 100;
console.log(array); // [1, 2, 3, 4]
console.log(copyArray); // [100, 2, 3, 4]

3. concat()数组方法

因为我们调用concat的时候没有带上参数，所以var copyArray = array.concat();实际上相当于var copyArray = array.concat([]);
也即把返回数组和一个空数组合并后返回
var array = [1, 2, 3, 4];
var copyArray = array.concat();
copyArray[0] = 100;
console.log(array); // [1, 2, 3, 4]
console.log(copyArray); // [100, 2, 3, 4]

对象

1. 直接遍历

let obj = {code:200,list:[1,2,3,4]}
let newObj = {}
for(let i in obj) {
    newObj[i] = obj[i]
}
console.log(obj);
console.log(newObj);

2 .ES6的Object.assign

var obj = {
  name: '张三',
  job: '学生'
}
var copyObj = Object.assign({}, obj);
copyObj.name = '李四';
console.log(obj);   	// {name: "张三", job: "学生"}
console.log(copyObj);  	// {name: "李四", job: "学生"}

Object.assign：用于对象的合并，将源对象（source）的所有可枚举属性，复制到目标对象（target），并返回合并后的target

用法： Object.assign(target, source1, source2); 所以 copyObj = Object.assign({}, obj); 这段代码将会把obj中的一级属性都拷贝到 ｛｝中，然后将其返回赋给copyObj
3. ES6扩展运算符

let obj = {code:200,list:[1,2,3,4]}
let newObj = {...obj}
console.log(newObj);

扩展运算符（…）用于取出参数对象的所有可遍历属性，拷贝到当前对象之中
对于以上方法，如果多层嵌套对象，当我们在改变新的对象的时候，会改变原对象
这样就引出了深拷贝：

深拷贝

浅拷贝是对原始对象第一层属性的精确拷贝，而深拷贝则是对原始对象所有层级属性的递归精确拷贝。
1. 先转换成字符串，在转换成(数组/对象) JSON.parse(JSON.stringify(XXXX))

let obj = {code:200,list:[1,2,3,4]}
let newObj = JSON.parse(JSON.stringify(obj))
newObj.list[1] = 1
console.log(obj);
console.log(newObj);

2. 手写深拷贝

let obj = {code:200,list:[1,2,3,4]}
function deepClone(obj={}) {
    // 首先判断是：基本数据类型 还是 引用数据类型
    if(typeof obj != 'object' || obj == null) {
        return obj
    }
    // 其次区分是数组还是对象
    let result
    if(obj instanceof Array) {
        result = []
    } else {
        result = {}
    }
    // 最后进行遍历
    for(let key in obj) {
        // 如果是原型上的属性，初始化的时候就存在了，所以要保证key不是原型上的属性
        // hasOwnProperty()判断是不是它自身的属性，不在原型上
        if(obj.hasOwnProperty(key)) {   
            result[key] = deepClone(obj[key])   // 递归
        }
    }
    // 返回结果
    return result
}
let newObj = deepClone(obj)
newObj.list[1] = 1
console.log(obj);
console.log(newObj);

如果这个数据包含日期、正则、函数：

let data = {
	name:'你好',
	arr:[1,2,3,4],
	fun:function(){ console.log('aaa') },
	date:new Date(),
	reg:new RegExp('a')
}

// 方法一：JSON.parse(JSON.stringify())
let newData = JSON.parse(JSON.stringify(data))
console.log(data);
console.log(newData);

但是这种方法有缺点：
1.日期类型的数据会变成字符串的形式，而不是对象类型
2.正则类型的数据会变成空对象{}
3.函数会丢失

// 方法二：
function deep(data) {
    if(data && typeof data != 'object') {
        return data
    }
    // 函数我们一般不做处理，用指针指向就行
    if(data instanceof RegExp) {
        return new data.constructor(data)
    }
    if(data instanceof Date){
        return new Date(data.getTime())
    } 
    let result = null
    // 解决指向原型问题
    if(data instanceof Array || data instanceof Object) {
        result = Array.isArray(data) ? [] : {}
        let keys = Object.keys(data)
        keys.forEach(key=>{
            result[key] = deep(data[key])
        })
    }

    // for(let key in data) {
    //     if(data.hasOwnProperty(key)) {
    //         result[key] = deep(data[key])
    //     }
    // }
    return result
}
let newData = deep(data)
newData.arr[0] = 'uuuu'
console.log(data);
console.log(newData);