分别使用 Object.defineProperty 、Proxy 实现简单实现 Vue 响应式

使用 Object.defineProperty 实现

使用 Object.defineProperty 实现基本的 Vue 响应式

基本实现 set

function updateView() {
    console.log("视图更新")
}

function defineReactive(target, key, value) {
    Object.defineProperty(target, key, {
        get() {
            return value
        },
        set(newValue) {
            if (newValue !== value) {
                value = newValue
                updateView()
            }
        }
    })
}

function observer(target) {
    if (typeof target !== 'object' || target === null) {
        return target
    }

    for (let key in target) {
        defineReactive(target, key, target[key])
    }
}

const data = {
    name: 'zhangasn',
    age: 20,
    info: {
        address: '北京'
    },
    nums: [10, 20, 30]
}

observer(data)

data.name = 'lisi' // 视图更新 lisi
data.age = 21 // 视图更新 21
data.info.address = '上海' // 暂未实现
data.nums.push(4) // 暂未实现

上面代码简单实现了 set 时响应视图更新。但深度内容及 push 方法暂无反应，需要额外处理。

深度监听

需要在进入 defineReactive 以及 set 的时候再次监听。

function defineReactive(target, key, value) {

    // 深度监听
    observer(value)

    Object.defineProperty(target, key, {
        get() {
            return value
        },
        set(newValue) {
            if (newValue !== value) {
                // 深度监听
                observer(newValue)

                value = newValue
                updateView()
            }
        }
    })
}

data.info.address = '上海' // 视图更新 上海

监听数组

默认 Object.defineProperty 是不会对数组进行操作，需要额外处理。

需要先对数组原型进行浅复制，然后在进行扩展。

const oldArrayProperty = Array.prototype
const arrProto = Object.create(oldArrayProperty);

['push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse'].forEach(methodName => {
    arrProto[methodName] = function () {
        updateView() // 触发视图更新
        oldArrayProperty[methodName].call(this, ...arguments)
    }
})

function observer(target) {
    if (typeof target !== 'object' || target === null) {
        return target
    }

    // 避免全局 Array 被污染
    if (Array.isArray(target)) {
        // Object.__proto__ 这是应避免的方法
        // target.__proto__ = arrProto
        
        // Object.setPrototypeOf() 方法设置一个指定的对象的原型 ( 即, 内部[[Prototype]]属性）到另一个对象或  null。
        Object.setPrototypeOf(target, arrProto)
    }

    for (let key in target) {
        defineReactive(target, key, target[key])
    }
}

data.nums.push(40) // 视图更新

大致雏形

// 触发更新视图
function updateView() {
    console.log('视图更新')
}

// 重新定义数组原型
const oldArrayProperty = Array.prototype
// 创建新对象，原型指向 oldArrayProperty ，再扩展新的方法不会影响原型
const arrProto = Object.create(oldArrayProperty);
['push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse'].forEach(methodName => {
    arrProto[methodName] = function () {
        updateView() // 触发视图更新
        oldArrayProperty[methodName].call(this, ...arguments)
        // Array.prototype.push.call(this, ...arguments)
    }
})

// 重新定义属性，监听起来
function defineReactive(target, key, value) {
    // 深度监听
    observer(value)

    // 核心 API
    Object.defineProperty(target, key, {
        get() {
            return value
        },
        set(newValue) {
            if (newValue !== value) {
                // 深度监听
                observer(newValue)

                // 设置新值
                // 注意，value 一直在闭包中，此处设置完之后，再 get 时也是会获取最新的值
                value = newValue

                // 触发更新视图
                updateView()
            }
        }
    })
}

// 监听对象属性
function observer(target) {
    if (typeof target !== 'object' || target === null) {
        // 不是对象或数组
        return target
    }

    // 避免全局 Array 被污染
    if (Array.isArray(target)) {
        // Object.__proto__ 这是应避免的方法
        // target.__proto__ = arrProto
        
        // Object.setPrototypeOf() 方法设置一个指定的对象的原型 ( 即, 内部[[Prototype]]属性）到另一个对象或  null。
        Object.setPrototypeOf(target, arrProto)
    }

    // 重新定义各个属性（for in 也可以遍历数组）
    for (let key in target) {
        defineReactive(target, key, target[key])
    }
}

// 准备数据
const data = {
    name: 'zhangsan',
    age: 20,
    info: {
        address: '北京' // 需要深度监听
    },
    nums: [10, 20, 30]
}

// 监听数据
observer(data)

// 测试
data.name = 'lisi'   // 视图更新 lisi
data.age = 21  // 视图更新 21
data.info.address = '上海' // 视图更新，深度监听
data.nums.push(4) // 视图更新，监听数组

// data.x = '100' // 新增属性，监听不到 —— 所以有 Vue.set
// delete data.name // 删除属性，监听不到 —— 所有有 Vue.delete

使用 Proxy 实现

使用 Proxy 实现基本的 Vue 响应式，可以省略很多东西

function updateView() {
    console.log("视图更新")
}

function proxyReactive(target) {
    if (typeof target === 'object') {

		for (let key in target) {
			if (typeof target[key] === 'object') {
				target[key] = proxyReactive(target[key]);
			}
		}

	}

    return new Proxy(target, {
        set: function (target, propKey, value, receiver) {
            // 如果前后两次的value相同，则直接跳过，不做处理
            if(target[propKey] === value){
                return true;
            }

            // 操作数组时会触发两次 set，一次数据改变，一次 length 改变
            if (Array.isArray(target) && propKey === "length") {
                return true;
            }
            
            updateView()
            return Reflect.set(target, propKey, value, receiver);
        }
    })
}

function observer(target) {
    if (typeof target !== 'object' || target === null) {
        return target
    }

    return proxyReactive(target)
}

const dataObj = {
    name: 'zhangasn',
    age: 20,
    info: {
        address: '北京'
    },
    nums: [10, 20, 30]
}

const data = observer(dataObj)

data.name = 'lisi' // 视图更新
data.age = 21 // 视图更新
data.info.address = '上海' //  视图更新
data.nums.push(4) //  视图更新