数据代理是指通过一个对象代理另一个对象中属性的（读/写）操作。

数据代理的原理

数据代理可以通过Object.defineProperty()实现。在Vue中，很多技术的实现都使用到了Object.defineProperty()这个方法。

Object.defineProperty()的用法如下所示：

 1let person = {
 2  name: '张三',
 3  sex: '男',
 4  // age: 18,
 5}
 6
 7/**
 8 * 使用 Object.defineProperty() 给对象添加属性
 9 * 1. 参数1：要添加属性的对象
10 * 2. 参数2：要给对象添加的属性名称
11 * 3. 参数3：要添加的属性的配置
12 */
13Object.defineProperty(person, 'age', {
14  value: 18,  // 定义属性的值
15  enumerable: true, // 控制属性是否可枚举，默认为false
16  writable: true, // 控制属性是否可被写入（修改），默认为false
17  configurable: true, // 控制属性是否可被删除，默认为false
18})
19
20console.log(person);
21// console.log(Object.keys(person));

 1let articleSize = 100
 2
 3let article = {
 4  name: 'Vue',
 5  // size: articleSize,
 6}
 7
 8Object.defineProperty(article, 'size', {
 9  /**
10   * Getter：
11   * 当article.size被读取时，get()会被调用，并且将返回值作为article.size的值
12   */
13  get() {
14    console.log('The article.size is read.');
15    return articleSize
16  },
17
18  /**
19   * Setter：
20   * 当article.size被修改时，set()会被调用，并且将参数value作为article.size的值
21   */
22  set(value) {
23    console.log(`The article.size is modified to ${value}.`);
24    articleSize = value
25  },
26})
27
28console.log(article);

假设有两个对象obj1和obj2，需要能通过obj2来修改obj1，可以这样实现：

 1let obj1 = {x: 100}
 2let obj2 = {y: 200}
 3
 4Object.defineProperty(obj2, 'x', {
 5  get() {
 6    return obj1.x
 7  },
 8  set(value) {
 9    obj1.x = value
10  }
11})

Vue 数据代理

Vue实例实际上是Vue实例中的data的数据代理对象。Vue实例中的data通过数据代理，将其对象中的属性交予Vue实例来直接管理。

验证Vue数据代理：

 1<!DOCTYPE html>
 2<html lang="en">
 3<head>
 4  <meta charset="UTF-8">
 5  <meta name="viewport" content="width=device-width, initial-scale=1.0">
 6  <script src="https://cdn.jsdelivr.net/npm/vue@2.7.14/dist/vue.js"></script>
 7  <title>数据代理</title>
 8</head>
 9<body>
10  <div id="app">
11    <h1>姓名：{{name}}</h1>
12    <h1>年龄：{{age}}</h1>
13  </div>
14
15  <script type="text/javascript">
16    const data = {
17      name: '张三',
18      age: '18',
19    }
20
21    const vm = new Vue({
22      el: "#app",
23      data,
24    });
25
26    console.log(data);
27    console.log(vm);
28
29    console.log(`vm._data === data ??? ${vm._data === data}`);
30  </script>
31</body>
32</html>

实际上，Vue对象在实例化时，会将配置（options）中的data实例化为vm._data。所以实际上vm对象代理的是vm._data对象。

由于Vue模板语法中，在使用插值时获取的是Vue实例中的对象。如果Vue没有使用数据代理，那么要获取data中的数据，相应的表达式应该写作{{_data.name}}（假设获取name）。当使用了数据代理，data中的对象可以通过Vue实例对象来进行操作，那么表达式就可以直接写作{{name}}。

Vue 计算属性

Vue.js计算属性在处理一些复杂逻辑时是很有用的。

计算属性的关键词是computed，在Vue实例的配置中指定computed即可定义计算属性。

Vue计算属性示例如下：

 1<div id="app">
 2  姓：<input type="text" v-model="firstName"><br><br>
 3  名：<input type="text" v-model="lastName"><br><br>
 4  姓名：<input type="text" v-model="fullName">
 5</div>
 6<script type="text/javascript">
 7  new Vue({
 8    el: "#app",
 9    data: {
10      firstName: '张',
11      lastName: '三',
12    },
13    computed: {
14      fullName: {
15        get() {
16          // 此处的 this 依旧是指向 vm
17          return this.firstName + '-' + this.lastName
18        },
19        set(value) {
20          const arr = value.split('-')
21          this.firstName = arr[0]
22          this.lastName = arr[1]
23        },
24      },
25    },
26  });
27</script>

