关于前端:Vue3的7种和Vue2的12种组件通信值得收藏

54次阅读

共计 10205 个字符，预计需要花费 26 分钟才能阅读完成。

本文原文首发掘金：https://juejin.cn/post/699968…

如有不对的或者脱漏的，欢送斧正，你的一赞一评都是我前行最大的能源，感激

Vue2.x 组件通信 12 种形式写在前面了，先来 Vue3 的

奥力给！

Vue3 组件通信形式

  • props
  • $emit
  • expose / ref
  • $attrs
  • v-model
  • provide / inject
  • Vuex

Vue3 通信应用写法

props

用 props 传数据给子组件有两种办法，如下

办法一，混合写法

// Parent.vue 传送
<child :msg1="msg1" :msg2="msg2"></child>
<script>
import child from "./child.vue"
import {ref, reactive} from "vue"
export default {data(){
        return {msg1:"这是传级子组件的信息 1"}
    },
    setup(){
        // 创立一个响应式数据
        
        // 写法一 实用于根底类型  ref 还有其余用途，上面章节有介绍
        const msg2 = ref("这是传级子组件的信息 2")
        
        // 写法二 实用于简单类型，如数组、对象
        const msg2 = reactive(["这是传级子组件的信息 2"])
        
        return {msg2}
    }
}
</script>

// Child.vue 接管
<script>
export default {props: ["msg1", "msg2"],// 如果这行不写，上面就接管不到
  setup(props) {console.log(props) // {msg1:"这是传给子组件的信息 1", msg2:"这是传给子组件的信息 2"}
  },
}
</script>

办法二，纯 Vue3 写法

// Parent.vue 传送
<child :msg2="msg2"></child>
<script setup>
    import child from "./child.vue"
    import {ref, reactive} from "vue"
    const msg2 = ref("这是传给子组件的信息 2")
    // 或者简单类型
    const msg2 = reactive(["这是传级子组件的信息 2"])
</script>

// Child.vue 接管
<script setup>
    // 不须要引入 间接应用
    // import {defineProps} from "vue"
    const props = defineProps({
        // 写法一
        msg2: String
        // 写法二
        msg2:{
            type:String,
            default:""
        }
    })
    console.log(props) // {msg2:"这是传级子组件的信息 2"}
</script>

留神：

如果父组件是混合写法，子组件纯 Vue3 写法的话，是接管不到父组件里 data 的属性，只能接管到父组件里 setup 函数里传的属性

如果父组件是纯 Vue3 写法，子组件混合写法，能够通过 props 接管到 data 和 setup 函数里的属性，然而子组件要是在 setup 里接管，同样只能接管到父组件中 setup 函数里的属性，接管不到 data 里的属性

官网也说了，既然用了 3，就不要写 2 了，所以不举荐混合写法。上面的例子，一律只用纯 Vue3 的写法，就不写混合写法了

$emit

// Child.vue 派发
<template>
    // 写法一
    <button @click="emit('myClick')"> 按钮 </buttom>
    // 写法二
    <button @click="handleClick"> 按钮 </buttom>
</template>
<script setup>
    
    // 办法一 实用于 Vue3.2 版本 不须要引入
    // import {defineEmits} from "vue"
    // 对应写法一
    const emit = defineEmits(["myClick","myClick2"])
    // 对应写法二
    const handleClick = ()=>{emit("myClick", "这是发送给父组件的信息")
    }
    
    // 办法二 不适用于 Vue3.2 版本，该版本 useContext()已废除
    import {useContext} from "vue"
    const {emit} = useContext()
    const handleClick = ()=>{emit("myClick", "这是发送给父组件的信息")
    }
</script>

// Parent.vue 响应
<template>
    <child @myClick="onMyClick"></child>
</template>
<script setup>
    import child from "./child.vue"
    const onMyClick = (msg) => {console.log(msg) // 这是父组件收到的信息
    }
</script>

expose / ref

父组件获取子组件的属性或者调用子组件办法

// Child.vue
<script setup>
    // 办法一 不适用于 Vue3.2 版本，该版本 useContext()已废除
    import {useContext} from "vue"
    const ctx = useContext()
    // 对外裸露属性办法等都能够
    ctx.expose({
        childName: "这是子组件的属性",
        someMethod(){console.log("这是子组件的办法")
        }
    })
    
    // 办法二 实用于 Vue3.2 版本, 不须要引入
    // import {defineExpose} from "vue"
    defineExpose({
        childName: "这是子组件的属性",
        someMethod(){console.log("这是子组件的办法")
        }
    })
</script>

// Parent.vue  留神 ref="comp"
<template>
    <child ref="comp"></child>
    <button @click="handlerClick"> 按钮 </button>
