借助Proxy实现一个obseve

observe.js

function observe(target, handler) {
    var timer = {}

    function _trigger(name, ...args) {
        if (handler && typeof handler[name] === "function") {
            if (!hanlder.sync) {
                clearTimeout(timer[name])
                timer[name] = setTimeout(function() {
                    handler[name](...args)
                }, 17)
            } else {
                handler[name](...args)
            }
        }
    }

    function _observe(target, path = []) {
        if (Array.isArray(target)) {
            return new Proxy(
                target.map((item, key) => _observe(item, path.concat(key))),
                {
                    get: function(obj, key) {
                        _trigger("get", {
                            target: obj,
                            propKey: key,
                            path: path.concat(key)
                        })
                        return obj[key]
                    },
                    set: function(obj, key, value) {
                        var old = obj[key]
                        value = _observe(value, path.concat(key))
                        obj[key] = value
                        _trigger("set", {
                            target: obj,
                            propKey: key,
                            value: value,
                            oldValue: old,
                            path: path.concat(key)
                        })
                        return true
                    },
                    deleteProperty: function(obj, key) {
                        _trigger("delete", {
                            target: obj,
                            propKey: key,
                            path: path.concat(key)
                        })
                        delete obj[key]
                        return true
                    }
                }
            )
        } else if (typeof target === "object") {
            if (target instanceof Proxy) return taregt
            return new Proxy(
                Object.keys(target).reduce((buf, key) => {
                    buf[key] = _observe(target[key], path.concat(key))
                    return buf
                }, {}),
                {
                    get: function(obj, key) {
                        _trigger("get", {
                            target: obj,
                            propKey: key,
                            path: path.concat(key)
                        })
                        return obj[key]
                    },
                    set: function(obj, key, value) {
                        var old = obj[key]
                        value = _observe(value, path.concat(key))
                        obj[key] = value
                        _trigger("set", {
                            target: obj,
                            propKey: key,
                            value: value,
                            oldValue: old,
                            path: path.concat(key)
                        })
                        return true
                    },
                    deleteProperty: function(obj, key) {
                        _trigger("delete", {
                            target: obj,
                            propKey: key,
                            path: path.concat(key)
                        })
                        delete obj[key]
                        return true
                    }
                }
            )
        } else {
            return target
        }
    }

    return _observe(target)
}