简易源码

# 简易源码

observe.js

// 触发更新视图
function uodateView() {
  console.log("视图更新");
}

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

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

  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 原型
  // Array.prototype.push = function () {
  //     updateView()
  //     ...
  // }
  if (Array.isArray(target)) {
      target.__proto__ = arrProto
  }

  // 重新定义各个(访问器)属性,主要是利用访问器属性的特性:set、get
  for(let key in target) {
    defineReactive(target, key, target[key[]])
  }
}

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

// 监听数据
observer(data)

# 源码分析

  • 关于深度监听
  1. 对于传进 defineReactive 的每个 value 都需要深度监听
/*
  data.info还是一个对象也需要监听,故在defineReactive开头进行递归
  递归出口为传入的value不再是对象
*/
  1. 赋值时也需深度监听
/*
  如果在赋值时不进行深度监听
  那么将data的age从一个数变成一个对象时,比如data.age = {num: 20},
  后续对data.age.num进行修改时不会更新视图
*/
```

- 关于数组的监听

```js
/*
  这里主要是利用Obejct.create重新定义了数组原型,并重写了对应的方法
  重写之后可以进行视图更新,并且不会污染全局的数组原型
*/

# 缺点分析

  1. 为了监听一次递归到底

  2. 无法新增/删除属性(Vue.set/Vue.delete)

  3. 无法监听数组,需要特殊处理

# Vue.set

function set(target, key, val) {
  // 传入的target是否是null、undefined或是原始类型(string, number, boolean, symbol);
  // 如果是就抛出警告。
  if (isUndef(target) || isPrimitive(target)) {
    warn(
      "Cannot set reactive property on undefined, null, or primitive value: " +
        target
    );
  }
  // 判断target是否是一个数组,并且key值是否是合法key
  if (Array.isArray(target) && isValidArrayIndex(key)) {
    // 将target.length设置为target.length和key最大的值
    // 防止某些情况下会报错,比如: 设置的key值,大于数组的长度。
    target.length = Math.max(target.length, key);
    // 将key位置的值替换为val
    // 调用splice的时候就会重新渲染新的视图
    // 因为Vue为了实现数组的响应式劫持了splice方法,并重新实现
    target.splice(key, 1, val);
    return val;
  }
  // 如果target对象上已经存在key,且这个key不是Object原型对象上的属性
  // 说明key这个属性已经是响应式的了,那么就则直接将val赋值给这个属性
  if (key in target && !(key in Object.prototype)) {
    target[key] = val;
    return val;
  }
  // __ob__指的是Observer对象
  // vmCount用来表示当前对象是否是根级属性
  // _isVue用来表示是否是Vue实例
  // target不能是根级属性或者Vue实例
  var ob = target.__ob__;
  if (target._isVue || (ob && ob.vmCount)) {
    warn(
      "Avoid adding reactive properties to a Vue instance or its root $data " +
        "at runtime - declare it upfront in the data option."
    );
    return val;
  }
  // 如果target上不存在Observer对象(这说明target只是一个普通的对象,不是一个响应式数据)
  // 直接赋值给key属性
  if (!ob) {
    target[key] = val;
    return val;
  }
  // ob.value其实就是target,只不过它是Vue实例上$data里的已经被追踪依赖的对象
  // 然后在这个被observed的对象上增加key属性。让key属性也转为getter/setter。
  defineReactive$$1(ob.value, key, val);
  // 让dep通知所有watcher重新渲染组件
  ob.dep.notify();
  return val;
}