一篇文章看懂Vue组合式API

Vue
283
0
0
2023-05-02
目录
  • 一. 为什么要使用Composition API
  • 1.1.一个Options API实例
  • 1.2.Options API存在的问题
  • 1.3.Composition API简介
  • 二.Composition API
  • 2.1.setup()入口
  • 2.2.ref 响应式监听
  • 2.3.reactive与toRefs
  • 2.4.computed的用法
  • 2.5.watch的用法
  • 2.6.setup()参数
  • 2.6.1.props参数
  • 2.6.2.context参数
  • 三.Composition API的使用
  • 3.1.provide与inject的使用
  • 3.2.vue生命周期的用法
  • 3.3.编程式路由的使用
  • 3.4.Vuex的使用
  • 3.5.获取DOM的使用
  • 四.使用Composition API重写todoList
  • 五.setup语法糖
  • 5.1.setup语法糖的基本结构
  • 5.2.响应数据的使用
  • 5.3.其它语法的使用
  • 5.4.引入组件的使用
  • 5.5.父子组件传值的使用
  • 5.5.1.defineProps的使用
  • 5.5.2.defineEmits的使用
  • 六.使用setup语法糖重写todoList
  • 七. 总结

一. 为什么要使用Composition API

1.1.一个Options API实例

在前面的课程中,我们都是采用 Options API(基于选项的 API ) 来写一个组件的。下面是一个实例:
<template>
  Count is: {{ count }}, doubleCount is: {{ doubleCount }} 
  <button @click="add"></button>
</template>
 
<script>
export default {
  data() {
    return {
      count: 0,
    };
  },
  computed: {
    doubleCount() {
      return this.count * 2;
    },
  },
  methods: {
    add() {
      this.count++;
    }
  }
}
</script>
当要去理解一个组件时,我们更加关心的是:“这个组件是要干什么(即代码背后的意图)”,而不是:“这个组件用到了什么选项”。
Options API 撰写出来的代码自然采用了后者的表述方式,然而对前者的表述并不好。

1.2.Options API存在的问题

在 Options API 中实际上形成了一种强制的约定:
  • props 里面设置接收参数
  • data 里面设置变量
  • computed 里面设置计算属性
  • watch 里面设置监听属性
  • methods 里面设置事件方法
我们会发现: Options API 都约定了我们该在哪个位置做什么事,这在一定程度上也强制我们进行了代码分割。这就为展示背后的逻辑关注点设置了障碍。我们必须不断地在选项代码块之间“跳转”,以找到与该关注点相关的部分。
尤其是在大型组件中,数据与方法会很多,而数据与其相关联的方法就会被其他数据和方法分隔的很远,往往很难被看出它们之间的关联。

这是一个大型组件的示例,其中逻辑关注点是按颜色分组。
这种碎片化使得理解和维护复杂组件变得困难。选项的分离掩盖了潜在的逻辑问题。此外,在处理单个逻辑关注点时,我们必须不断地“跳转”相关代码的选项块。
如果我们能够将与同一个逻辑关注点相关的代码配置在一起,这样会更好。而这正是组合式 API 使我们能够做到的。

1.3.Composition API简介

Composition API:组合式 API;一组低侵入式的、函数式的 API,使得我们能够更灵活地【组合】组件的逻辑。
这是有别于 Options API 的一种函数式 API。无需通过很多选项来完成业务逻辑,Composition API提供了一个setup函数,我们可以将data数据、计算属性、方法等等,都放在setup函数中,这样就可以对业务进行集中处理了。
采用Composition API来重写上面的组件:
<template>
  Count is: {{ state.count }}, doubleCount is: {{ state.doubleCount }}
  <button @click="add"></button>
</template>
 
<script>
import { reactive, computed } from "vue";
 
export default {
  setup() {
    const state = reactive({
      count: 0,
      doubleCount: computed(() => state.count * 2),
    });
 
    function add() {
      state.count++;
    }
 
    return {
      state,
      add
    }
  }
}
</script>
还有一个 setup 函数,setup 函数是一个新的组件选项。作为在组件内使用 Composition API 的入口点,如果 setup 返回一个对象,则对象的属性将会被合并到组件模板的渲染上下文,我们就可以在模板里使用对应的属性和方法。