</template>
<script setup>
    import child from "./child.vue"
    import {ref} from "vue"
    const comp = ref(null)
    const handlerClick = () => {console.log(comp.value.childName) // 获取子组件对外裸露的属性
        comp.value.someMethod() // 调用子组件对外裸露的办法}
</script>

attrs

attrs：蕴含父作用域里除 class 和 style 除外的非 props 属性汇合

// Parent.vue 传送
<child :msg1="msg1" :msg2="msg2" title="3333"></child>
<script setup>
    import child from "./child.vue"
    import {ref, reactive} from "vue"
    const msg1 = ref("1111")
    const msg2 = ref("2222")
</script>

// Child.vue 接管
<script setup>
    import {defineProps, useContext, useAttrs} from "vue"
    // 3.2 版本不须要引入 defineProps，间接用
    const props = defineProps({msg1: String})
    // 办法一 不适用于 Vue3.2 版本，该版本 useContext()已废除
    const ctx = useContext()
    // 如果没有用 props 接管 msg1 的话就是 {msg1: "1111", msg2:"2222", title: "3333"}
    console.log(ctx.attrs) // {msg2:"2222", title: "3333"}
    
    // 办法二 实用于 Vue3.2 版本
    const attrs = useAttrs()
    console.log(attrs) // {msg2:"2222", title: "3333"}
</script>

v-model

能够反对多个数据双向绑定

// Parent.vue
<child v-model:key="key" v-model:value="value"></child>
<script setup>
    import child from "./child.vue"
    import {ref, reactive} from "vue"
    const key = ref("1111")
    const value = ref("2222")
</script>

// Child.vue
<template>
    <button @click="handlerClick"> 按钮 </button>
</template>
<script setup>
    
    // 办法一  不适用于 Vue3.2 版本，该版本 useContext()已废除
    import {useContext} from "vue"
    const {emit} = useContext()
    
    // 办法二 实用于 Vue3.2 版本，不须要引入
    // import {defineEmits} from "vue"
    const emit = defineEmits(["key","value"])
    
    // 用法
    const handlerClick = () => {emit("update:key", "新的 key")
        emit("update:value", "新的 value")
    }
</script>

provide / inject

provide / inject 为依赖注入

provide：能够让咱们指定想要提供给后辈组件的数据或

inject：在任何后辈组件中接管想要增加在这个组件上的数据，不论组件嵌套多深都能够间接拿来用

// Parent.vue
<script setup>
    import {provide} from "vue"
    provide("name", "沐华")
</script>

// Child.vue
<script setup>
    import {inject} from "vue"
    const name = inject("name")
    console.log(name) // 沐华
</script>

Vuex

// store/index.js
import {createStore} from "vuex"
export default createStore({state:{ count: 1},
    getters:{getCount: state => state.count},
    mutations:{add(state){state.count++}
    }
})

// main.js
import {createApp} from "vue"
import App from "./App.vue"
import store from "./store"
createApp(App).use(store).mount("#app")

// Page.vue
// 办法一 间接应用
<template>
    <div>{{$store.state.count}}</div>
    <button @click="$store.commit('add')"> 按钮 </button>
</template>

// 办法二 获取
<script setup>
    import {useStore, computed} from "vuex"
    const store = useStore()
    console.log(store.state.count) // 1

    const count = computed(()=>store.state.count) // 响应式，会随着 vuex 数据扭转而扭转
    console.log(count) // 1 
</script>

Vue2.x 组件通信形式

Vue2.x 组件通信共有 12 种

  1. props
  2. $emit / v-on
  3. .sync
  4. v-model
  5. ref
  6. $children / $parent
  7. $attrs / $listeners
  8. provide / inject
  9. EventBus
  10. Vuex
  11. $root
  12. slot

父子组件通信能够用：

  • props
  • $emit / v-on
  • $attrs / $listeners
  • ref
  • .sync
  • v-model
  • $children / $parent

兄弟组件通信能够用：

  • EventBus
  • Vuex
  • $parent

跨层级组件通信能够用：

  • provide/inject
  • EventBus
  • Vuex
  • $attrs / $listeners
  • $root

Vue2.x 通信应用写法

上面把每一种组件通信形式的写法一一列出

1. props

父组件向子组件传送数据，这应该是最罕用的形式了

子组件接管到数据之后，不能间接批改 父组件的数据。会报错，所以当父组件从新渲染时，数据会被笼罩。如果子组件内要批改的话举荐应用 computed

// Parent.vue 传送
<template>
    <child :msg="msg"></child>
</template>

// Child.vue 接管
export default {
  // 写法一 用数组接管
  props:['msg'],
  // 写法二 用对象接管，能够限定接管的数据类型、设置默认值、验证等
  props:{
      msg:{
          type:String,
          default:'这是默认数据'
      }
  },
  mounted(){console.log(this.msg)
  },
}

2. .sync

能够帮咱们实现父组件向子组件传递的数据 的双向绑定，所以子组件接管到数据后 能够间接批改，并且会同时批改父组件的数据

// Parent.vue
<template>
    <child :page.sync="page"></child>
</template>
<script>
export default {data(){
        return {page:1}
    }
}

// Child.vue
export default {props:["page"],
    computed(){
        // 当咱们在子组件里批改 currentPage 时，父组件的 page 也会随之扭转
        currentPage {get(){return this.page},
            set(newVal){this.$emit("update:page", newVal)
            }
        }
    }
}
</script>

3. v-model

和 .sync 相似，能够实现将父组件传给子组件的数据为双向绑定，子组件通过 $emit 批改父组件的数据

// Parent.vue
<template>
    <child v-model="value"></child>
</template>
<script>
export default {data(){
        return {value:1}
    }
}

// Child.vue
<template>
    <input :value="value" @input="handlerChange">
</template>
export default {props:["value"],
    // 能够批改事件名，默认为 input
    model:{event:"updateValue"},
    methods:{handlerChange(e){this.$emit("input", e.target.value)
            // 如果有下面的重命名就是这样
            this.$emit("updateValue", e.target.value)
        }
    }
}
</script>

4. ref

ref 如果在一般的 DOM 元素上，援用指向的就是该 DOM 元素;

如果在子组件上，援用的指向就是子组件实例，而后父组件就能够通过 ref 被动获取子组件的属性或者调用子组件的办法

// Child.vue
export default {data(){
        return {name:"沐华"}
    },
    methods:{someMethod(msg){console.log(msg)
        }
    }
}

// Parent.vue
<template>
    <child ref="child"></child>
</template>
<script>
export default {mounted(){
        const child = this.$refs.child
        console.log(child.name) // 沐华
        child.someMethod("调用了子组件的办法")
    }
}
</script>

5. $emit / v-on

子组件通过派发事件的形式给父组件数据，或者触发父组件更新等操作

// Child.vue 派发
export default {data(){return { msg: "这是发给父组件的信息"}
  },
  methods: {handleClick(){this.$emit("sendMsg",this.msg)
      }
  },
}
// Parent.vue 响应
<template>
    <child v-on:sendMsg="getChildMsg"></child>
    // 或 简写
    <child @sendMsg="getChildMsg"></child>
</template>

export default {
    methods:{getChildMsg(msg){console.log(msg) // 这是父组件接管到的音讯
        }
    }
}

6. $attrs / $listeners

多层嵌套组件传递数据时，如果只是传递数据，而不做两头解决的话就能够用这个，比方父组件向孙子组件传递数据时

$attrs：蕴含父作用域里除 class 和 style 除外的非 props 属性汇合。通过 this.$attrs 获取父作用域中所有符合条件的属性汇合，而后还要持续传给子组件外部的其余组件，就能够通过 v-bind=”$attrs”

$listeners：蕴含父作用域里 .native 除外的监听 事件汇合。如果还要持续传给子组件外部的其余组件，就能够通过 v-on=”$linteners”

应用形式是雷同的

// Parent.vue
<template>
    <child :name="name" title="1111" ></child>
</template
export default{data(){
        return {name:"沐华"}
    }
}

// Child.vue
<template>
    // 持续传给孙子组件
    <sun-child v-bind="$attrs"></sun-child>
</template>
export default{props:["name"], // 这里能够接管，也能够不接管
    mounted(){// 如果 props 接管了 name 就是 { title:1111}，否则就是{name:"沐华", title:1111}
        console.log(this.$attrs)
    }
}

7. $children / $parent

$children：获取到一个蕴含所有子组件 (不蕴含孙子组件) 的 VueComponent 对象数组，能够间接拿到子组件中所有数据和办法等

$parent：获取到一个父节点的 VueComponent 对象，同样蕴含父节点中所有数据和办法等

// Parent.vue
export default{mounted(){this.$children[0].someMethod() // 调用第一个子组件的办法
        this.$children[0].name // 获取第一个子组件中的属性
    }
}

// Child.vue
export default{mounted(){this.$parent.someMethod() // 调用父组件的办法
        this.$parent.name // 获取父组件中的属性
    }
}

8. provide / inject

provide / inject 为依赖注入，说是不举荐间接用于利用程序代码中，然而在一些插件或组件库里却是被罕用，所以我感觉用也没啥，还挺好用的

provide：能够让咱们指定想要提供给后辈组件的数据或办法

inject：在任何后辈组件中接管想要增加在这个组件上的数据或办法，不论组件嵌套多深都能够间接拿来用

要留神的是 provide 和 inject 传递的数据不是响应式的，也就是说用 inject 接管来数据后，provide 里的数据扭转了，后辈组件中的数据不会扭转，除非传入的就是一个可监听的对象

所以倡议还是传递一些常量或者办法

// 父组件
export default{
    // 办法一 不能获取 methods 中的办法
    provide:{
        name:"沐华",
        age: this.data 中的属性
    },
    // 办法二 不能获取 data 中的属性
    provide(){
        return {
            name:"沐华",
            someMethod:this.someMethod // methods 中的办法
        }
    },
    methods:{someMethod(){console.log("这是注入的办法")
        }
    }
}

// 后辈组件
export default{inject:["name","someMethod"],
    mounted(){console.log(this.name)
        this.someMethod()}
}

9. EventBus

EventBus 是地方事件总线，不论是父子组件，兄弟组件，跨层级组件等都能够应用它实现通信操作

定义形式有三种

// 办法一
// 抽离成一个独自的 js 文件 Bus.js，而后在须要的中央引入
// Bus.js
import Vue from "vue"
export default new Vue()

// 办法二 间接挂载到全局
// main.js
import Vue from "vue"
Vue.prototype.$bus = new Vue()

// 办法三 注入到 Vue 根对象上
// main.js
import Vue from "vue"
new Vue({
    el:"#app",
    data:{Bus: new Vue()
    }
})

应用如下，以办法一按需引入为例

// 在须要向内部发送自定义事件的组件内
<template>
    <button @click="handlerClick"> 按钮 </button>
</template>
import Bus from "./Bus.js"
export default{
    methods:{handlerClick(){
            // 自定义事件名 sendMsg
            Bus.$emit("sendMsg", "这是要向内部发送的数据")
        }
    }
}

// 在须要接管内部事件的组件内
import Bus from "./Bus.js"
export default{mounted(){
        // 监听事件的触发
        Bus.$on("sendMsg", data => {console.log("这是接管到的数据：", data)
        })
    },
    beforeDestroy(){
        // 勾销监听
        Bus.$off("sendMsg")
    }
}

10. Vuex

Vuex 是状态管理器，集中式存储管理所有组件的状态。这一块内容过长，如果根底不熟的话能够看这个 Vuex，而后大抵用法如下

比方创立这样的文件构造

index.js 里内容如下

import Vue from 'vue'
import Vuex from 'vuex'
import getters from './getters'
import actions from './actions'
import mutations from './mutations'
import state from './state'
import user from './modules/user'

Vue.use(Vuex)

const store = new Vuex.Store({
  modules: {user},
  getters,
  actions,
  mutations,
  state
})
export default store

而后在 main.js 引入

import Vue from "vue"
import store from "./store"
new Vue({
    el:"#app",
    store,
    render: h => h(App)
})

而后在须要的应用组件里

import {mapGetters, mapMutations} from "vuex"
export default{
    computed:{
        // 形式一 而后通过 this. 属性名就能够用了
        ...mapGetters(["引入 getters.js 里属性 1","属性 2"])
        // 形式二
        ...mapGetters("user", ["user 模块里的属性 1","属性 2"])
    },
    methods:{
        // 形式一 而后通过 this. 属性名就能够用了
        ...mapMutations(["引入 mutations.js 里的办法 1","办法 2"])
        // 形式二
        ...mapMutations("user",["引入 user 模块里的办法 1","办法 2"])
    }
}

// 或者也能够这样获取
this.$store.state.xxx
this.$store.state.user.xxx

11. $root

$root 能够拿到 App.vue 里的数据和办法

12. slot

就是把子组件的数据通过插槽的形式传给父组件应用，而后再插回来

// Child.vue
<template>
    <div>
        <slot :user="user"></slot>
    </div>
</template>
export default{data(){
        return {user:{ name:"沐华"}
        }
    }
}

// Parent.vue
<template>
    <div>
        <child v-slot="slotProps">
            {{slotProps.user.name}}
        </child>
    </div>
</template>

结语

写作不易，你的一赞一评，就是我前行的最大能源。

正文完
前端
发表至： 前端
2021-10-21
 0
关于前端:较难解决的问题记录
关于前端:比-MyBatis-快了-100-倍
关于前端:TS-实现-Promise-相关-api
关于前端:50天36位小伙伴开源实时监控工具-HertzBeat-v131-发布