详解vue组件之间相互传值的方式

概述

我们都知道 vue 作为一个轻量级的前端框架，其核心就是组件化开发。vue 就是由一个一个的组件构成的，组件化是它的精髓，也是最强大的功能之一。而组件实例的作用域是相互独立的，这就意味着不同组件之间的数据无法相互引用。

但在实际项目开发过程中，我们需要访问其他组件的数据，这样就就有了组件通信的问题。在 vue 中组件之间的关系有：父子，兄弟，隔代。针对不同的关系，怎么实现数据传递，就是接下来要讲的。

一、父组件向子组件传值

即父组件通过属性的方式向子组件传值，子组件通过 props 来接收。

在父组件的子组件标签中绑定自定义属性

// 父组件
<user-detail :myname="name" />
    
export default {
    components: {
        userdetail
    }
    ......
}

在子组件中使用props（可以是数组也可以是对象）接收即可。可以传多个属性。

// 子组件
export default {
    props: ['myname']
}
​
/*
props: { myname: string } //这样指定传入的类型，如果类型不对会警告
props: { myname: [string, number] } // 多个可能的类型
prosp: { myname: { type: string, requires: true } } //必填的的字符串
props: { 
    childmsg: { 
        type: array, 
        default: () => [] 
    }
}  // default指定默认值
如果 props 验证失败，会在控制台发出一个警告。
*/

子组件接收的父组件的值分为引用类型和普通类型两种：

普通类型：字符串（string）、数字（number）、布尔值（boolean）、空（null）

引用类型：数组（array）、对象（object）

基于 vue 的单向数据流，即组件之间的数据是单向流通的，子组件是不允许直接对父组件传来的值进行修改的，所以应该避免这种直接修改父组件传过来的值的操作，否则控制台会报错。

如果传过来的值是简单数据类型，是可以在子组件中修改，也不会影响其他兄弟组件内同样调用了来自该父组件的值。

具体操作是可以先把传过来的值重新赋值给data中的一个变量，然后再更改那个变量。

// 子组件
export default {
    props: ['myname'],
    data() {
        return {
            name : this.myname    // 把传过来的值赋值给新的变量
        }
    },
    watch: {
        myname(newval) {
            this.name = newval //对父组件传过来的值进行监听，如果改变也对子组件内部的值进行改变
        }
    },
    methods: {
        changename() {  
            this.name = 'lily'  // 这里修改的只是自己内部的值，就不会报错了
        },
    }
}

注：如果不使用 watch 来监听父组件传递的 myname 值，子组件中的 name 值是不会随着父组件的 myname 值进行改变，因为 data 中 name: this.myname 仅仅只是定义了一个初始值。

如果引用类型的值，当在子组件中修改后，父组件的也会修改，因其数据是公用的，其他同样引用了该值的子组件也会跟着被修改。可以理解成父组件传递给子组件的值，就相当于复制了一个副本，这个副本的指针还是指向父组件中的那个，即共享同一个引用。所以除非有特殊需要，否则不要轻易修改。

二、子组件向父组件传值

1.子组件绑定一个事件，通过 this.$emit() 来触发

在子组件中绑定一个事件，并给这个事件定义一个函数

// 子组件
<button @click="changeparentname">改变父组件的name</button>
​
export default {
    methods: {
        //子组件的事件
        changeparentname: function() {
            this.$emit('handlechange', 'jack') // 触发父组件中handlechange事件并传参jack
            // 注：此处事件名称与父组件中绑定的事件名称要一致
        }
    }
}

在父组件中定义并绑定 handlechange 事件

// 父组件
<child @handlechange="changename"></child>
​
methods: {
    changename(name) {  // name形参是子组件中传入的值jack
        this.name = name
    }
}

2.通过 callback 函数

先在父组件中定义一个callback函数，并把 callback 函数传过去

// 父组件
<child :callback="callback"></child>
​
methods: {
    callback: function(name) {
        this.name = name
    }
}

在子组件中接收，并执行 callback 函数

// 子组件
<button @click="callback('jack')">改变父组件的name</button>
​
props: {
    callback: function,
}

3. 通过 $parent / $children 或 $refs 访问组件实例

这两种都是直接得到组件实例，使用后可以直接调用组件的方法或访问数据。

// 子组件
export default {
  data () {
    return {
      title: '子组件'
    }
  },
  methods: {
    sayhello () {
        console.log('hello');
    }
  }
}

// 父组件
<template>
  <child ref="childref" />
</template>
​
<script>
  export default {
    created () {
      // 通过 $ref 来访问子组件
      console.log(this.$refs.childref.title);  // 子组件
      this.$refs.childref.sayhello(); // hello
      
      // 通过 $children 来调用子组件的方法
      this.$children.sayhello(); // hello 
    }
  }
</script>

注：这种方式的组件通信不能跨级。

三、兄弟组件之间传值

1. 还是通过 $emit 和 props 结合的方式

在父组件中给要传值的两个兄弟组件都绑定要传的变量，并定义事件

// 父组件
<child-a :myname="name" />
<child-b :myname="name" @changename="editname" />  
    
export default {
    data() {
        return {
            name: 'john'
        }
    },
    components: {
        'child-a': childa,
        'child-b': childb,
    },
    methods: {
        editname(name) {
            this.name = name
        },
    }
}