二.Composition API

2.1.setup()入口

setup 函数是一个新的组件选项,它是在组件内使用 Composition API 的入口点。它会在Vue实例创建完成前被调用。所以,setup函数中没有this指针
<template>
  <div></div>
</template>
 
<script>
export default {
  setup() {
	//这里书写本地状态(data数据)、计算属性或方法等
    console.log('setup函数');
  }
}
</script>
如果 setup 返回一个对象,则对象的属性将会被合并到组件模板的渲染上下文,我们就可以在模板里使用对应的属性和方法。所以,我们可以将本地状态(data数据)、方法、计算属性等写在 setup 函数中。
<template>
  Count is: {{ count }}
</template>
 
<script>
export default {
  setup() {
    let count = 10;
    
    return {
      count
    }
  }
}
</script>
上面代码中,在 setup 函数中声明了一个 count 数据。然后使用 return 返回需要暴露的内容。运行之后可以看到:视图能够正确显示count数据。
setup函数总结:
  • setup函数是Composition API 的入口点,是它的核心。
  • 由于执行 setup 时,组件实例尚未被创建,因此在 setup 中不能使用 this。
  • setup中定义的东西必须要return出去,才能被使用或绑定视图。

2.2.ref 响应式监听

上面实例中,虽然视图能够显示数据。但当改变数据时,视图却不会得到响应。
<template>
  Count is: {{ count }}
  <button @click="add"></button>
</template>
 
<script>
export default {
  setup() {
    let count = 10;
 
    function add(){
      count++;       //setup函数中没有this指针
    }
    
    return {
      count,
      add
    }
  }
}
</script>
原因很简单,count只是声明的一个普通数据,不具备响应功能。
在 Vue 3.0 中,我们可以通过一个 ref 函数来实现响应式数据监听。ref 接受一个参数,并将其包裹在一个带有 value 属性的对象中返回,然后可以使用该 value 属性访问或更改响应式变量的值:
<template>
  Count is: {{ count }}
  <button @click="add"></button>
</template>
 
<script>
//注意:要导入ref
import {ref} from 'vue';
 
export default {
  setup() {
    let count = ref(10);  //count成为响应式数据。
 
    function add(){
      count.value++;       //使用value属性获取响应数据
    }
    
    return {
      count,
      add
    }
  }
}
</script>
为什么要将值封装在一个对象中,看似没有必要,但为了保持 JavaScript 中不同数据类型的行为统一,这是必须的。因为在 JavaScript 中,Number 或 String 等基本类型是通过值传递的,而不是通过引用传递的:

2.3.reactive与toRefs

上面实例中,操作数据时需要使用 value 属性,比较麻烦。
可以使用 reactive 与 toRefs 解决这个问题。首先使用 reactive 创建响应式对象,封装数据。
<template>
  <p>Count is: {{ state.count }}</p>
  <button @click="add"></button>
  <p>{{ state.user.username }}</p>
</template>
 
<script>
//注意:要导入ref
import {reactive} from 'vue';
 
export default {
  setup() {
    //所有响应数据都声明在这里,包括对象、数组
    const state = reactive({
      count: 10,
      user:{
        userId: 1,
        username: '张三'
      }
    })
 
    function add(){
      state.count++;       //这里可以不使用value了
    }
    
    return {
      state,
      add
    }
  }
}
</script>
此时不用使用 value 属性了。
但是因为只有state是响应式数据,而state中的那些数据还不是响应式的。所以在视图访问数据时都需要使用 state 作为前缀才可以。这就比较麻烦了。
此时我们可以使用 toRefs 进行优化。toRefs可以将state中的每一个数据进行展开,且都包装成响应数据。这样视图层就可以直接使用了。
<template>
  <p>Count is: {{ count }}</p>
  <button @click="add"></button>
  <p>{{ user.username }}</p>