计算属性中有两种方法（就像数据代理一样）：

Getter：

作用：当对应的计算属性（如上例为fullName）被读取时，get()就会被调用，且返回值作为该计算属性的值。

Vue对计算属性做了缓存，所以当计算属性被读取时，并不总是会调用get()方法。

计算属性的get()方法被调用的时机：
1. 初次读取该计算属性时。
2. 所依赖的数据（这类数据必须是由Vue来管理的数据，如firstName、lastName）发生变化时。其它不被依赖的属性发生改变时， get() 方法不会被调用。
常见的计算数据不需要修改，因此仅使用Getter即可。当仅使用Getter时，可以使用以下简写形式：
```
1computedAttribute() {
2  /* ... */
3}
```
即，将计算属性使用函数式定义（上方所示是对象式定义），该函数即用作该计算属性的get()。例如将上例修改为仅使用Getter的简写形式：
```
 1new Vue({
 2  el: "#app",
 3  data: {
 4    firstName: '张',
 5    lastName: '三',
 6  },
 7  computed: {
 8    fullName() {
 9      // 此处的 this 依旧是指向 vm
10      return this.firstName + '-' + this.lastName
11    },
12  },
13});
```
Setter：

如果计算属性会被用户修改，则需要使用Setter；否则，Setter可省略。

作用：当对应的计算属性被修改时，set()就会被调用，且返回值作为该计算属性的值。

使用计算属性的好处：与methods相比，计算属性内部有缓存机制（复用），效率更高，更加方便调试。

注：计算属性不能与data属性重名。

Vue 监听属性

通过Vue.js提供的监听属性watch来响应数据的变化。

例如：

 1<div id="app">
 2    <h2>今天天气很{{info}}</h2>
 3    <button @click="isHot = !isHot">切换天气</button>
 4</div>
 5<script type="text/javascript">
 6  new Vue({
 7    el: "#app",
 8    data: {
 9      isHot: true,
10    },
11    computed: {
12      info() {
13        return this.isHot ? '炎热' : '凉爽'
14      }
15    },
16    watch: {
17      info: {
18        immediate: true,  // 初始化时执行 handler()
19        handler(newValue, oldValue) {
20          const update = {
21            newValue,
22            oldValue,
23          }
24          console.log('The attribute "info" was updated: ');
25          console.log(update);
26        },
27      }
28    }
29  });
30</script>

在watch中，将要监听的属性直接作为watch配置的属性定义即可（名称要相同）。如上例，要监听计算属性info，则直接在watch中定义info即可。
watch可监听的属性包括data、computed中的属性。
Handler：当监听的属性发生改变时，其对应的handler()方法会被调用。

如果在监听属性的配置中，不需要添加其它属性来修改配置（仅定义了handler()时），可以使用以下简写形式来定义：

1watchingAttribute() {
2  /* handler ... */
3}

即函数式定义监听属性，定义的函数将作为该属性的handler()所使用。如上例，将其修改为仅定义Handler的简写形式：

 1new Vue({
 2  el: "#app",
 3  data: {
 4    isHot: true,
 5  },
 6  computed: {
 7    info() {
 8      return this.isHot ? '炎热' : '凉爽'
 9    }
10  },
11  watch: {
12    info() {
13      const update = {
14        newValue,
15        oldValue,
16      }
17      console.log('The attribute "info" was updated: ');
18      console.log(update);
19    }
20  }
21});

监听属性还有另外一种定义的形式，使用Vue示例对象的方法vm.$watch()来定义。

vm.$watch()接受两个参数：

参数1：指定监听的属性。
参数2：该监听属性的配置对象（与在Vue示例中的配置对象一样）。

例如：

 1const vm = new Vue({
 2  el: "#app",
 3  data: {
 4    isHot: true,
 5  },
 6  computed: {
 7    info() {
 8      return this.isHot ? '炎热' : '凉爽'
 9    }
10  },
11});
12
13vm.$watch('info', {
14  immediate: true,
15  handler(newValue, oldValue) {
16    const update = {
17      newValue,
18      oldValue,
19    }
20    console.log('The attribute "info" was updated: ');
21    console.log(update);
22  },
23});

仅配置Handler时，简写形式如下：

1vm.$watch('info', function (newValue, oldValue) {
2  const update = {
3    newValue,
4    oldValue,
5  }
6  console.log('The attribute "info" was updated: ');
7  console.log(update);
8});

