响应式数据的两种实现方法 

注意 传递给子组件父组件等的数据，也需要是响应式的才能联动。否则就一直是初始值。

Reactive API

当前计数: {{state.counter}}
<button @click="increment">+1button>
 
 import { reactive } from 'vue';
 
  export default {
    setup() {
      const state = reactive({
        counter: 100
      }) // Reactive API 实现响应式数据
 
      // 局部函数
      const increment = () => {
        state.counter++;
      }
 
      return {
        state,
        increment
      }
    }
  }
 
//事实上，我们vue2编写的data选项，也是在内部交给了reactive函数将其编程响应式对象的
reactive API 对传入的类型是有限制的，它要求我们必须传入的是一个对象或者数组类型：
如果我们传入一个基本数据类型（String、Number、Boolean）会报一个警告；
这个时候Vue3给我们提供了另外一个API：ref AP

Ref API

{{counter}}
{{aa.name}}
//template 里为何不勇加 .value? 在模板中引入ref的值时，Vue会自动帮助我们进行解包操作，所以我们并不需要在模板中通过 ref.value 的方式
 
 
import { ref } from 'vue';
 
setup() {
      let counter = ref(100);
      let aa = ref({counter:100});
 
      // 局部函数
      const increment = () => {
        counter.value++; 
        aa.value.counter++;
        //setup 函数内部，它依然是一个 ref 引用， 所以对其进行操作时，我们依然需要使用 ref.value的方式；
 
      }
 
      return {
        counter,
        increment
      }

Readonly

我们通过reactive或者ref可以获取到一个响应式的对象，但是某些情况下，我们传入给其他地方（组件）的这个 响应式对象希望在另外一个地方（组件）被使用，但是不能被修改，这个时候如何防止这种情况的出现呢？

Vue3为我们提供了readonly的方法；

readonly会返回原生对象的只读代理（也就是它依然是一个Proxy，这是一个proxy的set方法被劫持，并且不 能对其进行修改）；

在开发中常见的readonly方法会传入三个类型的参数：

类型一：普通对象；

类型二：reactive返回的对象；

类型三：ref的对象；

import { reactive, ref, readonly } from 'vue';
// 1.普通对象
      const info1 = {name: "why"};
      const readonlyInfo1 = readonly(info1);
 
      // 2.响应式的对象reactive
      const info2 = reactive({
        name: "why"
      })
      const readonlyInfo2 = readonly(info2);
 
      // 3.响应式的对象ref
      const info3 = ref("why");
      const readonlyInfo3 = readonly(info3);

readonly 使用规则

readonly返回的对象都是不允许修改的；

但是经过readonly处理的原来的对象是允许被修改的；

• 比如 const info = readonly(obj)，readonly返回的对象info对象是不允许被修改的；
• 当obj被修改时，readonly返回的info对象也会被修改；

其实本质上就是readonly返回的对象的setter方法被劫持了而已；

Readonly使用场景

在我们传递给其他组件数据时，往往希望其他组件使用我们传递的内容，但是不允许它们修改时，就可以使用 readonly了

<子组件 :info="info" />

给子组件传的值是响应式的时候，值变的时候子组件才能跟着变。 

Reactive判断的API

isProxy
检查对象是否是由 reactive 或 readonly创建的 proxy。

isReactive
检查对象是否是由 reactive创建的响应式代理：
如果该代理是 readonly 建的，但包裹了由 reactive 创建的另一个代理，它也会返回 true；

isReadonly
检查对象是否是由 readonly 创建的只读代理。

toRaw
返回 reactive 或 readonly 代理的原始对象（不建议保留对原始对象的持久引用。请谨慎使用）。

shallowReactive
创建一个响应式代理，它跟踪其自身 property 的响应性，但不执行嵌套对象的深层响应式转换 (深层还是原生对象)。

shallowReadonly
创建一个 proxy，使其自身的 property 为只读，但不执行嵌套对象的深度只读转换（深层还是可读、可写的）。

toRefs & toRef

对 reactive 对象进行解构，使解构出来的数据依旧是响应式的。

import { reactive, toRefs, toRef } from 'vue';
 
  export default {
    setup() {
      const info = reactive({name: "why", age: 18});
 
    //如果我们使用ES6的解构语法，对reactive返回的对象进行解构获取值 
    //let { name, age } = info ;
    //那么之后无论是修改结构后的变量，还是修改reactive 返回的state对象，数据都不再是响应式的：
      
 
      // 1.toRefs: 将reactive对象中的所有属性都转成ref, 建立链接
      // let { name, age } = toRefs(info);
      // 2.toRef: 对其中一个属性进行转换ref, 建立链接
      let { name } = info;
      let age = toRef(info, "age");
 
      return {
        name,
        age
      }
    }
  }

ref其他的API

unref

• 如果我们想要获取一个ref引用中的value，那么也可以通过unref方法：
• 如果参数是一个 ref，则返回内部值，否则返回参数本身；
• 这是 val = isRef(val) ? val.value : val 的语法糖函数；

isRef
判断值是否是一个ref对象。

shallowRef
创建一个浅层的ref对象；

triggerRef
手动触发和 shallowRef 相关联的副作用

import { ref, shallowRef, triggerRef } from 'vue';
 
  export default {
    setup() {
      const info = shallowRef({name: "why"})
 
      const changeInfo = () => {
        info.value.name = "james"; //这个修改不是响应式的，因为 info 是浅层的 ref 对象
        triggerRef(info); //手动触发改变
      }
 
      return {
        info,
        changeInfo
      }
    }
  }

customRef

n创建一个自定义的ref，并对其依赖项跟踪和更新触发进行显示控制： 它需要一个工厂函数，该函数接受 track 和 trigger 函数作为参数； 并且应该返回一个带有 get 和 set 的对象；

案例： 对双向绑定的属性进行debounce(节流)的操作 （快速在文本框输入文字的时候不要马上响应式的变化）

<template>
  <div>
    <input v-model="message"/>
    <h2>{{message}}h2>
  div>
template>
 
<script>
  import debounceRef from './hook/useDebounceRef';
 
  export default {
    setup() {
      const message = debounceRef("Hello World");
 
      return {
        message
      }
    }
  }
script>

useDebounceRef.js

import { customRef } from 'vue';
 
// 自定义ref
export default function(value, delay = 300) {
  let timer = null;
  return customRef((track, trigger) => {
    return {
      get() {
        track();
        return value;
      },
      set(newValue) {
        clearTimeout(timer);
        timer = setTimeout(() => {
          value = newValue;
          trigger();
        }, delay);
      }
    }
  })
}