</template>
 
<script>
//注意:要导入ref
import {reactive, toRefs} from 'vue';
 
export default {
  setup() {
    //所有响应数据都声明在这里,包括对象、数组
    const state = reactive({
      count: 10,
      user:{
        userId: 1,
        username: '张三'
      }
    })
 
    function add(){
      state.count++;       //这里可以不使用value了
    }
    
    return {
      ...toRefs(state),    //这里使用使用 ...toRefs(state)
      add
    }
  }
}
</script>
在返回时使用 ...toRefs(state) ,这样视图层就可以不使用 state 前缀了。
为什么要使用 ... 参数扩展运输符呢?因为toRefs(state) 将state对象展开,并包装成多个响应数据。

2.4.computed的用法

<template>
  <p>Count is: {{ count }}</p>
  <p>doubleCount is: {{ doubleCount }}</p>
  <button @click="add"></button>
  <p>{{ user.username }}</p>
</template>
 
<script>
//注意:要导入ref
import { reactive, toRefs, computed } from "vue";
 
export default {
  setup() {
    //所有响应数据都声明在这里,包括对象、数组
    const state = reactive({
      count: 10,
      user: {
        userId: 1,
        username: "张三",
      },
      doubleCount: computed(() => {    //使用computed函数
        return state.count * 2;
      }),
    });
 
    function add() {
      state.count++; //这里可以不使用value了
    }
 
    return {
      ...toRefs(state),
      add,
    };
  },
};
</script>
首先要import导入computed。
在reactive({})中声明computed即可。
到现在为止,响应式数据就都可以处理了。

2.5.watch的用法

<template>
  <div>
    {{ num }}
    <button @click="add"></button>
  </div>
</template>
 
<script>
import { reactive, toRefs, watch } from "vue";
 
export default {
  setup() {
    const state = reactive({
      num: 0,
    });
 
    watch(state,(newValue, oldValue) => {
        console.log(newValue, oldValue);
      }
    );
 
    function add() {
      state.num++;
    }
 
    return {
      ...toRefs(state),
      add,
    };
  },
};
</script>
使用watch函数来进行数据监听。watch函数有两个参数。
第一个参数:要监听的数据。
第二个参数:触发监听时的处理函数(包括newValue, oldValue)
上面实例中直接监听state响应对象。但我们知道,在state中会有很多数据,如果只想监听其中的某个数据,就需要换一种写法:
watch(() => state.num,(newValue, oldValue) => {
    console.log(newValue, oldValue);
});
第一个参数要写成函数返回值的形式,这样就能监听state响应对象中的某个数据了。

2.6.setup()参数

setup() 函数有两个参数:props 和 context。
为什么要有这两个参数呢?我们知道父子组件之间是可以传值。但是现在我们的业务逻辑都写在setup函数中,而setpu中没有this指针,那么就只能靠这两个参数来进行传递了。
  • props:父组件向子组件传值的参数。
  • context:子组件向父组件传值的参数。

2.6.1.props参数

setup() 函数的 props 是父组件向子组件传值的参数。
在components文件夹中创建子组件(Hello.vue):
<template>
  <div>我是子组件</div>
</template>
 
<script>
export default {
  setup(props, context) {
    console.log(props.msg)
  },
  props: {
    msg: String,
  },
};
</script>
 
<style>
</style>
父组件(HomeView.vue):
<template>
  <div>
    <Hello msg="hello"></Hello>
  </div>
</template>
 
<script>
import Hello from '../components/Hello.vue'
import { reactive, toRefs, computed } from "vue";
 
export default {
  setup() {
    const state = reactive({
 
    });
    return {
      ...toRefs(state),
    };
  },
  components:{
    Hello
  }
};
</script>
注意,要先import导入子组件,然后使用components挂载子组件。

2.6.2.context参数

setup() 函数的 context 是子组件向父组件传值的参数。
子组件(Hello.vue):
<template>
  <div>
    <div>我是子组件</div>
    <button @click="send">给父组件发数据</button>
  </div>