Vue 深度监听

Vue中的watch：

watch默认不监测对象内部值的改变（只监视对象整体的改变）。
配置deep: true可以监测对象内部值的改变（监视对象多层内部属性的改变）。

 1<div id="app">
 2  <h2>numbers.x = {{numbers.x}}</h2>
 3  <button @click="numbers.x++">x + 1</button>
 4  <button @click="numbers.x = 0">x = 0</button>
 5  <h2>numbers.y = {{numbers.y}}</h2>
 6  <button @click="numbers.y++">y + 1</button>
 7  <button @click="numbers.y = 0">y = 0</button><br><br>
 8  <button @click="numbers = {x: 666, y: 233}">改变 numbers</button>
 9</div>
10<script type="text/javascript">
11  const vm = new Vue({
12    el: "#app",
13    data: {
14      numbers: {
15        x: 0,
16        y: 0,
17      }
18    },
19    watch: {
20      // 监听对象内部属性
21      'numbers.x': {
22        handler(newValue, oldValue) {
23          console.log({
24            variable: 'numbers.x',
25            newValue,
26            oldValue,
27          });
28        },
29      },
30      'numbers.y': {
31        handler(newValue, oldValue) {
32          console.log({
33            variable: 'numbers.y',
34            newValue,
35            oldValue,
36          });
37        },
38      },
39      // 监听对象内部多层级属性
40      numbers: {
41        deep: true, // 开启监听多级结构中所有属性的变化（深度监视）
42        handler(newValue, oldValue) {
43          console.log({
44            variable: 'numbers',
45            newValue,
46            oldValue,
47          });
48        }
49      }
50    }
51  });
52</script>

其中，提供了另外一种用于监听对象内部属性变化的watch简写形式：

1'numbers.y'(newValue, oldValue) {
2  /* ... */
3},

对计算属性中的案例进行修改，让名字的修改延迟1秒：

 1<div id="app">
 2  姓：<input type="text" v-model="user.firstName"><br><br>
 3  名：<input type="text" v-model="user.lastName"><br><br>
 4  姓名：<span>{{user.fullName}}</span>
 5</div>
 6<script type="text/javascript">
 7  new Vue({
 8    el: "#app",
 9    data: {
10      user: {
11        firstName: '张',
12        lastName: '三',
13        fullName: '张-三',
14      },        
15    },
16    watch: {
17      user: {
18        deep: true,
19        handler(val) {
20          /**
21           * 延迟 1s 进行修改
22           * 这里的setTimeout()不能使用 function 定义的函数，只能使用lambda，因为使用function的话函数中的this指向的是window
23           */
24          setTimeout(() => {
25            this.user.fullName = val.firstName + '-' + val.lastName
26          }, 1000)
27        }
28      },
29    }
30  });
31</script>

计算属性不能进行异步操作，所以在有些情况下使用监听属性相对较好。

由Vue管理的函数，最好以普通函数function() {}的形式去定义；而其它不被Vue所管理的函数（例如定时器回调函数、Ajax回调函数、Promise回调函数），最好使用lambda表达式() => {}的形式去定义。

数据劫持

Vue加载data配置和data中的数据发生更新的过程大致如下：

加工data配置。

Vue为data中每个属性都通过Object.defineProperty()添加了Getter和Setter（响应式处理）。当对data中的属性进行更改时，会自动调用对应的Setter。当调用Setter时，Setter会自动解析模板中对应的内容。

Setter调用时执行的流程大致如下：

重新解析模板，生成新的虚拟DOM。
新旧虚拟DOM对比。
更新页面。

Vue中Getter和Setter的大致实现方式如下：

 1let data = {
 2  x: 1,
 3  y: 1000,
 4}
 5
 6// 创建监视者实例对象，用于监视data中属性的变化
 7const obs = new Observer(data)
 8
 9// 模拟Vue实例对象
10let vm = {}
11vm._data = data = obs
12
13function Observer(obj) {
14  // 汇总对象中所有的属性形成一个数组
15  const keys = Object.keys(obj)
16  // 遍历
17  keys.forEach((key) => {
18    Object.defineProperty(this, key, {
19      get() {
20        return obj[key]
21      },
22      set(val) {
23        console.log(`${key} 被修改`);
24        console.log('解析模板，生成虚拟DOM');
25        console.log('......');
26        obj[key] = val
27      },
28    })
29  })
30}

