Vue3.0 中 Object.defineProperty 的代替方案 Proxy

Object.defineProperty or Proxy 均可以對對象進行劫持 Vue 3.0 之前響應式處理都是使用 Object.definProperty 來處理的，3.0 已經轉向 Proxy 了 接下來咱們來看看 Proxy 都有哪些好處

不瞭解 Object.defineProperty 的同窗能夠戳這裏

Proxy 參數

target 目標對象（對象、數組、函數） handler 代理對象，能夠對目標對象進行自定義的操做

Proxy 的基本使用

hanlder.apply() 用於攔截函數的調用

const p2 = new Proxy((a, b) => {
    return a + b
}, {
    apply(target, thisArg, argus) {
        // 將結果返回出去
        return target.apply(thisArg, argus)
    }
})

// p2(1, 2) 實際上調用的是 handler.apply 方法
// 只有目標對象是函數的時候 纔會主動觸發 handler.apply
console.log(p2(1, 2))
複製代碼

handler.construct() 方法用於攔截new 操做符

必須返回一個對象

const p3 = new Proxy(function Person(name) {
    this.name = name
}, {
    construct(target, argus, newTarget) {
        console.log(newTarget === p3)
        return new target(...argus)
    }
})

console.log(new p3('Tom'))
複製代碼

handler.defineProperty() 用於攔截對對象的 Object.defineProperty() 操做

必須返回一個布爾值 表示操做是否成功

const obj2 = {
    a: 1,
    b: 2
}
const p4 = new Proxy(obj2, {
    defineProperty(target, property, descriptor) {
        return Object.defineProperty(...arguments)
    }
})

Object.defineProperty(p4, 'a', {
    value: 'a'
})
console.log(obj2)
複製代碼

handler.deleteProperty() 方法用於攔截對對象屬性的 delete 操做。

必須返回一個布爾值 表示操做是否成功

const p5 = new Proxy({
    a: 1,
    b: 2
}, {
    deleteProperty(target, property) {
        delete target[property]
        return true
    }
})

delete p5.a
console.log(p5)
複製代碼

handler.get() 方法用於攔截對象的讀取屬性操做。

const p6 = new Proxy({
    a: 1,
    b: 2
}, {
    get(target, property, receiver) {
        console.log(receiver === p6)
        return target[property]
    }
})

console.log(p6.a)
複製代碼

handler.getOwnPropertyDescriptor() 方法是 Object.getOwnPropertyDescriptor() 的鉤子。

必須返回一個對象 or undefined

const obj1 = {}
Object.defineProperty(obj1, 'a', {
    value: 1,
    configurable: true
})

const p7 = new Proxy(obj1, {
    getOwnPropertyDescriptor(target, property) {
        return Object.getOwnPropertyDescriptor(...arguments)
    }
})

console.log(Object.getOwnPropertyDescriptor(p7, 'a'))
複製代碼

handler.getPrototypeOf() 是一個代理（Proxy）方法，當讀取代理對象的原型時，該方法就會被調用。

const p8 = new Proxy({
   a: 1,
   b: 2
}, {
   getPrototypeOf(target) {
       return function Person() {}
   }
})

console.log(Object.getPrototypeOf(p8))
複製代碼

handler.has() 方法是針對 in 操做符的代理方法。

必須返回一個布爾值 表示是否存在

const p9 = new Proxy({
    a: 1,
    b: 2
}, {
    has(target, property) {
        // return false
        return property in target
    }
})

console.log('a' in p9)
複製代碼

handler.isExtensible() 方法用於攔截對對象的Object.isExtensible() 。

Object.isExtensible() 方法判斷一個對象是不是可擴展的（是否能夠在它上面添加新的屬性）。

const p10 = new Proxy(Object.freeze({
    a: 1,
    b: 2
}), {
    isExtensible(target) {
        return Object.isExtensible(target)
    }
})

console.log(Object.isExtensible(p10))
複製代碼

handler.ownKeys() 方法用於攔截 Reflect.ownKeys().

const sy = Symbol('secret')
const p11 = new Proxy({
    a: 1,
    [sy]: 'I am scared!',
    b: 2
}, {
    ownKeys(target) {
        console.log('isExtensible')
        return Object.keys(target)
        // return Reflect.ownKeys(target)
        // return Object.getOwnPropertyNames(target)
        // return Object.getOwnPropertySymbols(target)
    }
})

console.log(Object.getOwnPropertyNames(p11))
複製代碼

handler.preventExtensions() 方法用於設置對Object.preventExtensions()的攔截

返回一個布爾值 Object.preventExtensions()方法讓一個對象變的不可擴展，也就是永遠不能再添加新的屬性。

const p12 = new Proxy({
    a: 1,
    b: 2
}, {
    preventExtensions(target) {
        target.c = 'c'
        Object.preventExtensions(target)
        target.d = 'd'
        return true
    }
})

console.log(Object.preventExtensions(p12))
複製代碼

handler.set() 方法是設置屬性值操做的捕獲器。

const p13 = new Proxy({
    a: 1,
    b: 2,
    _c: 3
}, {
    set(target, property, value) {
        console.log('oldVlu: ' + target[property])
        if (property[0] === '_') return console.log('私有屬性不能修改')
        target[property] = value
        return true
    }
})

p13.a = 'a'
p13._c = 'c'
console.log(p13)
複製代碼

handler.setPrototypeOf() 方法主要用來攔截 Object.setPrototypeOf().

const p14 = new Proxy({
    a: 1,
    b: 2,
    _c: 3
}, {
    setPrototypeOf(target, prototype) {
        Object.setPrototypeOf(...arguments)
        return true
    }
})

Object.setPrototypeOf(p14, function Person() {})
console.log(p14.__proto__)
複製代碼

Proxy 共有 13 種對對象劫持方式 相對於 Object.definProperty 的選擇性更廣

Proxy 對對象的響應式處理

const log = console.log.bind(window)

const _target = {
    id: 1,
    name: 'Tom',
    friends: [
        {
            id: 2,
            name: 'Skill'
        },
        {
            id: 3,
            name: 'Gree'
        }
    ],
    like: {
        movie: true,
        running: true,
        volleyball: false
    }
}

const handler = {
    get(target, property, receiver) {
        log(`get ${property} attr`)
        //log(target[property])

        const value = target[property]

        // 當屬性的值是對象類型的時候，須要將其轉換成 Proxy
        // __isProxy__ 判斷當前對象 是否是 Proxy 對象
        if (!value.__isProxy__) {
            if (typeof value === 'object' && typeof value !== null) {
                Object.defineProperty(value, '__isProxy__', {
                    value: true,
                    writable: false,
                    enumerable: false
                })
                Reflect.set(receiver, property, new Proxy(target[property], handler))
            }
        }

        return Reflect.get(...arguments)
        // return target[property]
    },
    set(target, property, value) {
        log(`set ${property} attr`)
        log(value)
        
        Reflect.set(...arguments)
        return true
        // target[property] = value
    }
}

const target = new Proxy(_target, handler)

log(target.id)
log(target.friends[0].name)
log(target.like.movie)

target.age = 23
target.like.movie = false
target.friends.push({ name: 'Owen', id: 4 })

log(target.friends[2])

log(target)
複製代碼

Proxy 跟 Object.defineProperty 的對比

優勢：

• 不須要遞歸遍歷每一個屬性，添加劫持，深層對象屬性只有在訪問的時候才轉換成 Proxy
• 對新增的屬性不須要另外作劫持處理
• 不須要對數組的方法進行重定義

缺點： 不兼容 ie

【筆記不易，如對您有幫助，請點贊，謝謝】