前言

记录一些必须掌握的es6

Proxy

如其名，代理，能够对对象的操作进行代理，未代理的都会直接转发到对象上。

const obj = {
    _a: 'obj'
}
const proxyObj = new Proxy(obj, {
    get(target, prop, receiver) {
        console.log(`${prop}: ${target[prop]}`)
        return target[prop]
    },
    set(target, prop, value, receiver) {
        console.log(`set ${prop}: ${value}`)
        target[prop] = value
    }
})

proxyObj.a
// a: obj
// obj
// 打印上面两行

上面可以看出就是对象的代理，函数也是对象的一种，也能对函数的执行，new 示例的执行监听。

• get(target, prop, receiver) 代理 [[get]]
• set(target, prop, value, receiver) 代理[[set]]
• deleteProperty(target, prop, receiver) 代理 [[delete]]
• has(target, prop, receiver) 代理 in 查询对象，以及原型上面是否存在某个属性
• ownKeys(target, receiver) 代理 for in, Object.keys(), getOwnPropertyNames, getOwnPropertySymbols的操作
• defineProperty(target, prop, descriptor) 代理 Object.defineProperty和Object.defineProperties()
• getPrototypeOf() setPrototypeOf()
• apply(target, thisArgs, ...args) 代理函数的调用，包括call或者bind等调用
• constructor() 如果一个代理对象被用作 new 示例，介入执行。

Reflect

翻译成映射，值得是将一些操作映射成函数的执行，从而判断执行的成功与否。

const obj = {
    _a: 'obj'
}
const proxyObj = new Proxy(obj, {
    get(target, prop, receiver) {
        return target._a
    },
})

const objA = Object.create(proxyObj)
objA._a = 'objA'
objA.a // 期待返回ObjA， 结果是 obj
// 改写如下
const proxyObj = new Proxy(obj, {
    get(target, prop, receiver) {
        return Reflect(target, prop, receiver)
    },
})

上面的例子proxy 总是有对应的Reflect来处理某些被忽略的错误的操作。除此之外if(Reflect.set(obj, 'a')) 还能判断是否该操作成功执行

Map 和 Set

Map是哈希表，取代长期使用object当做hash的问题。get, set, has, delete, size, clear，支持迭代 keys, values, entries，forEach。同时还保留了插入顺序迭代，解决了hash表无序问题。支持Map和Object互转 new Map(Object.entries({a: 1})) 或者 Object.formEntries(xxx.entries()),额外的特性还有支持任意类型键

Set 是一个无重复项的hash表(每个值就是一个键)。 add, delete, has，clear, size 和Map一样也支持迭代，本身就是一个可迭代对象，直接for of或者自带forEach 方法。 和Array可以相互转 Array.from(set)

set 常用于数组去重 [...new set([1,1,3,4])] Set 参数支持可迭代对象和数组, 还有当队列用，set.values().next() 总是先入先出

可迭代对象和迭代器

如果一个对象具有Symbol.iterator 属性，这个对象就是可迭代对象，可迭代对象被用于各种地方，比如new Set() Array.from() for of。 Symbol.iterator 返回一个迭代器，任何具有next() 并返回{ value: any, done: boolean }的对象都是一个迭代器，迭代器还能由迭代器生成函数Generator产生(function*() {})

大部分内置对象都实现了迭代接口，比如Array,String,Set,Map

class A {
    [Symbol.iterator]: function*() {
        yield 1;
        yield 2;
        yield 3;
    }
}

for(const i of new A) {
    console.log(i)  // 1 2 3
}

还有一种是可迭代迭代对象，就是迭代器本本身也是一个可迭代对象

const some = ((count) => {
    return {
        [Symbol.iterator]() {
            return this;
        }
        next() {
            if(count >= 5) {
                return { done: false , value }
            }
            return { value: value++, done: false}
        }
    }
})(0)

some.next();  // 可以作为迭代器使用
for(const i of some) {}  // 作为可迭代对象使用

Generator迭代器生成函数

用于生成迭代器，每次迭代器迭代时函数才执行，

function* a(count) {
    console.log(count)
    count = yield 3
    console.log(count)
    return 
} 
b = a(2)
b.next(1)  // 只有yield 才能接受参数，1会被忽略
b.next()  //