Vue通过递归将data中所有的对象及其属性通过Object.defineProperty()的方式设置了Getter和Setter。通过Object.defineProperty()添加Getter和Setter来进行响应式处理的动作叫做数据劫持。

数组中的对象仅会对它们的属性进行响应式处理，而数组中的元素是没有Getter和Setter的（没有进行响应式处理）。

将加工完成的data赋给Vue示例的_data属性。即vm._data = data。

添加新的响应式数据

例如页面中存在需要后续添加的数据：

 1<div id="app">
 2  <h2>姓名：{{user.name}}</h2>
 3  <h2>性别：{{user.sex}}</h2>
 4  <h2>年龄：</h2>
 5  <ul>
 6    <li>真实年龄：{{user.age.rAge}}</li>
 7    <li>对外年龄：{{user.age.sAge}}</li>
 8  </ul>
 9  <hr>
10  <h2>好友：</h2>
11  <table>
12    <thead><tr><td>姓名</td><td>年龄</td></tr></thead>
13    <tbody>
14      <tr v-for="(friend, index) in user.friends" :key="index">
15        <td>{{friend.name}}</td><td>{{friend.age}}</td>
16      </tr>
17    </tbody>
18  </table>
19</div>
20<script type="text/javascript">
21  const vm = new Vue({
22    el: "#app",
23    data: {
24      user: {
25        name: '张三',
26        // sex: '男',
27        age: {
28          rAge: 40,
29          sAge: 29,
30        },
31        friends: [
32          {name: '李四', age: 35},
33          {name: '王五', age: 36},
34        ]
35      }
36    },
37  });
38</script>

这部分后续添加的数据（如上例中的user.sex），直接为其赋值（vm._data.user = '男'）并不能让页面产生改变。这是因为在Vue实例中，后续添加的数据Vue并不会自动帮它们进行响应式数据处理（即通过Object.defineProperty()添加Getter和Setter）。

为了解决这些问题，Vue提供了一个Vue.set()方法来为Vue实例或Vue组件实例中的数据对象添加新的响应式数据。Vue.set()方法的参数如下：

参数1（target）：要添加属性的对象。
参数2（key）：要为target添加的属性名称。
参数3（value）：要为target对象添加的key属性所赋的值。

如上例，可以使用以下方式添加响应式数据user.sex：

1Vue.set(vm._data.user, 'sex', '男')

此时页面才能进行正常的更新。

在Vue实例中也存在这样的方法，即vm.$set()方法（参数与Vue.set()一致）。如上例，添加响应式数据user.sex的另一种方式：

1vm.$set(vm.user, 'sex', '男')

Vue.set()和vm.$set()中参数target的前缀可以是vm._data也可以是vm这是因为在Vue实例vm中，Vue将vm._data中的一些属性交给了vm来代理（数据代理）。

对上例进行修改：

 1<div id="app">
 2  <button @click="addSex">添加性别（默认值是男）</button>
 3  <h2>姓名：{{user.name}}</h2>
 4  <h2 v-if="user.sex">性别：{{user.sex}}</h2>
 5  <h2>年龄：</h2>
 6  <ul>
 7    <li>真实年龄：{{user.age.rAge}}</li>
 8    <li>对外年龄：{{user.age.sAge}}</li>
 9  </ul>
10  <hr>
11  <h2>好友：</h2>
12  <table>
13    <thead><tr><td>姓名</td><td>年龄</td></tr></thead>
14    <tbody>
15      <tr v-for="(friend, index) in user.friends" :key="index">
16        <td>{{friend.name}}</td><td>{{friend.age}}</td>
17      </tr>
18    </tbody>
19  </table>
20</div>
21<script type="text/javascript">
22  new Vue({
23    el: "#app",
24    data: {
25      user: {
26        name: '张三',
27        // sex: '男',
28        age: {
29          rAge: 40,
30          sAge: 29,
31        },
32        friends: [
33          {name: '李四', age: 35},
34          {name: '王五', age: 36},
35        ]
36      }
37    },
38    methods: {
39      addSex() {
40        this.$set(this.user, 'sex', '男')
41      }
42    }
43  });
44</script>

Vue.set()和vm.$set()的使用有一些局限性。它们在使用时不允许target为Vue实例对象或Vue实例对象的直接数据对象（如_data等，Vue组件实例对象也一样）。

