【从0开始学前端】vue3路由，Pinia，组件通信

雨雨雨雨雨别下啦2025-12-02 16:04

一.路由

1.理解路由

路由就是一组key-value的对应关系

多个路由，需要经过路由器的管理

  • Vue3中要使用vue-router的最新版本，目前是4版本。安装方法：在vscode终端输入npm i vue-router

  • 路由配置文件代码如下：

    js 复制代码 
    import {createRouter,createWebHistory} from 'vue-router'
//引入可能要呈现的组件
import Home from '@/pages/Home.vue'
import News from '@/pages/News.vue'
import About from '@/pages/About.vue'

const router = createRouter({
	history:createWebHistory(),//路由器的工作模式
	routes:[//管理多个路由
		{
			path:'/home',//路径
			component:Home//组件
		},
		{
			path:'/about',
			component:About
		}
	]
})
export default router//交出路由，暴露

  • main.ts代码如下：

    js 复制代码 
    import router from './router/index'//导入路由
app.use(router)//使用路由

app.mount('#app')//挂在整个应用到app容器中

  • App.vue代码如下

    vue 复制代码 
    <template>
  <div class="app">
    <h2 class="title">Vue路由测试</h2>
    <!-- 导航区 -->
    <div class="navigate">
      <RouterLink to="/home" active-class="active">首页</RouterLink>
      <RouterLink to="/news" active-class="active">新闻</RouterLink>
      <RouterLink to="/about" active-class="active">关于</RouterLink>//active-class="active点谁谁亮
    </div>
    <!-- 展示区 -->
    <div class="main-content">
      <RouterView></RouterView>
    </div>
  </div>
</template>

<script lang="ts" setup name="App">
  import {RouterLink,RouterView} from 'vue-router'  
    //RouterLink跳转RouterView浏览视图
</script>

2.注意点

  1. 在工程中路由组件通常存放在pages 或 views文件夹，一般组件通常存放在components文件夹。
  2. 通过点击导航，视觉效果上"消失" 了的路由组件，默认是被卸载 掉的，需要的时候再去挂载。

3.路由器的工作模式

  1. history模式

    优点：URL更加美观，不带有#，更接近传统的网站URL。

    缺点：后期项目上线，需要服务端配合处理路径问题，否则刷新会有404错误。

    js 复制代码 
    const router = createRouter({
  	history:createWebHistory(), //history模式
  	/******/
})

  2. hash模式

    优点：兼容性更好，因为不需要服务器端处理路径。

    缺点：URL带有#不太美观，且在SEO优化方面相对较差。

    js 复制代码 
    const router = createRouter({
  	history:createWebHashHistory(), //hash模式
  	/******/
})
特性 Hash 模式 History 模式
URL 美观度 不美观，带 # 美观，与普通 URL 无差异
兼容性 极好，兼容到 IE8 依赖 HTML5 History API，兼容性稍差（但现代浏览器均支持）
服务器配置 无需特殊配置 必须配置 ，将所有路由 fallback 到 index.html
SEO 友好度 相对较差 更好（但 SPA 的 SEO 本身就需要额外处理，如 SSR）
实现原理 监听 hashchange 事件 调用 HTML5 History API

4.to的两种写法

vue 复制代码 
<!-- 第一种：to的字符串写法 -->
<router-link active-class="active" to="/home">主页</router-link>

<!-- 第二种：to的对象写法 -->
<router-link active-class="active" :to="{path:'/home'}">Home</router-link>

5.命名路由

作用：可以简化路由跳转及传参。

给路由规则命名：

js 复制代码 
routes:[
  {
    name:'zhuye',
    path:'/home',
    component:Home
  },
  {
    name:'xinwen',
    path:'/news',
    component:News,
  },
  {
    name:'guanyu',
    path:'/about',
    component:About
  }
]

跳转路由：

vue 复制代码 
<!--简化前：需要写完整的路径（to的字符串写法） -->
<router-link to="/news/detail">跳转</router-link>

<!--简化后：直接通过名字跳转（to的对象写法配合name属性） -->
<router-link :to="{name:'guanyu'}">跳转</router-link>

6.嵌套路由

  1. 编写News的子路由：Detail.vue

  2. 配置路由规则，使用children配置项：

    ts 复制代码 
    const router = createRouter({
  history:createWebHistory(),
	routes:[
		{
			name:'zhuye',
			path:'/home',
			component:Home
		},
		{
			name:'xinwen',
			path:'/news',
			component:News,
			children:[
				{
					name:'xiang',
					path:'detail',
					component:Detail
				}
			]
		},
		{
			name:'guanyu',
			path:'/about',
			component:About
		}
	]
})
export default router

  3. 跳转路由（记得要加完整路径）：

    vue 复制代码 
    <router-link to="/news/detail">xxxx</router-link>
