ES6

let const

var

• 污染全局变量
• 导致变量提升
• 可以被重复声明

let

• 块级作用域
• 可以解决重复定义问题

const

常量 不会变的量 (地址不变即可)

const obj = {name: 1}
obj = {name: 2} // 只是改变常量的内容，没有改变常量的地址和大小

... 展开运算符

• 合并数组

let arr1 = [1,2,3]
let arr2 = [4,5,6]
let arr3 = [...arr1, ...arr2]

• 深拷贝 浅拷贝

let school = {name: 'zfpx'}
let my = {age: {count: 18}, name: 'jw'} // 里面的count是个对象，是个指针，存放的是个地址
// 把原来的my放在新对象里，用一个新的age把原来的age也拷贝一份
let newMy = {...my, age: {...my.age}}
let all = {...schooll, ...newMy} // 这里的age是18 深拷贝的实现
my.age.count = 100

// 自己实现一个深拷贝的方法
// 掌握类型判断 typeof instanceof object.prototype.toString.call() constructor

function deepClone(obj) {// 判断obj是null还是undefined
    if (obj==null) return obj
    // 不是对象就不用拷贝了
    if (obj instanceof Date) return new Date(obj)
    if (obj instanceof RegExp) return new RegExp(obj)
    if (typeof !== 'object') return obj
    // 剩下的是数组或者对象
    let cloneObj= new obj.constructor
    // 用for in 来遍历数组和对象
    for (let key in obj) { // 实现深拷贝
        if(obj.hasOwnProperty(key)) { // 遍历私有属性
            cloneObj[key] = deepClone(obj[key])
        }
    }
    return cloneObj
}
deepClone()

set / map 是两种存储解构

set 集合 不能重复的东西，放了，就白放了，去重

let s = new Set([1,2,3,4])
typeof s // set
// 基础数据类型 string number boolean undefined object 私有，bol

• 添加和删除 并且没有顺序

s.add('5') // 增加
s.delete('5') // 删除
s.values()

• 集合 并集 交集 差集

let s01 = [1,2,3,1,2]
let s02 = [3,4,5,1,2]

// 并集
function union() {
    let s1 = new Set(s01)
    let s2 = new Set(s02)
    console.log([...new Set([...s1,...s2])])
}
// 交集
function intersection() {
   return [...new Set(s01)].filter(v => new Set(s02).has(v))
}

// 差集
function diff() {
   return [...new Set(s01)].filter(v => !new Set(s02).has(v)) // 取出相差的部分留下来
}

map

map 是有key的，不能放重复

let m = new Map()
m.set('name', 'zfjg')
m.set('name', '124')
let obj = {name: 1}
m.set(obj, '456') // 这个obj的引用空间被set所引用
obj = null // 把obj清空 这个空间还是在的
console.log(obj) // null
console.log(m) // {name =>'123', {name:1} => '456'}

weakMap 弱链接 map的区别 回收机制

• WeakMap 弱链接集合 的key 必须是对象类型

// 修改深拷贝代码 解决循环引用问题
function deepClone(obj, hash=new Map()) {// 判断obj是null还是undefined
    if (obj==null) return obj
    // 不是对象就不用拷贝了
    if (obj instanceof Date) return new Date(obj)
    if (obj instanceof RegExp) return new RegExp(obj)
    if (typeof !== 'object') return obj
    if (hash.has(obj)) return hash.get(obj) // 如果weakMap中有对象就直接返回
    // 剩下的是数组或者对象
    let cloneObj= new obj.constructor
    // 如果是对象，把他放到weakMap中，如果再拷贝这个对象存在 就直接返回这个对象即可
    hash.set(obj, cloneObj)
    // 用for in 来遍历数组和对象
    for (let key in obj) { // 实现深拷贝
        if(obj.hasOwnProperty(key)) { // 遍历私有属性
            cloneObj[key] = deepClone(obj[key]， hash)
        }
    }
    return cloneObj
}
deepClone()

object.defineProperty es5 vue

// 通过object.defineProperty定义属性，可以增加拦截器