在子组件b中接收变量和绑定触发事件

// child-b 组件
<p>姓名：{{ myname }}</p>
<button @click="changename">修改姓名</button>
    
<script>
export default {
    props: ["myname"],
    methods: {
        changename() {
            this.$emit('changename', 'lily')   // 触发事件并传值
        }
    }
}
</script>

// child-a 组件
<p>姓名：{{ newname }}</p>
    
<script>
export default {
    props: ["myname"],
    computed: {
        newname() {
            if(this.myname) { // 判断是否有值传过来
                return this.myname
            }
            return 'john' //没有传值的默认值
        }
    }
}
</script>

即：当子组件b 通过 $emit() 触发了父组件的事件函数 editname，改变了父组件的变量name 值，父组件又可以把改变了的值通过 props 传递给子组件a，从而实现兄弟组件间数据传递。

2.通过一个空 vue 实例

创建一个 eventbus.js 文件，并暴露一个 vue 实例

import vue from 'vue'
export default new vue()

在要传值的文件里导入这个空 vue 实例，绑定事件并通过 $emit 触发事件函数

(也可以在 main.js 中全局引入该 js 文件，我一般在需要使用到的组件中引入)

<template>
    <div>
        <p>姓名: {{ name }}</p>
        <button @click="changename">修改姓名</button>
    </div>
</template>
​
<script>
import { eventbus } from "../eventbus.js"
​
export default {
 data() {
     return {
         name: 'john',
     }
  },
  methods: {
      changename() {
          this.name = 'lily'
          eventbus.$emit("editname", this.name) // 触发全局事件,并且把改变后的值传入事件函数
      }
    }
}
</script>

在接收传值的组件中也导入 vue 实例，通过 $on 监听回调，回调函数接收所有触发事件时传入的参数

import { eventbus } from "../eventbus.js"
​
export default {
    data() {
        return {
            name: ''
        }
    },
    created() {
         eventbus.$on('editname', (name) => {
             this.name = name
         })
    }
}

这种通过创建一个空的 vue 实例的方式，相当于创建了一个事件中心或者说是中转站，用来传递和接收事件。这种方式同样适用于任何组件间的通信，包括父子、兄弟、跨级，对于通信需求简单的项目比较方便，但对于更复杂的情况，或者项目比较大时，可以使用 vue 提供的更复杂的状态管理模式 vuex 来进行处理。

四、多层父子组件通信

有时需要实现通信的两个组件不是直接的父子组件，而是祖父和孙子，或者是跨越了更多层级的父子组件，这种时候就不可能由子组件一级一级的向上传递参数，特别是在组件层级比较深，嵌套比较多的情况下，需要传递的事件和属性较多，会导致代码很混乱。

这时就需要用到 vue 提供的更高阶的方法：provide/inject。

这对选项需要一起使用，以允许一个祖先组件向其所有子孙后代注入一个依赖，不论组件层次有多深，并在起上下游关系成立的时间里始终生效。

provide/inject：简单来说就是在父组件中通过provider来提供变量，然后在子组件中通过inject来注入变量，不管组件层级有多深，在父组件生效的生命周期内，这个变量就一直有效。

父组件：

export default {
  provide: { // 它的作用就是将 **name** 这个变量提供给它的所有子组件。
    name: 'jack'
  }
}

子组件：

export default {
  inject: ['name'], // 注入了从父组件中提供的name变量
  mounted () {
    console.log(this.name);  // jack
  }
}

注：provide 和 inject 绑定并不是可响应的。即父组件的name变化后，子组件不会跟着变。

如果想要实现 provide 和 inject 数据响应，有两种方法：

provide 祖先组件的实例，然后在子孙组件中注入依赖，这样就可以在后代组件中直接修改祖先组件的实例的属性，不过这种方法有个缺点就是这个实例上挂载很多没有必要的东西比如 props，methods

// 父组件　
<div>
      <button @click="changename">修改姓名</button>
      <child-b />
</div>
<script>
    ......
    data() {
        return {
            name: "jack"
        };
    },
    provide() {
        return {
            parentobj: this //提供祖先组件的实例
        };
    },
    methods: {
        changename() {
            this.name = 'lily'
        }
    }
</script>

后代组件中取值：　　

<template>
　　<div class="border2">
　　　　<p>姓名：{{parentobj.name}}</p>
　　</div>
</template>
<script>
　　export default {
　　　　inject: {
　　　　　　parentobj: {
　　　　　　　　default: () => ({})
　　　　　　}
　　　　} // 或者inject: ['parentobj']
　　};
</script>

注：这种方式在函数式组件中用的比较多。函数式组件，即无状态(没有响应式数据)，无实例化(没有 this 上下文)，内部也没有任何生命周期处理方法，所以渲染性能高，比较适合依赖外部数据传递而变化的组件。

总结

父子通信： 父向子传递数据是通过 props，子向父是通过 $emit；通过 $parent / $children 通信；$ref 也可以访问组件实例；provide / inject ；$attrs / $listeners；

兄弟通信：eventbus；vuex；

跨级通信：eventbus；vuex；provide / inject ；$attrs / $listeners；

以上就是详解vue组件之间相互传值的方式的详细内容，更多关于vue的资料请关注其它相关文章！