<!-- 或 -->
<router-link :to="{path:'/news/detail'}">xxxx</router-link>

  4. 要去Home组件中预留一个<router-view>

    vue 复制代码 
    <template>
  <div class="news">
    <nav class="news-list">
      <RouterLink v-for="news in newsList" :key="news.id" :to="{path:'/news/detail'}">
        {{news.name}}
      </RouterLink>
    </nav>
    <div class="news-detail">
      <RouterView/>
    </div>
  </div>
</template>

7.路由传参

query参数

  1. 传递参数

    vue 复制代码 
    <!-- 跳转并携带query参数（to的字符串写法） -->
<router-link to="/news/detail?a=1&b=2&content=欢迎你">
	跳转
</router-link>
				
<!-- 跳转并携带query参数（to的对象写法） -->
<RouterLink 
  :to="{
    //name:'xiang', //用name也可以跳转
    path:'/news/detail',
    query:{
      id:news.id,
      title:news.title,
      content:news.content
    }
  }"
>
  {{news.title}}
</RouterLink>

  2. 接收参数：

    js 复制代码 
    import {useRoute} from 'vue-router'
const route = useRoute()
// 打印query参数
console.log(route.query)

params参数

  1. 传递参数

    vue 复制代码 
    <!-- 跳转并携带params参数（to的字符串写法） -->
<RouterLink :to="`/news/detail/001/新闻001/内容001`">{{news.title}}</RouterLink>
				
<!-- 跳转并携带params参数（to的对象写法） -->
<RouterLink 
  :to="{
    name:'xiang', //用name跳转
    params:{
      id:news.id,
      title:news.title,
      content:news.title
    }
  }"
>
  {{news.title}}
</RouterLink>

  2. 接收参数：

    js 复制代码 
    import {useRoute} from 'vue-router'
const route = useRoute()
// 打印params参数
console.log(route.params)

备注1：传递params参数时，若使用to的对象写法，必须使用name配置项，不能用path。

备注2：传递params参数时，需要提前在规则中占位。

比较

特性 Query 参数 Params 参数
URL 表现形式 在 ? 之后，以 key=value 形式出现，用 & 分隔。/user?name=john&plan=private 是 URL 路径的一部分 。/user/123
路由配置 不需要 在路由配置中预先声明。 必须 在路由配置中预先声明。{ path: '/user/:id', ... }
命名路由 可以使用 path 或 name 进行导航。 使用 name 导航更可靠。使用 path 时，params 会被忽略。
强制性 可选 的。跳转到 /user 和 /user?name=john 都是有效的。 在路径中定义的 Params 是必填的（除非标记为可选）。否则路由无法匹配。
数据容量 适合传递多个参数或复杂数据，因为可以有很多键值对。 适合传递少量、关键的参数（如ID、用户名）。
适用场景 1. 筛选、搜索 ：如 ?keyword=vue&sort=price2. 分页 ：?page=23. 模态框或标签页 ：?dialog=open&tab=settings4. 非强制性的、可选的参数。 1. 资源定位 ：参数是资源标识的一部分。- 用户详情页：/user/123 (123是用户ID)- 文章页面：/post/hello-world (hello-world是文章别名)2. 参数是页面本身的标识。
数据丢失 刷新页面参数不会丢失，因为完整的参数都在URL中。 刷新页面参数不会丢失，因为参数是路径的一部分。
获取方式 在组件中使用 $route.query 或 useRoute().query。 在组件中使用 $route.params 或 useRoute().params。

8.路由的props配置

在没有使用 props 时，组件必须从 $route 对象中直接提取参数，这使得组件与路由系统紧密耦合。

让路由组件更方便的收到参数（可以将路由参数作为props传给组件）

ts 复制代码 
{
	name:'xiang',
	path:'detail/:id/:title/:content',
	component:Detail,

  // props的对象写法，作用：把对象中的每一组key-value作为props传给Detail组件
  // props:{a:1,b:2,c:3}, 

  // props的布尔值写法，作用：把收到了每一组params参数，作为props传给Detail组件
  // props:true
  
  // props的函数写法，作用：把返回的对象中每一组key-value作为props传给Detail组件
  props(route){
    return route.query
  }
}

9.repalce属性

replace 属性用于在导航时替换当前的历史记录，而不是添加新的记录。

vue 复制代码 
<!-- 模板中使用 -->
<template>
  <div>
    <!-- 使用 router-link -->
    <router-link to="/home" replace>首页</router-link>
    <router-link :to="{ path: '/about' }" replace>关于</router-link>
    
    <!-- 编程式导航 -->
    <button @click="goToHome">去首页</button>
  </div>
</template>

<script setup>
import { useRouter } from 'vue-router'

const router = useRouter()

const goToHome = () => {
  // 使用 replace 导航
  router.replace('/home')
  // 或者使用对象形式
  router.replace({ path: '/home' })
}
</script>

与普通导航区别

js 复制代码 
// 普通导航 - 添加新记录
router.push('/home')
// 历史记录: [当前页] -> [/home]