</template>
 
<script>
export default {
  setup(props, context) {
    function send() {
      context.emit("childmsg", "hello world!");
    }
 
    return {
      send,
    };
  },
  props: {
    msg: String,
  },
};
</script>
 
<style>
</style>
父组件(HomeView.vue):
<template>
  <div>
    <Hello msg="hello" @childmsg="get"></Hello>
    <p>我是父组件,接受子组件传的值:{{welcome}}</p>
  </div>
</template>
 
<script>
import Hello from '../components/Hello.vue'
import { reactive, toRefs, computed } from "vue";
 
export default {
  setup() {
    //所有响应数据都声明在这里,包括对象、数组
    const state = reactive({
      welcome: ''
    });
 
    function get(param) {
      state.welcome = param;
    }
 
    return {
      ...toRefs(state),
      get
    };
  },
  components:{
    Hello
  }
};
</script>

三.Composition API的使用

下面我们会将前面学过的知识点都改写为Composition API的形式。而且,Vue3兼容Options API和Composition API两种写法。所以这两种写法都要会。

3.1.provide与inject的使用

我们学过provide与inject可用于多级组件直接传递数据,下面学习provide与inject在Composition API中的使用。
创建孙子组件(SubHello.vue)
<template>
  <div>
    <div>我是孙组件</div>
  </div>
</template>
 
<script>
import { inject } from "vue";
 
export default {
  setup(props, context) {
 
    console.log(inject('msg'))
      
    return {};
  }
};
</script>
在孙子组件中import导入inject,并使用inject接收上级组件的传值。

在子组件(Hello.vue)中使用孙子组件

<template>
  <div>
    <div>我是子组件</div>
    <SubHello></SubHello>
  </div>
</template>
 
<script>
import SubHello from './SubHello.vue'
 
export default {
  setup(props, context) {
 
    return {};
  },
  components:{
      SubHello
  }
};
</script>
 
<style>
</style>

在父组件中使用provide给多级组件传值

<template>
  <div>
    <Hello></Hello>
  </div>
</template>
 
<script>
import Hello from "../components/Hello.vue";
import { provide } from "vue";
 
export default {
  setup() {
    provide('msg','hello');
  },
  components:{
    Hello
  }
};
</script>
注意,由于父组件向孙子组件传递数据是单向的,所以孙子组件不能修改传递的值。如果子组件

3.2.vue生命周期的用法

在 setup () 内部调用生命周期钩子:

选项式API

setup () 内部调用生命周期钩子

beforeCreate()

setup()

created()

setup()

beforeMount()

onBeforeMount()

mounted()

onMounted()

beforeUpdate()

onBeforeUpdate()

updated()

onUpdated()

beforeUnmount()

onBeforeUnmount()

unmounted()

onUnmounted()

注意:在Composition API中没有beforeCreate()和created()这里两个声明周期函数了,统一使用setup()。

实例:

<template>
  <div>
    {{ num }}
    <button @click="add"></button>
  </div>
</template>
 
<script>
import { reactive,toRefs,onBeforeMount,onMounted,onBeforeUpdate,onUpdated,onBeforeUnmount,onUnmounted } from "vue";
 
export default {
  setup() {
    const state = reactive({
      num: 1,
    });
 
    function add() {
      state.num++;
    }
 
    onBeforeMount(() => {
      console.log("DOM挂载前!");
    });
 
    onMounted(() => {
      console.log("DOM挂载后!");
    });
 
    onBeforeUpdate(() => {
      console.log("数据更新前!");
    })
 
    onUpdated(() => {
      console.log("数据更新后!");
    })
 
    onBeforeUnmount(() => {
      console.log("实例卸载前!");
    })
 
    onUnmounted(() => {
      console.log("实例卸载后!");
    })
 
    return {
      ...toRefs(state),
      add,
    };
  },
};
</script>

3.3.编程式路由的使用

