js proxy handler

const handler = {
    // 获取对象的原型
    getPrototypeOf(target) {
       /**
        * trigger:
        *
        * Object.getPrototypeOf()
        * Reflect.getPrototypeOf(target)
        * __proto__
        * Object.prototype.isPrototypeOf()
        * instanceof
        * */
    },
    // 设置对象的原型
    setPrototypeOf(target, prototype) {
       /**
        * trigger：
        *
        * Object.setPrototypeOf()
        * Reflect.setPrototypeOf(target, prototype)
        * */
    },
    // 判断对象是否可扩展
    isExtensible(target) {
        /**
         * trigger：
         *
         * Object.isExtensible()
         * Reflect.isExtensible(target)
         * */
    },
    // 阻止扩展
    preventExtensions(target) {
        /**
         * trigger:
         *
         * Object.preventExtensions()
         * Reflect.preventExtension(target)
         * */
    },
    // 获取自有属性描述符
    getOwnPropertyDescriptor(target, property) {
        /**
         * trigger:
         *
         * Object.getOwnPropertyDescriptor()
         * Reflect.getOwnPropertyDescriptor(target, property)
         * */
    },
    // 设置对象的访问器属性
    defineProperty(target, property, descriptor) {
        /**
         * trigger:
         *
         * Object.defineProperty()
         * Reflect.defineProperty(target, propertyKey, descriptor)
         * */
    },
    // 判断某个property是否存在于对象中
    has(target, property) {
        /**
         * trigger:
         *
         * foo in proxy
         * foo in Object.create(proxy)
         * with(proxy) {(foo)}
         * */
    },
    // 获取对象的属性值
    get(target, property, receiver) {
        /**
         * trigger:
         *
         * proxy[foo] proxy.bar
         * Object.create(proxy)[foo]
         * Reflect.get(target, property, receiver)
         * */
    },
    // 设置对象的属性值
    set(target, property, value, receiver) {
       /**
        * trigger:
        *
        * proxy[foo] = bar proxy.foo = bar
        * Object.create(proxy)[foo] = bar
        * Reflect.set(target, property, value, receiver)
        * */
    },
    // 删除对象的属性
    deleteProperty(target, property) {
       /**
        * trigger:
        *
        * delete proxy[foo] delete proxy.foo
        * Reflect.deleteProperty(target, property)
        * */
    },
    // 函数对象指定运行上下文
    apply(target, thisArg, argumentsList) {
       /**
        * trigger:
        *
        * proxy(...args)
        * Function.prototype.apply() Function.prototype.call()
        * Reflect.apply(target, thisArgument, argumentsList)
        * */
    },
    // 创建实例拦截
    construct(target, argumentsList, newTarget) {
        /**
         * trigger:
         *
         * new proxy(...args)
         * Reflect.construct(target, argumentsList, newTarget)
         * */
    },
};