// Replace 导航 - 替换当前记录
router.replace('/home')
// 历史记录: [当前页] 被替换为 [/home]

10.编程式路由导航

路由组件的两个重要的属性：$route和$router变成了两个hooks

ts 复制代码 
import {useRoute,useRouter} from 'vue-router'

const route = useRoute()
const router = useRouter()

console.log(route.query)
console.log(route.parmas)
console.log(router.push)
console.log(router.replace)

11.重定向

重定向是指将用户从一个 URL 自动导航到另一个 URL 的过程。当用户访问某个地址时，系统会自动将其引导到不同的目标地址。

比喻想象你去图书馆：

  • 你询问「科幻小说区在哪里？」
  • 管理员告诉你：「科幻小说已经搬到三楼了，请跟我来」
  • 你被引导到新的位置

这就是重定向的本质：「你要找的内容不在这里，它在那边」

ts 复制代码 
{
    path:'/',
    redirect:'/about'
}

二.Pinia

Pinia 是 Vue.js 的状态管理库，是 Vuex 的替代品，具有更简单的 API、更好的 TypeScript 支持和组合式 API 风格。

核心特点

  • ✅ 支持 Vue 2 和 Vue 3
  • ✅ 极致的 TypeScript 支持
  • ✅ 去除 mutations，只有 state、getters、actions
  • ✅ 模块化设计，无需嵌套模块
  • ✅ 非常轻量（约 1KB）
  • ✅ 支持服务端渲染

1.如何安装使用Pinia

首先，在终端安装pinia

bash 复制代码 
npm install pinia
# 或
yarn add pinia
# 或
pnpm add pinia

然后操作src/main.ts，这里引入使用pinia

ts 复制代码 
import { createApp } from 'vue'
import App from './App.vue'

/* 引入createPinia，用于创建pinia */
import { createPinia } from 'pinia'

/* 创建pinia */
const pinia = createPinia()
const app = createApp(App)

/* 使用插件 */{}
app.use(pinia)
app.mount('#app')

最后创建src/store文件夹，该文件夹中全部保存compinents中相对应的数据

2.存储读取数据

  1. Store是一个保存：状态 、业务逻辑 的实体，每个组件都可以读取 、写入它。

  2. 它有三个概念：state、getter、action，相当于组件中的： data、 computed 和 methods。

  3. 具体编码：src/store/count.ts

    ts 复制代码 
    // 引入defineStore用于创建store
import {defineStore} from 'pinia'

// 定义并暴露一个store
export const useCountStore = defineStore('count',{
  // 动作
  actions:{},
  // 状态
  state(){
    return {
      sum:6
    }
  },
  // 计算
  getters:{}
})

  4. 具体编码：src/store/talk.ts

    js 复制代码 
    // 引入defineStore用于创建store
import {defineStore} from 'pinia'

// 定义并暴露一个store
export const useTalkStore = defineStore('talk',{
  // 动作
  actions:{},
  // 状态
  state(){
    return {
      talkList:[
        {id:'yuysada01',content:'你今天有点怪，哪里怪？怪好看的！'},
     		{id:'yuysada02',content:'草莓、蓝莓、蔓越莓，你想我了没？'},
        {id:'yuysada03',content:'心里给你留了一块地，我的死心塌地'}
      ]
    }
  },
  // 计算
  getters:{}
})

  5. 组件中使用state中的数据

    vue 复制代码 
    <template>
  <h2>当前求和为：{{ sumStore.sum }}</h2>
</template>

<script setup lang="ts" name="Count">
  // 引入对应的useXxxxxStore	
  import {useSumStore} from '@/store/sum'
  
  // 调用useXxxxxStore得到对应的store
  const sumStore = useSumStore()
</script>
    vue 复制代码 
    <template>
	<ul>
    <li v-for="talk in talkStore.talkList" :key="talk.id">
      {{ talk.content }}
    </li>
  </ul>
</template>

<script setup lang="ts" name="Count">
  import axios from 'axios'
  import {useTalkStore} from '@/store/talk'

  const talkStore = useTalkStore()
</script>

3.修改数据

  1. 第一种修改方式，直接修改

    ts 复制代码 
    countStore.sum = 666

  2. 第二种修改方式：批量修改

    ts 复制代码 
    countStore.$patch({
  sum:999,
  school:'atguigu'
})

  3. 第三种修改方式：借助action修改（action中可以编写一些业务逻辑）

    js 复制代码 
    import { defineStore } from 'pinia'

export const useCountStore = defineStore('count', {
  /*************/
  actions: {
    //加
    increment(value:number) {
      if (this.sum < 10) {
        //操作countStore中的sum
        this.sum += value
      }
    },
    //减
    decrement(value:number){
      if(this.sum > 1){
        this.sum -= value
      }
    }
  },
  /*************/
})

  4. 组件中调用action即可

    js 复制代码 
    // 使用countStore
const countStore = useCountStore()

// 调用对应action
countStore.incrementOdd(n.value)

4.storeToRefs