下面学习如何在Composition API中使用路由。
打开App.vue组件,这里已经有了路由。当然,是使用router-link标签来实现的。现在我们将它改成编程式路由。
<template>
  <nav>
    <!--
    <router-link to="/">Home</router-link> |
    <router-link to="/about">About</router-link>
    -->
    <button @click="toHome">Home</button>
    <button @click="toAbout">About</button>
  </nav>
  <router-view />
</template>
 
<script>
import { useRouter } from "vue-router";
 
export default{
  setup() {
    const router = useRouter();
 
    function toHome(){
      router.push('/');
    }
  
    function toAbout(){
      router.push({path:'/about',query:{name:'zhangsan'}});
    }
 
    return {
      toHome,
      toAbout
    }
  },
}
</script>
先import导入useRouter模块。
通过useRouter模块获取router对象。以后的路由写法就与前面所学一样了。
下面是获取路由参数,打开AboutView.vue文件
<template>
  <div>   
  </div>
</template>
 
<script>
import { useRoute } from "vue-router";
 
export default {
  setup(){
    const route = useRoute();
 
    console.log(route.query.name);
  }
}
</script>
通过同样的方式获取route对象后就可以获取路由参数了。

3.4.Vuex的使用

下面学习如何在Composition API中使用Vuex。
<template>
  <div>
  </div>
</template>
 
<script>
import { useStore } from "vuex";
 
export default {
  setup() {
    const store = useStore();
    console.log(store.state.num);
    console.log(store.getters.newnum);
  }
};
</script>
先import导入useStore模块。
通过useStore模块获取store对象。就可以通过store对象获取Vuex中的所有数据了。

3.5.获取DOM的使用

前面我们知道在Vue中,可以使用ref来获取DOM对象。下面学习如何在Composition API中使用ref。
<template>
  <div ref="myRef">获取单个DOM元素</div>
</template>
 
<script>
import { ref, onMounted } from 'vue';
 
export default {
  setup() {
    const myRef = ref(null);   //ref(null)是一个固定的写法
 
    onMounted(() => {
      console.dir(myRef.value);
    });
    return {
      myRef
    };
  }
};
</script>
  • 在HTML标签中使用 ref 属性标识一个DOM对象。
  • 需要 import 导入 ref 对象。
  • 使用 const myRef = ref(null); 的方式获取包装好的DOM对象,命名为HTML中的 ref 属性名。并且此数据需要暴露出去。
  • 使用 value 属性即可获取 DOM对象。

四.使用Composition API重写todoList

AddNew组件

<template>
  <div>
    <input type="text" v-model="newItem" />
    <button @click="handleAdd">添加</button>
  </div>
</template>
 
<script>
import {reactive, toRefs} from 'vue';
 
export default {
  setup(props, context){
    const state = reactive({
      newItem: ""
    })
 
    function handleAdd() {
      if (state.newItem == "") {
        alert("不能为空");
        return;
      }
      //注意:这里使用setup参数context来出发父组件事件
      context.emit("submitNewItem", state.newItem);
      state.newItem = "";
    }
 
    return {
      ...toRefs(state),
      handleAdd
    }
  }
}
</script>

TheList组件

<template>
  <ol>
    <li v-for="(item, index) in list" :key="index" @click="judgeItem(index)">
      {{ item }}
    </li>
  </ol>
</template>
 
<script>
export default {
  setup(props, context) {
    //这里分别使用了setup的两个参数  
    function judgeItem(index) {
      if (props.listType) {
        context.emit("handleDelete", index);
      } else {
        context.emit("handleJudge", index);
      }
    }
 
    return {
      judgeItem
    };
  },
  props: {
    list: {
      type: Array,
      required: true,
    },
    listType: {
      type: Boolean,
      default: false,
    },
  },
};
</script>

TodoList组件

<template>
  <div>
    <h1>todoList</h1>
    <AddNew @submitNewItem="addNewItem"></AddNew>
    <TheList :list="todoList" @handleJudge="toDone"></TheList>
    <hr />
    <TheList :list="doneList" :listType="true" @handleDelete="toDelete"></TheList>
  </div>