在Vue中，后续添加的新对象，如果添加的方式满足Vue的规范，添加的元素Vue会对其进行响应式处理。

Vue 数组的修改

在Vue中，对数组的某些修改并不会使页面发生改变。例如直接使用数组索引对元素赋值(如list[0] = 0)。这是因为Vue在加载和更新时并不会对数组中元素的本身作响应式处理（但是数组中对象元素的属性会做响应式处理），所以导致直接使用索引对数组元素赋值的修改并不会使页面发生改变。

问题演示：

 1<div id="app">
 2  <h2>姓名：{{user.name}}</h2>
 3  <h2>年龄：</h2>
 4  <ul>
 5    <li>真实年龄：{{user.age.rAge}}</li>
 6    <li>对外年龄：{{user.age.sAge}}</li>
 7  </ul>
 8  <hr>
 9  <h2>好友：</h2>
10  <table>
11    <thead><tr><td>姓名</td><td>年龄</td></tr></thead>
12    <tbody>
13      <tr v-for="(friend, index) in user.friends" :key="index">
14        <td>{{friend.name}}</td><td>{{friend.age}}</td>
15      </tr>
16    </tbody>
17  </table>
18  <hr>
19  <h2>爱好：</h2>
20  <ul>
21    <li v-for="(hobby, index) in user.hobbies" :key="index">
22      {{hobby}}
23    </li>
24  </ul>
25</div>
26<script type="text/javascript">
27  const vm = new Vue({
28    el: "#app",
29    data: {
30      user: {
31        name: '张三',
32        age: {
33          rAge: 40,
34          sAge: 29,
35        },
36        hobbies: ['唱', '跳', 'Rap', '篮球'],
37        friends: [
38          {name: '李四', age: 35},
39          {name: '王五', age: 36},
40        ]
41      }
42    },
43  });
44</script>

在浏览器控制台中使用如下命令修改数组元素，并不会让页面更新：

1vm.user.hobbies[0] = '唱歌'
2vm.user.hobbies[1] = '跳舞'
3vm.user.hobbies[3] = '打篮球'

为了解决这些问题，Vue指定了7个操作数组的方法，并承认它们的操作是对数组进行了修改，所以使用这7个方法对数组进行修改后，页面才能正常更新。Vue指定的这7个操作数组的方法分别是：

方法	说明
`array.push()`	向数组的末尾添加一个或者多个元素，并返回新数组的长度
`array.pop()`	删除并返回数组的最后一个元素
`array.shift()`	删除并返回数组的第一个元素
`array.unshift()`	向数组的开头添加一个或多个元素，并返回新数组的长度
`array.splice()`	删除元素，并向数组添加新元素
`array.sort()`	对数组的元素进行排序
`array.reverse()`	颠倒数组中元素的顺序

这7个方法能奏效是因为Vue对Array.prototype中对应的这7个方法进行了封装。

Vue封装的这7个方法大致上都做了以下两件事：

调用Array.prototype中对应的原生方法。
数据更新引起的模板的解析和页面更改等操作。

在Vue官方文档中，将这7个方法称为数组的变更方法。这7个方法其实是对数组变化的监测。

其实在Vue中修改数组也可以使用Vue.set()和vm.$set()。如上例，在控制台修改其中的数组元素：

1Vue.set(vm._data.user.hobbies, 0, '唱歌')
2vm.$set(vm.user.hobbies, 1, '跳舞')

Vue 数据监听总结

Vue会监听data中所有层次的数据。

监听对象中数据的方式：

通过Setter实现监听，且要在new Vue()时就传入要监测的数据。

在Vue监听对象中需要注意：
- 对象中后追加的属性，Vue默认不做响应式处理。
- 如需给后添加的属性做响应式，请使用如下API：
```
1Vue.set(target, propertyName|index, value)
2vm.$set(target, propertyName|index, value)
```
监听数组中数据的方式：

通过包裹数组更新元素的7个方法实现，本质就是做了两件事：
1. 调用原生（Array.prototype）对应的方法对数组进行更新。
2. 重新解析模板，进而更新页面。
在Vue修改数组中的某个元素一定要用如下方法：
- 使用以下API：
  - array.push()
  - array.pop()
  - array.shift()
  - array.unshift()
  - array.splice()
  - array.sort()
  - array.reverse()
- 使用Vue.set()或vm.$set()
  
  注：Vue.set()和vm.$set()不能给vm或vm的根数据对象添加属性。

Vue 数据代理与监听

目录