storeToRefs 是 Pinia 提供的一个工具函数，用于从 store 中提取状态并保持其响应式。它专门为了解决直接解构 store 丢失响应性的问题。

  • 借助storeToRefs将store中的数据转为ref对象，方便在模板中使用。
  • 注意：pinia提供的storeToRefs只会将数据做转换，而Vue的toRefs会转换store中数据。
vue 复制代码 
<template>
	<div class="count">
		<h2>当前求和为：{{sum}}</h2>
	</div>
</template>

<script setup lang="ts" name="Count">
  import { useCountStore } from '@/store/count'
  /* 引入storeToRefs */
  import { storeToRefs } from 'pinia'

	/* 得到countStore */
  const countStore = useCountStore()
  /* 使用storeToRefs转换countStore，随后解构 */
  const {sum} = storeToRefs(countStore)
</script>

5.getters

Getters 是 Pinia Store 中的计算属性，它们基于 state 或其他 getters 派生出新的数据。

  1. 概念：当state中的数据，需要经过处理后再使用时，可以使用getters配置。

  2. 追加getters配置。

    js 复制代码 
    // 引入defineStore用于创建store
import {defineStore} from 'pinia'

// 定义并暴露一个store
export const useCountStore = defineStore('count',{
  // 动作
  actions:{
    /************/
  },
  // 状态
  state(){
    return {
      sum:1,
      school:'atguigu'
    }
  },
  // 计算
  getters:{
    bigSum:(state):number => state.sum *10,
    upperSchool():string{
      return this. school.toUpperCase()
    }
  }
})

  3. 组件中读取数据：

    js 复制代码 
    const {increment,decrement} = countStore
let {sum,school,bigSum,upperSchool} = storeToRefs(countStore)

$subscribe

$subscribe 是 Pinia Store 的一个方法，用于监听 store 中状态的变化 。它类似于 Vue 的 watch，但专门用于监听整个 store 的状态变化。

通过 store 的 $subscribe() 方法侦听 state 及其变化

ts 复制代码 
talkStore.$subscribe((mutate,state)=>{
  console.log('LoveTalk',mutate,state)
  localStorage.setItem('talk',JSON.stringify(talkList.value))
})

6.store组合式写法

ts 复制代码 
import {defineStore} from 'pinia'
import axios from 'axios'
import {nanoid} from 'nanoid'
import {reactive} from 'vue'

export const useTalkStore = defineStore('talk',()=>{
  // talkList就是state
  const talkList = reactive(
    JSON.parse(localStorage.getItem('talkList') as string) || []
  )

  // getATalk函数相当于action
  async function getATalk(){
    // 发请求，下面这行的写法是：连续解构赋值+重命名
    let {data:{content:title}} = await axios.get('https://api.uomg.com/api/rand.qinghua?format=json')
    // 把请求回来的字符串，包装成一个对象
    let obj = {id:nanoid(),title}
    // 放到数组中
    talkList.unshift(obj)
  }
  return {talkList,getATalk}
})

三.组件通信

1.props

概述：props是使用频率最高的一种通信方式，常用与 ：父 ↔ 子。

  • 若 父传子 ：属性值是非函数。
  • 若 子传父 ：属性值是函数。

父亲接收孩子的值需要定义方法，孩子接收父亲的值需要进行声明接收props

父组件：

vue 复制代码 
<template>
  <div class="father">
    <h3>父组件</h3>
		<h4>我的车：{{ car }}</h4>
		<h4>儿子给的玩具：{{ toy }}</h4>
		<Child :car="car" :getToy="getToy"/>
  </div>
</template>

<script setup lang="ts" name="Father">
	import Child from './Child.vue'
	import { ref } from "vue";
	// 数据
	const car = ref('奔驰')
	const toy = ref()
	// 方法
	function getToy(value:string){
		toy.value = value
	}
</script>

子组件

vue 复制代码 
<template>
  <div class="child">
    <h3>子组件</h3>
		<h4>我的玩具：{{ toy }}</h4>
		<h4>父给我的车：{{ car }}</h4>
		<button @click="getToy(toy)">玩具给父亲</button>
  </div>
</template>

<script setup lang="ts" name="Child">
	import { ref } from "vue";
	const toy = ref('奥特曼')
	
	defineProps(['car','getToy'])
</script>

2.自定义事件

  1. 概述：自定义事件常用于：子 => 父。
  2. 注意区分好：原生事件、自定义事件。ref值在模板写时不需要.value
  • 原生事件：
    • 事件名是特定的（click、mosueenter等等）
    • 事件对象$event: 是包含事件相关信息的对象（pageX、pageY、target、keyCode）
  • 自定义事件：
    • 事件名是任意名称
    • 事件对象$event: 是调用emit时所提供的数据，可以是任意类型！！！

示例：

html 复制代码 
<!--在父组件中，给子组件绑定自定义事件：-->
<Child @send-toy="toy = $event"/>