</template>
 
<script>
import AddNew from "../components/AddNew.vue";
import TheList from "../components/TheList.vue";
import {reactive, toRefs} from 'vue';
 
export default {
  setup(){
    const state = reactive({
      todoList: [],  //待办事项
      doneList: []   //完成事项
    })
 
    function addNewItem(newItem){
      state.todoList.push(newItem);
    }
    function toDone(index){
      state.doneList.push(state.todoList.splice(index,1)[0]);
    }
    function toDelete(index){
      state.doneList.splice(index,1);
    }
 
    return {
      ...toRefs(state),
      addNewItem,
      toDone,
      toDelete
    }
  },
  components: {
    AddNew,
    TheList,
  },
};
</script>

五.setup语法糖

在Composition API中,在setup函数中声明的数据、函数等内容,都需要通过 return 对外暴露,才能被组件的视图模板(template)使用,这就造成了书写上的不方便。于是,Vue官方又给我们推出了一个新的setup语法糖。
使用setup语法糖,就可以不用写setup函数了。并且,数据和函数也不用返回,组件也不需要注册了。

5.1.setup语法糖的基本结构

<template>
</template>
 
<script setup>
//此处直接写setup函数中的内容
</script>
 
<style>
</style>
  • 在script标签中使用setup属性即可。
  • 运行时,script标签中的内容会被重新编译成 setup() 函数的形式。
  • 而且,声明的数据、函数不需要通过 return 暴露,即可被 template所使用

5.2.响应数据的使用

<template>
  <div>
    <p>{{ num }}</p>
    <button @click="add"></button>
  </div>
</template>
 
<script setup>
let num = 10;
//const num = 10;
 
//由于num不是响应数据,所以改变num是无效的。
const add = ()=>{
  alert("触发了此方法");
  num++;
}
</script>
直接声明的数据不是响应式的,数据改变时不会响应到视图模板中。
<template>
  <div>
    <p>{{ num }}</p>
    <p>{{ dept.deptno }},{{ dept.dname }},{{ dept.loc }}</p>
    <ul>
      <li v-for="user in userArr" :key="user.userId">
        {{user.userId}},{{user.userName}},{{user.userAge}}
      </li>
    </ul>
    <button @click="add"></button>
  </div>
</template>
 
<script setup>
import { reactive, ref } from "vue";
 
const num = ref(10);
 
const dept = reactive({
  deptno: 20,
  dname: "技术部",
  loc: '沈阳市',
});
 
const userArr = ref([
  {
    userId: 100,
    userName: "张三",
    userAge: 25,
  },
  {
    userId: 101,
    userName: "李四",
    userAge: 26,
  },
  {
    userId: 102,
    userName: "王五",
    userAge: 27,
  },
]);
 
const add = () => {
  num.value++;      //注意:要使用value属性获取
  dept.deptno++;
  //userArr.value[0].userAge++;
  userArr.value = [];
}
</script>

ref 和 reactive 都可以做响应式数据,它们的区别如下:

  • reactive:用于定义引用类型。只能修改数据,不能改变其引用。
  • ref:用于定义基本类型和引用类型。可以修改数据,也可以改变其引用。
  • 在方法中修改数据时需要使用 value属性。因为,Ref的本质是通过Reactive创建的,Ref(10) 就相当于:Reactive({value:10});
  • 在视图模板调用可以省略value属性的书写。

5.3.其它语法的使用

下面例子演示了computed计算属性、watch监听、生命周期函数的使用。
<template>
  <div>
    {{ num }}
    {{ newNum }}
    <button @click="add">add</button>
  </div>
</template>
 
<script setup>
import { ref, computed, watch, onMounted } from 'vue';
 
const num = ref(10);
 
const newNum = computed(() => {
  return num.value*2;
})
 
const add = ()=>{
  num.value++;
}
 
watch(num,(newValue,oldValue)=>{
  console.log(newValue,oldValue);
})
 
//生命周期函数
onMounted(() => {
  console.log("DOM挂载后!");
});
</script>

5.4.引入组件的使用

引入的组件不必注册,可以直接使用。
<template>
  <div class="home">
    <HelloWorld msg="Welcome to Your Vue.js App"/>
  </div>
</template>
 
<script setup>
// @ is an alias to /src
import HelloWorld from '@/components/HelloWorld.vue'
</script>

5.5.父子组件传值的使用

5.5.1.defineProps的使用

defineProps用于父组件向子组件传值。

父组件

<template>
  <div class="home">
    <HelloWorld msg="Welcome to Your Vue.js App" :num="num"/>
  </div>
</template>
 
<script setup>
// @ is an alias to /src
import HelloWorld from '@/components/HelloWorld.vue'
 
const num = 20
</script>

子组件

<template>
  <div class="hello">
    <h1>{{ msg }},{{ num }}</h1>
  </div>  
</template>
 
<script setup>
//const myProps = defineProps(['msg','num']);
 
const myProps = defineProps({
  msg:{
    type: String
  },
  num:{
    type: Number,
    required: true
  }
});
</script>
 
<style scoped>
</style>
defineProps也可以有数组形式和对象形式两种写法。

5.5.2.defineEmits的使用

defineEmits用于子组件向父组件传值。

父组件

<template>
  <div class="home">
    <HelloWorld 
           msg="Welcome to Your Vue.js App" 
           :num="num"
           @childmsg="get"/>
  </div>
</template>
 
<script setup>
// @ is an alias to /src
import HelloWorld from '@/components/HelloWorld.vue'
 
const num = 20;
 
const get = (value) => {
  console.log(value)
}
</script>

子组件

<template>
  <div class="hello">
    <h1>{{ msg }},{{ num }}</h1>
    <button @click="send">给父组件传值</button>
  </div>  
</template>
 
<script setup>
const myProps = defineProps(['msg','num']);
 
const emit = defineEmits(['childmsg']);
 
const send = () => {
  emit('childmsg','子组件向父组件传的值');
}
</script>
 
<style scoped>
</style>

六.使用setup语法糖重写todoList

AddNew组件

<template>
  <div>
    <input type="text" v-model="newItem" />
    <button @click="handleAdd">添加</button>
  </div>
</template>
 
<script setup>
import { ref } from "vue";
 
const newItem = ref("");
 
const emit = defineEmits(["submitNewItem"]);
 
const handleAdd = () => {
  if (newItem.value == "") {
    alert("不能为空");
    return;
  }
  emit("submitNewItem", newItem.value);
  newItem.value = "";
};
</script>

TheList组件

<template>
  <ol>
    <li v-for="(item, index) in list" :key="index" @click="judgeItem(index)">
      {{ item }}
    </li>
  </ol>
</template>
 
<script setup>
const emit = defineEmits(['handleDelete','handleJudge']);
 
const judgeItem = (index) => {
  if (myProps.listType) {
    emit("handleDelete", index);
  } else {
    emit("handleJudge", index);
  }
};
 
const myProps = defineProps({
  list: {
    type: Array,
    required: true,
  },
  listType: {
    type: Boolean,
    default: false,
  },
});
</script>

TodoList组件

<template>
  <div>
    <h1>todoList</h1>
    <AddNew @submitNewItem="addNewItem"></AddNew>
    <TheList :list="todoList" @handleJudge="toDone"></TheList>
    <hr />
    <TheList
      :list="doneList"
      :listType="true"
      @handleDelete="toDelete"
    ></TheList>
  </div>
</template>
 
<script setup>
import AddNew from "../components/AddNew.vue";
import TheList from "../components/TheList.vue";
import { reactive } from "vue";
 
const todoList = reactive([]); //待办事项
const doneList = reactive([]); //完成事项
 
const addNewItem = (newItem) => {
  todoList.push(newItem);
}
const toDone = (index) => {
  doneList.push(todoList.splice(index, 1)[0]);
}
const toDelete = (index) => {
  doneList.splice(index, 1);
}
</script>