<!--注意区分原生事件与自定义事件中的$event-->
<button @click="toy = $event">测试</button>
js 复制代码 
//子组件中，触发事件：
this.$emit('send-toy', 具体数据)

3.mitt

Mitt 是一个 200 字节 的 JavaScript 事件发射器/发布订阅库，专为浏览器和 Node.js 设计。它是 Vue 3 生态中替代 $on、$off、$emit 事件系统的流行选择。

就相当于AB两个组件要进行信息交互，通过mitt可以实现，类似于第三方帮助

概述：与消息订阅与发布（pubsub）功能类似，可以实现任意组件间通信。

方案 大小 特点 适用场景
Mitt 200b 极简、零依赖 轻量级事件总线
Vuex 40kb+ 完整状态管理 复杂状态管理
Pinia 1kb 轻量状态管理 Vue 3 状态管理
EventEmitter3 8kb 功能丰富 Node.js 风格事件
RxJS 29kb 响应式编程 复杂数据流

安装mitt

shell 复制代码 
npm i mitt

新建文件：src\utils\emitter.ts

javascript 复制代码 
// 引入mitt 
import mitt from "mitt";

// 创建emitter
const emitter = mitt()

/*所有的事件
  // 绑定事件
  emitter.on('abc',(value)=>{
    console.log('abc事件被触发',value)
  })
  emitter.on('xyz',(value)=>{
    console.log('xyz事件被触发',value)
  })

  setInterval(() => {
    // 触发事件
    emitter.emit('abc',666)
    emitter.emit('xyz',777)
  }, 1000);//这里在控制台中能够看到有运行

  setTimeout(() => {
    // 清理事件
    emitter.all.clear()
  }, 3000); 
*/

// 创建并暴露mitt
export default emitter

接收数据的组件中：绑定事件、同时在销毁前解绑事件：

typescript 复制代码 
import emitter from "@/utils/emitter";
import { onUnmounted } from "vue";

// 绑定事件
emitter.on('send-toy',(value)=>{
  console.log('send-toy事件被触发',value)
})

onUnmounted(()=>{
  // 解绑事件
  emitter.off('send-toy')
})

提供数据的组件，在合适的时候触发事件

javascript 复制代码 
import emitter from "@/utils/emitter";

function sendToy(){
  // 触发事件
  emitter.emit('send-toy',toy.value)
}

注意这个重要的内置关系，总线依赖着这个内置关系

4.v-model

v-model 是 Vue 中实现表单输入元素双向绑定 的指令，本质上是 :value 和 @input 的语法糖。v-model用在html标签上

  1. 概述：实现 父↔子 之间相互通信。

  2. 前序知识 ------ v-model的本质

    vue 复制代码 
    <!-- 使用v-model指令 -->
<input type="text" v-model="userName">
<!-- 相当于 -->
<input type="text" :value="username" @input="username = (<HTMLInputElement>$event.target).value"> 
<!-- v-model的本质是下面这行代码 -->
<input 
  type="text" 
  :value="userName" 
  @input="userName =(<HTMLInputElement>$event.target).value"
>

  3. 组件标签上的v-model的本质：:moldeValue ＋ update:modelValue事件。

    vue 复制代码 
    <!-- 组件标签上使用v-model指令 -->
<AtguiguInput v-model="userName"/>

<!-- 组件标签上v-model的本质 -->
<AtguiguInput :modelValue="userName" @update:model-value="userName = $event"/>

    AtguiguInput组件中：

    vue 复制代码 
    <template>
  <div class="box">
    <!--将接收的value值赋给input元素的value属性，目的是：为了呈现数据 -->
		<!--给input元素绑定原生input事件，触发input事件时，进而触发update:model-value事件-->
    <input 
       type="text" 
       :value="modelValue" 
       @input="emit('update:model-value',$event.target.value)"
    >
  </div>
</template>

<script setup lang="ts" name="AtguiguInput">
  // 接收props
  defineProps(['modelValue'])
  // 声明事件
  const emit = defineEmits(['update:model-value'])
</script>

  4. 也可以更换value，例如改成abc

    vue 复制代码 
    <!-- 也可以更换value，例如改成abc-->
<AtguiguInput v-model:abc="userName"/>

<!-- 上面代码的本质如下 -->
<AtguiguInput :abc="userName" @update:abc="userName = $event"/>

    AtguiguInput组件中：

    vue 复制代码 
    <template>
  <div class="box">
    <input 
       type="text" 
       :value="abc" 
       @input="emit('update:abc',$event.target.value)"
    >
  </div>
</template>

<script setup lang="ts" name="AtguiguInput">
  // 接收props
  defineProps(['abc'])
  // 声明事件
  const emit = defineEmits(['update:abc'])
</script>

  5. 如果value可以更换，那么就可以在组件标签上多次使用v-model

    vue 复制代码 
    <AtguiguInput v-model:abc="userName" v-model:xyz="password"/>

$event到底是什么？什么时候能.target

对于原生事件，$event就是事件对象 ====> 能.target

对于自定义事件，$event就是触发事件时，所传递的数据 ===> 不能.target

5.$attrs

$attrs 是一个 Vue 实例属性，包含了父组件传递给子组件但未被子组件显式声明为 props 或 emits 的所有属性。

  1. 概述：$attrs用于实现当前组件的父组件 ，向当前组件的子组件 通信（祖→孙）。

  2. 具体说明：$attrs是一个对象，包含所有父组件传入的标签属性。

    注意：$attrs会自动排除props中声明的属性(可以认为声明过的 props 被子组件自己"消费"了)

父组件：

vue 复制代码 
<template>
  <div class="father">
    <h3>父组件</h3>
		<Child :a="a" :b="b" :c="c" :d="d" v-bind="{x:100,y:200}" :updateA="updateA"/>
  </div>
</template>

<script setup lang="ts" name="Father">
	import Child from './Child.vue'
	import { ref } from "vue";
	let a = ref(1)
	let b = ref(2)
	let c = ref(3)
	let d = ref(4)

	function updateA(value){
		a.value = value
	}
</script>

子组件：

vue 复制代码 
<template>
	<div class="child">
		<h3>子组件</h3>
		<GrandChild v-bind="$attrs"/>
	</div>
</template>

<script setup lang="ts" name="Child">
	import GrandChild from './GrandChild.vue'
</script>

孙组件：

vue 复制代码 
<template>
	<div class="grand-child">
		<h3>孙组件</h3>
		<h4>a：{{ a }}</h4>
		<h4>b：{{ b }}</h4>
		<h4>c：{{ c }}</h4>
		<h4>d：{{ d }}</h4>
		<h4>x：{{ x }}</h4>
		<h4>y：{{ y }}</h4>
		<button @click="updateA(666)">点我更新A</button>
	</div>
</template>

<script setup lang="ts" name="GrandChild">
	defineProps(['a','b','c','d','x','y','updateA'])
</script>

6.$refs、parent

$refs 是一个包含所有已注册 ref 的元素或组件实例的对象。

$parent 访问父组件实例，在子组件使用

ref在relative中时，访问直接读取value属性，因为ref在响应式对象中。

  1. 概述：

    • $refs用于 ：父→子。
    • $parent用于：子→父。

  2. 原理如下：

    属性 说明
    $refs 值为对象，包含所有被ref属性标识的DOM元素或组件实例。
    $parent 值为对象，当前组件的父组件实例对象。

7.provide、inject

provide 和 inject 是 Vue 3 提供的依赖注入 机制，用于跨层级组件通信 ，特别适合祖先组件向后代组件传递数据的场景。

  1. 概述：实现祖孙组件直接通信

  2. 具体使用：

    • 在祖先组件中通过provide配置向后代组件提供数据
    • 在后代组件中通过inject配置来声明接收数据

  3. 具体编码：

    【第一步】父组件中，使用provide提供数据

    vue 复制代码 
    <template>
  <div class="father">
    <h3>父组件</h3>
    <h4>资产：{{ money }}</h4>
    <h4>汽车：{{ car }}</h4>
    <button @click="money += 1">资产+1</button>
    <button @click="car.price += 1">汽车价格+1</button>
    <Child/>
  </div>
</template>

<script setup lang="ts" name="Father">
  import Child from './Child.vue'
  import { ref,reactive,provide } from "vue";
  // 数据
  let money = ref(100)
  let car = reactive({
    brand:'奔驰',
    price:100
  })
  // 用于更新money的方法
  function updateMoney(value:number){
    money.value += value
  }
  // 提供数据
  provide('moneyContext',{money,updateMoney})
  provide('car',car)
</script>

    注意：子组件中不用编写任何东西，是不受到任何打扰的

    【第二步】孙组件中使用inject配置项接受数据。

    vue 复制代码 
    <template>
  <div class="grand-child">
    <h3>我是孙组件</h3>
    <h4>资产：{{ money }}</h4>
    <h4>汽车：{{ car }}</h4>
    <button @click="updateMoney(6)">点我</button>
  </div>
</template>

<script setup lang="ts" name="GrandChild">
  import { inject } from 'vue';
  // 注入数据
 let {money,updateMoney} = inject('moneyContext',{money:0,updateMoney:(x:number)=>{}})
  let car = inject('car')
</script>

8.pinia

之前pinia部分有讲解

9.slot

默认插槽

vue 复制代码 
父组件中：
        <Category title="今日热门游戏">
          <ul>
            <li v-for="g in games" :key="g.id">{{ g.name }}</li>
          </ul>
        </Category>
子组件中：
        <template>
          <div class="item">
            <h3>{{ title }}</h3>
            <!-- 默认插槽 -->
            <slot></slot>
          </div>
        </template>

具名插槽

v-slot只能用在component和中

vue 复制代码 
父组件中：
        <Category title="今日热门游戏">
          <template v-slot:s1>
            <ul>
              <li v-for="g in games" :key="g.id">{{ g.name }}</li>
            </ul>
          </template>
          <template #s2>
            <a href="">更多</a>
          </template>
        </Category>
子组件中：
        <template>
          <div class="item">
            <h3>{{ title }}</h3>
            <slot name="s1"></slot>
            <slot name="s2"></slot>
          </div>
        </template>

作用域插槽

作用域插槽（Scoped Slots）是子组件向父组件传递数据的一种插槽机制，允许父组件在插槽内容中访问子组件的数据。

数据在孩子处，但由于数据生成的结构在父亲处，由父亲决定

  1. 理解：数据在组件的自身，但根据数据生成的结构需要组件的使用者来决定。（新闻数据在News组件中，但使用数据所遍历出来的结构由App组件决定）

  2. 具体编码：

    vue 复制代码 
    父组件中：
      <Game v-slot="params">
      <!-- <Game v-slot:default="params"> -->
      <!-- <Game #default="params"> -->
        <ul>
          <li v-for="g in params.games" :key="g.id">{{ g.name }}</li>
        </ul>
      </Game>

子组件中：
      <template>
        <div class="category">
          <h2>今日游戏榜单</h2>
          <slot :games="games" a="哈哈"></slot>
        </div>
      </template>

      <script setup lang="ts" name="Category">
        import {reactive} from 'vue'
        let games = reactive([
          {id:'asgdytsa01',name:'英雄联盟'},
          {id:'asgdytsa02',name:'王者荣耀'},
          {id:'asgdytsa03',name:'红色警戒'},
          {id:'asgdytsa04',name:'斗罗大陆'}
        ])
      </script>

四.其它 API

1.shallowRef 与 shallowReactive

shallowRef

  1. 作用：创建一个响应式数据，但只对顶层属性进行响应式处理。

  2. 用法：

    js 复制代码 
    let myVar = shallowRef(initialValue);

  3. 特点：只跟踪引用值的变化，不关心值内部的属性变化。

shallowReactive

  1. 作用：创建一个浅层响应式对象，只会使对象的最顶层属性变成响应式的，对象内部的嵌套属性则不会变成响应式的

  2. 用法：

    js 复制代码 
    const myObj = shallowReactive({ ... });

  3. 特点：对象的顶层属性是响应式的，但嵌套对象的属性不是。

总结

通过使用 shallowRef() 和 shallowReactive() 来绕开深度响应。浅层式 API 创建的状态只在其顶层是响应式的，对所有深层的对象不会做任何处理，避免了对每一个内部属性做响应式所带来的性能成本，这使得属性的访问变得更快，可提升性能。

2.readonly 与 shallowReadonly

readonly

  1. 作用：用于创建一个对象的深只读副本。

  2. 用法：

    js 复制代码 
    const original = reactive({ ... });
const readOnlyCopy = readonly(original);

  3. 特点：

    • 对象的所有嵌套属性都将变为只读。
    • 任何尝试修改这个对象的操作都会被阻止（在开发模式下，还会在控制台中发出警告）。

  4. 应用场景：

    • 创建不可变的状态快照。
    • 保护全局状态或配置不被修改。

shallowReadonly

  1. 作用：与 readonly 类似，但只作用于对象的顶层属性。

  2. 用法：

    js 复制代码 
    const original = reactive({ ... });
const shallowReadOnlyCopy = shallowReadonly(original);

  3. 特点：

    • 只将对象的顶层属性设置为只读，对象内部的嵌套属性仍然是可变的。
    • 适用于只需保护对象顶层属性的场景。

3.toRaw 与 markRaw

toRaw

  1. 作用：用于获取一个响应式对象的原始对象， toRaw 返回的对象不再是响应式的，不会触发视图更新。

    官网描述：这是一个可以用于临时读取而不引起代理访问/跟踪开销，或是写入而不触发更改的特殊方法。不建议保存对原始对象的持久引用，请谨慎使用。
    何时使用？ ------ 在需要将响应式对象传递给非 Vue 的库或外部系统时，使用 toRaw 可以确保它们收到的是普通对象

  2. 具体编码：

    js 复制代码 
    import { reactive,toRaw,markRaw,isReactive } from "vue";

/* toRaw */
// 响应式对象
let person = reactive({name:'tony',age:18})
// 原始对象
let rawPerson = toRaw(person)


/* markRaw */
let citysd = markRaw([
  {id:'asdda01',name:'北京'},
  {id:'asdda02',name:'上海'},
  {id:'asdda03',name:'天津'},
  {id:'asdda04',name:'重庆'}
])
// 根据原始对象citys去创建响应式对象citys2 ------ 创建失败，因为citys被markRaw标记了
let citys2 = reactive(citys)
console.log(isReactive(person))
console.log(isReactive(rawPerson))
console.log(isReactive(citys))
console.log(isReactive(citys2))

markRaw

  1. 作用：标记一个对象，使其永远不会变成响应式的。

    例如使用mockjs时，为了防止误把mockjs变为响应式对象，可以使用 markRaw 去标记mockjs

  2. 编码：

    js 复制代码 
    /* markRaw */
let citys = markRaw([
  {id:'asdda01',name:'北京'},
  {id:'asdda02',name:'上海'},
  {id:'asdda03',name:'天津'},
  {id:'asdda04',name:'重庆'}
])
// 根据原始对象citys去创建响应式对象citys2 ------ 创建失败，因为citys被markRaw标记了
let citys2 = reactive(citys)

4.customRef

作用：创建一个自定义的ref，并对其依赖项跟踪和更新触发进行逻辑控制。

实现防抖效果（useSumRef.ts）：

typescript 复制代码 
import {customRef } from "vue";

export default function(initValue:string,delay:number){
  let msg = customRef((track,trigger)=>{
    let timer:number
    return {
      get(){
        track() // 告诉Vue数据msg很重要，要对msg持续关注，一旦变化就更新
        return initValue
      },
      set(value){
        clearTimeout(timer)
        timer = setTimeout(() => {
          initValue = value
          trigger() //通知Vue数据msg变化了
        }, delay);
      }
    }
  }) 
  return {msg}
}

组件中使用：

五.Vue3新组件

1.Teleport

  • 什么是Teleport？------ Teleport 是一种能够将我们的组件html结构移动到指定位置的技术。
html 复制代码 
<teleport to='body' >
    <div class="modal" v-show="isShow">
      <h2>我是一个弹窗</h2>
      <p>我是弹窗中的一些内容</p>
      <button @click="isShow = false">关闭弹窗</button>
    </div>
</teleport>

2.Suspense

  • 等待异步组件时渲染一些额外内容，让应用有更好的用户体验
  • 使用步骤：
    • 异步引入组件
    • 使用Suspense包裹组件，并配置好default 与 fallback
tsx 复制代码 
import { defineAsyncComponent,Suspense } from "vue";
const Child = defineAsyncComponent(()=>import('./Child.vue'))
vue 复制代码 
<template>
    <div class="app">
        <h3>我是App组件</h3>
        <Suspense>
          <template v-slot:default>
            <Child/>
          </template>
          <template v-slot:fallback>
            <h3>加载中.......</h3>
          </template>
        </Suspense>
    </div>
</template>

3.全局API转移到应用对象

  • app.component
  • app.config
  • app.directive
  • app.mount
  • app.unmount
  • app.use

4.其他

  • 过渡类名 v-enter 修改为 v-enter-from、过渡类名 v-leave 修改为 v-leave-from。

  • keyCode 作为 v-on 修饰符的支持。

  • v-model 指令在组件上的使用已经被重新设计，替换掉了 v-bind.sync。

  • v-if 和 v-for 在同一个元素身上使用时的优先级发生了变化。

  • 移除了$on、$off 和 $once 实例方法。

  • 移除了过滤器 filter。

  • 移除了$children 实例 propert。

ut(() => {

initValue = value

trigger() //通知Vue数据msg变化了

}, delay);

}

}

})

return {msg}

}

复制代码 
组件中使用：

# 8. Vue3新组件

## Teleport

- 什么是Teleport？------ Teleport 是一种能够将我们的**组件html结构**移动到指定位置的技术。

```html
<teleport to='body' >
    <div class="modal" v-show="isShow">
      <h2>我是一个弹窗</h2>
      <p>我是弹窗中的一些内容</p>
      <button @click="isShow = false">关闭弹窗</button>
    </div>
</teleport>
相关推荐
调皮LE1 小时前
前端 HTML 转 PDF
前端
Nan_Shu_6141 小时前
熟悉RuoYi-Vue-Plus-前端 （1）
前端·javascript·vue.js
23124_801 小时前
网络管理-1
运维·服务器·前端
PBitW1 小时前
Electron 初体验
前端·electron·trae
D***M9761 小时前
WebSpoon9.0（KETTLE的WEB版本）编译 + tomcatdocker部署 + 远程调试教程
前端
南囝coding1 小时前
《独立开发者精选工具》第 023 期
前端·后端·开源
文心快码BaiduComate1 小时前
Agent如何重塑跨角色协作的AI提效新范式
前端·后端·程序员
梦6501 小时前
react日历组件
前端·javascript·react.js
网络点点滴1 小时前
Vue3路由params参数
前端·javascript·vue.js
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）04BongoCat - 跨平台键盘猫动画工具05Linux下V2Ray安装配置指南06本地部署阿里最新开源的Z-Image07Meta第三代“分割一切”模型——SAM 3本地部署教程：首支持文本提示分割，400万概念、30毫秒响应，检测分割追踪一网打尽08Gemini 3.0 Pro Preview 实测报告0946个Nano-banana 精选提示词，持续更新中10【保姆级教程】免费使用Gemini3的5种方法！免翻墙/国内直连