vue中组件之间传值的六种方式（完整版）

最新推荐文章于 2024-07-16 16:34:25 发布
最新推荐文章于 2024-07-16 16:34:25 发布
阅读量3w 收藏 324
点赞数 45
文章标签： vue.js 前端
原文链接：https://segmentfault.com/a/1190000019208626
版权

前言

  组件是 vue.js 最强大的功能之一，而组件实例的作用域是相互独立的，这就意味着不同组件之间的数据无法相互引用。一般来说，组件可以有以下几种关系：

如上图所示，A 和 B、B 和 C、B 和 D 都是父子关系，C 和 D 是兄弟关系，A 和 C 是隔代关系（可能隔多代）。

  针对不同的使用场景，如何选择行之有效的通信方式？这是我们所要探讨的主题。本文总结了 vue 组件间通信的几种方式，如 props、$emit/$on、vuex、$parent / $children、$attrs/$listeners 和 provide/inject，以通俗易懂的实例讲述这其中的差别及使用场景，希望对小伙伴有些许帮助。

  本文的代码请猛戳 github博客，纸上得来终觉浅，大家动手多敲敲代码！

方法一、props/$emit

  父组件 A 通过 props 的方式向子组件 B 传递，B to A 通过在 B 组件中 $emit, A 组件中 v-on 的方式实现。

1.父组件向子组件传值

  接下来我们通过一个例子，说明父组件如何向子组件传递值：在子组件 Users.vue 中如何获取父组件 App.vue 中的数据 users:["Henry","Bucky","Emily"]

	//App.vue父组件
	<template>
	  <div id="app">
	    <users v-bind:users="users"></users>//前者自定义名称便于子组件调用，后者要传递数据名
	  </div>
	</template>
	<script>
	import Users from "./components/Users"
	export default {
	  name: 'App',
	  data(){
	    return{
	      users:["Henry","Bucky","Emily"]
	    }
	  },
	  components:{
	    "users":Users
	  }
	}

//users子组件
	<template>
	  <div class="hello">
	    <ul>
	      <li v-for="user in users">{{user}}</li>//遍历传递过来的值，然后呈现到页面
	    </ul>
	  </div>
	</template>
	<script>
	export default {
	  name: 'HelloWorld',
	  props:{
	    users:{           //这个就是父组件中子标签自定义名字
	      type:Array,
	      required:true
	    }
	  }
	}
	</script>

 总结：父组件通过 props 向下传递数据给子组件。注：组件中的数据共有三种形式：data、props、computed

2.子组件向父组件传值（通过事件形式）

  接下来我们通过一个例子，说明子组件如何向父组件传递值：当我们点击 “Vue.js Demo” 后，子组件向父组件传递值，文字由原来的“传递的是一个值”变成“子向父组件传值”，实现子组件向父组件值的传递。

	// 子组件
	<template>
	  <header>
	    <h1 @click="changeTitle">{{title}}</h1>//绑定一个点击事件
	  </header>
	</template>
	<script>
	export default {
	  name: 'app-header',
	  data() {
	    return {
	      title:"Vue.js Demo"
	    }
	  },
	  methods:{
	    changeTitle() {
	      this.$emit("titleChanged","子向父组件传值");//自定义事件  传递值“子向父组件传值”
	    }
	  }
	}
	</script>

// 父组件
	<template>
	  <div id="app">
	 	//与子组件titleChanged自定义事件保持一致
	    <app-header v-on:titleChanged="updateTitle" ></app-header>
		// updateTitle($event)接受传递过来的文字
	    <h2>{{title}}</h2>
	  </div>
	</template>
	<script>
	import Header from "./components/Header"
	export default {
	  name: 'App',
	  data(){
	    return{
	      title:"传递的是一个值"
	    }
	  },
	  methods:{
	    updateTitle(e){   //声明这个函数
	      this.title = e;
	    }
	  },
	  components:{
	   "app-header":Header,
	  }
	}
	</script>

 总结：子组件通过 events 给父组件发送消息，实际上就是子组件把自己的数据发送到父组件。

方法二、$emit/$on

  这种方法通过一个空的 Vue 实例作为中央事件总线（事件中心），用它来触发事件和监听事件，巧妙而轻量地实现了任何组件间的通信，包括父子、兄弟、跨级。
  当我们的项目比较大时，可以选择更好的状态管理解决方案 vuex。

1. 具体实现方式：

	var Event=new Vue();
	Event.$emit(事件名,数据);
	Event.$on(事件名,data => {});

2. 举个例子

  假设兄弟组件有三个，分别是 A、B、C 组件，C 组件如何获取 A 或者 B 组件的数据。

<div id="itany">
	    <my-a></my-a>
	    <my-b></my-b>
	    <my-c></my-c>
	</div>
	<template id="a">
	  <div>
	    <h3>A组件：{{name}}</h3>
	    <button @click="send">将数据发送给C组件</button>
	  </div>
	</template>
	<template id="b">
	  <div>
	    <h3>B组件：{{age}}</h3>
	    <button @click="send">将数组发送给C组件</button>
	  </div>
	</template>
	<template id="c">
	  <div>
	    <h3>C组件：{{name}}，{{age}}</h3>
	  </div>
	</template>
	<script>
	var Event = new Vue();//定义一个空的Vue实例
	var A = {
	    template: '#a',
	    data() {
	      return {
	        name: 'tom'
	      }
	    },
	    methods: {
	      send() {
	        Event.$emit('data-a', this.name);
	      }
	    }
	}
	var B = {
	    template: '#b',
	    data() {
	      return {
	        age: 20
	      }
	    },
	    methods: {
	      send() {
	        Event.$emit('data-b', this.age);
	      }
	    }
	}
	var C = {
	    template: '#c',
	    data() {
	      return {
	        name: '',
	        age: ""
	      }
	    },
	    mounted() {//在模板编译完成后执行
	     Event.$on('data-a',name => {
	         this.name = name;//箭头函数内部不会产生新的this，这边如果不用=>,this指代Event
	     })
	     Event.$on('data-b',age => {
	         this.age = age;
	     })
	    }
	}
	var vm = new Vue({
	    el: '#itany',
	    components: {
	      'my-a': A,
	      'my-b': B,
	      'my-c': C
	    }
	});    
	</script>

 $on 监听了自定义事件 data-a 和 data-b，因为有时不确定何时会触发事件，一般会在 mounted 或 created 钩子中来监听。

方法三、vuex

 

1.简要介绍 Vuex 原理

  Vuex 实现了一个单向数据流，在全局拥有一个 State 存放数据，当组件要更改 State 中的数据时，必须通过 Mutation 进行，Mutation 同时提供了订阅者模式供外部插件调用获取 State 数据的更新。而所有异步操作(常见于调用后端接口异步获取更新数据)或批量的同步操作需要走 Action，但 Action 也是无法直接修改 State 的，还是需要通过 Mutation 来修改 State 的数据。最后，根据 State 的变化，渲染到视图上。

2.简要介绍各模块在流程中的功能：

  • Vue Components：Vue组件。HTML页面上，负责接收用户操作等交互行为，执行 dispatch 方法触发对应 action 进行回应。
  • dispatch：操作行为触发方法，是唯一能执行 action 的方法。
  • actions：操作行为处理模块，由组件中的 $store.dispatch('action 名称', data1) 来触发。然后由 commit() 来触发 mutation 的调用 , 间接更新 state。负责处理 Vue Components 接收到的所有交互行为。包含同步/异步操作，支持多个同名方法，按照注册的顺序依次触发。向后台 API 请求的操作就在这个模块中进行，包括触发其他 action 以及提交 mutation 的操作。该模块提供了 Promise 的封装，以支持 action 的链式触发。
  • commit：状态改变提交操作方法。对 mutation 进行提交，是唯一能执行 mutation 的方法。
  • mutations：状态改变操作方法，由 actions 中的 commit('mutation 名称') 来触发。是 Vuex 修改 state 的唯一推荐方法。该方法只能进行同步操作，且方法名只能全局唯一。操作之中会有一些 hook 暴露出来，以进行 state 的监控等。
  • state：页面状态管理容器对象。集中存储 Vue components 中 data 对象的零散数据，全局唯一，以进行统一的状态管理。页面显示所需的数据从该对象中进行读取，利用 Vue 的细粒度数据响应机制来进行高效的状态更新。
  • getters：state 对象读取方法。图中没有单独列出该模块，应该被包含在了 render 中，Vue Components 通过该方法读取全局 state 对象。

3.Vuex 与 localStorage

  vuex 是 vue 的状态管理器，存储的数据是响应式的。但是并不会保存起来，刷新之后就回到了初始状态，具体做法应该在 vuex 里数据改变的时候把数据拷贝一份保存到 localStorage 里面，刷新之后，如果 localStorage 里有保存的数据，取出来再替换 store 里的 state。

	let defaultCity = "上海"
	try {   // 用户关闭了本地存储功能，此时在外层加个try...catch
	  if (!defaultCity){
	    defaultCity = JSON.parse(window.localStorage.getItem('defaultCity'))
	  }
	}catch(e){}
	export default new Vuex.Store({
	  state: {
	    city: defaultCity
	  },
	  mutations: {
	    changeCity(state, city) {
	      state.city = city
	      try {
	      window.localStorage.setItem('defaultCity', JSON.stringify(state.city));
	      // 数据改变的时候把数据拷贝一份保存到localStorage里面
	      } catch (e) {}
	    }
	  }
	})

这里需要注意的是：由于 vuex 里，我们保存的状态，都是数组，而 localStorage 只支持字符串，所以需要用 JSON 转换：

	JSON.stringify(state.subscribeList);   // array -> string
	JSON.parse(window.localStorage.getItem("subscribeList"));    // string -> array

方法四、$attrs/$listeners

1.简介

  多级组件嵌套需要传递数据时，通常使用的方法是通过 vuex。但如果仅仅是传递数据，而不做中间处理，使用 vuex 处理，未免有点大材小用。为此 Vue2.4 版本提供了另一种方法---- $attrs/$listeners

  • $attrs：包含了父作用域中不被 prop 所识别 (且获取) 的特性绑定 (class 和 style 除外)。当一个组件没有声明任何 prop 时，这里会包含所有父作用域的绑定 (class 和 style 除外)，并且可以通过 v-bind="$attrs" 传入内部组件。通常配合 interitAttrs 选项一起使用。
    有关 interitAttrs 详情可见 博客园鲁小风lyf 的文章 vue组件的inheritAttrs属性
  • $listeners：包含了父作用域中的 (不含 .native 修饰器的) v-on 事件监听器。它可以通过 v-on="$listeners" 传入内部组件。

  接下来我们看个跨级通信的例子：

	// index.vue
	<template>
	  <div>
	    <h2>浪里行舟</h2>
	    <child-com1
	      :foo="foo"
	      :boo="boo"
	      :coo="coo"
	      :doo="doo"
	      title="前端工匠"
	    ></child-com1>
	  </div>
	</template>
	<script>
	const childCom1 = () => import("./childCom1.vue");
	export default {
	  components: { childCom1 },
	  data() {
	    return {
	      foo: "Javascript",
	      boo: "Html",
	      coo: "CSS",
	      doo: "Vue"
	    };
	  }
	};
	</script>

	// childCom1.vue
	<template class="border">
	  <div>
	    <p>foo: {{ foo }}</p>
	    <p>childCom1的$attrs: {{ $attrs }}</p>
	    <child-com2 v-bind="$attrs"></child-com2>
	  </div>
	</template>
	<script>
	const childCom2 = () => import("./childCom2.vue");
	export default {
	  components: {
	    childCom2
	  },
	  inheritAttrs: false, // 可以关闭自动挂载到组件根元素上的没有在 props 声明的属性
	  props: {
	    foo: String // foo 作为 props 属性绑定
	  },
	  created() {
	    console.log(this.$attrs); 
	    // { "boo": "Html", "coo": "CSS", "doo": "Vue", "title": "前端工匠" }
	  }
	};
	</script>

// childCom2.vue
	<template>
	  <div class="border">
	    <p>boo: {{ boo }}</p>
	    <p>childCom2: {{ $attrs }}</p>
	    <child-com3 v-bind="$attrs"></child-com3>
	  </div>
	</template>
	<script>
	const childCom3 = () => import("./childCom3.vue");
	export default {
	  components: {
	    childCom3
	  },
	  inheritAttrs: false,
	  props: {
	    boo: String
	  },
	  created() {
	    console.log(this.$attrs); 
	    // {"coo": "CSS", "doo": "Vue", "title": "前端工匠" }
	  }
	};
	</script>

	// childCom3.vue
	<template>
	  <div class="border">
	    <p>childCom3: {{ $attrs }}</p>
	  </div>
	</template>
	<script>
	export default {
	  props: {
	    coo: String,
	    title: String
	  }
	};
	</script>

 

如上图所示 $attrs 表示没有继承数据的对象，格式为 {属性名：属性值}。Vue2.4 提供了 $attrs , $listeners 来传递数据与事件，跨级组件之间的通讯变得更简单。

  简单来说：$attrs 与 $listeners 是两个对象，$attrs 里存放的是父组件中绑定的非 Props 属性，$listeners 里存放的是父组件中绑定的非原生事件。

方法五、provide/inject

1.简介

  Vue2.2.0 新增 API,这对选项需要一起使用，以允许一个祖先组件向其所有子孙后代注入一个依赖，不论组件层次有多深，并在起上下游关系成立的时间里始终生效。一言而蔽之：祖先组件中通过 provider 来提供变量，然后在子孙组件中通过 inject 来注入变量。
  provide / inject API 主要解决了跨级组件间的通信问题，不过它的使用场景，主要是子组件获取上级组件的状态，跨级组件间建立了一种主动提供与依赖注入的关系。

2.举个例子

  假设有两个组件： A.vue 和 B.vue，B 是 A 的子组件

// A.vue
	export default {
	  provide: {
	    name: '浪里行舟'
	  }
	}
	// B.vue
	export default {
	  inject: ['name'],
	  mounted () {
	    console.log(this.name);  // 浪里行舟
	  }
	}

可以看到，在 A.vue 里，我们设置了一个 provide: name，值为 '浪里行舟'，它的作用就是将 name 这个变量提供给它的所有子组件。而在 B.vue 中，通过 inject 注入了从 A 组件中提供的 name 变量，那么在组件 B 中，就可以直接通过 this.name 访问这个变量了，它的值也是 '浪里行舟'。这就是 provide / inject API 最核心的用法。

  需要注意的是：provide 和 inject 绑定并不是可响应的。这是刻意为之的。然而，如果你传入了一个可监听的对象，那么其对象的属性还是可响应的----vue官方文档
所以，上面 A.vue 的 name 如果改变了，B.vue 的 this.name 是不会改变的，仍然是 '浪里行舟'。

3.provide 与 inject 怎么实现数据响应式

一般来说，有两种办法：

  • provide 祖先组件的实例，然后在子孙组件中注入依赖，这样就可以在子孙组件中直接修改祖先组件的实例的属性，不过这种方法有个缺点就是这个实例上挂载很多没有必要的东西比如 props，methods 等
  • 使用 2.6 最新 API Vue.observable 优化响应式 provide (推荐)

  我们来看个例子：孙组件 D、E 和 F 获取 A 组件传递过来的 color 值，并能实现数据响应式变化，即 A 组件的 color 变化后，组件 D、E、F 会跟着变（核心代码如下：）

 

// A 组件 
	<div>
	      <h1>A 组件</h1>
	      <button @click="() => changeColor()">改变color</button>
	      <ChildrenB />
	      <ChildrenC />
	</div>
	......
	  data() {
	    return {
	      color: "blue"
	    };
	  },
	  // provide() {
	  //   return {
	  //     theme: {
	  //       color: this.color //这种方式绑定的数据并不是可响应的
	  //     } // 即A组件的color变化后，组件D、E、F不会跟着变
	  //   };
	  // },
	  provide() {
	    return {
	      theme: this//方法一：提供祖先组件的实例
	    };
	  },
	  methods: {
	    changeColor(color) {
	      if (color) {
	        this.color = color;
	      } else {
	        this.color = this.color === "blue" ? "red" : "blue";
	      }
	    }
	  }
	  // 方法二:使用2.6最新API Vue.observable 优化响应式 provide
	  // provide() {
	  //   this.theme = Vue.observable({
	  //     color: "blue"
	  //   });
	  //   return {
	  //     theme: this.theme
	  //   };
	  // },
	  // methods: {
	  //   changeColor(color) {
	  //     if (color) {
	  //       this.theme.color = color;
	  //     } else {
	  //       this.theme.color = this.theme.color === "blue" ? "red" : "blue";
	  //     }
	  //   }
	  // }

// F 组件 
	<template functional>
	  <div class="border2">
	    <h3 :style="{ color: this.theme.color }">F 组件</h3>
	  </div>
	</template>
	<script>
	export default {
	  inject: ["theme"]
	  // inject: {
	  // 	theme: {
	  // 		from: theme,
	  // 		//函数式组件取值不一样
     	  // 		default: () => ({})
	  // 	}
	  // }
	};
	</script>

虽说 provide 和 inject 主要为高阶插件/组件库提供用例，但如果你能在业务中熟练运用，可以达到事半功倍的效果！
  有关 inject 参数为对象的用法可见 provide / inject

方法六、$parent/$children 与 ref

转载自 segmentfault 浪里行舟 的文章 vue组件间通信六种方式（完整版）

  • ref：如果在普通的 DOM 元素上使用，引用指向的就是 DOM 元素；如果用在子组件上，引用就指向组件实例
  • $parent / $children：访问父 / 子实例
    需要注意的是：这两种都是直接得到组件实例，使用后可以直接调用组件的方法或访问数据。我们先来看个用 ref 来访问组件的例子：
  • 	// component-a 子组件
	export default {
	  data () {
	    return {
	      title: 'Vue.js'
	    }
	  },
	  methods: {
	    sayHello () {
	      window.alert('Hello');
	    }
	  }
	}

    	// 父组件
	<template>
	  <component-a ref="comA"></component-a>
	</template>
	<script>
	  export default {
	    mounted () {
	      const comA = this.$refs.comA;
	      console.log(comA.title);  // Vue.js
	      comA.sayHello();  // 弹窗
	    }
	  }
	</script>

     不过，这两种方法的弊端是，无法在跨级或兄弟间通信。

  • 	// parent.vue
	<component-a></component-a>
	<component-b></component-b>
	<component-b></component-b>

    我们想在 component-a 中，访问到引用它的页面中（这里就是 parent.vue）的两个 component-b 组件，那这种情况下，就得配置额外的插件或工具了，比如 Vuex 和 Bus 的解决方案。

    总结

    常见使用场景可以分为三类：

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

  • 兄弟通信：
    Bus；Vuex

  • 跨级通信：
    Bus；Vuex；provide/inject API、$attrs/$listeners

小邱程序员
关注
  • 45
    点赞
  • 踩
  • 324
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
vue之组件之间的传值
przlovecsdn的博客
08-08 452
1、父组件向子组件传值 //parent.vue &lt;template&gt; &lt;div&gt; &lt;child :send-msg-to-child="toChildMsg"&gt;&lt;/child&gt; &lt;/div&gt; &lt;/template&gt; &lt;script&gt; import child
Vue 组件传值的12种方法
qq_42753091的博客
08-15 2489
Vue 组件通信方式
vue学习笔记之组件传值
最新发布
cnzzs的博客
07-16 960
说起组件传值，首先要介绍再vue中什么是组件。组件(Component)，是vue中很强大的一个功能，可以将一些可重用的代码进行重用。所有的vue组件同时也是vue实例，可以接受使用相同的选项对象和提供相同的生命周期钩子。用一句话来概括：组件就是可以扩展的HTML元素，封装可重用的HTML代码，可以将组件看做自定义的HTM...
Vue组件间的通讯方式
qq_40063198的博客
06-27 1007
Vue组件间的通讯方式
vue组件传值的13种方式
dan_seek的博客
10-19 5万+
vue组件传值 不写这篇文章，我自己都不知道我知道的vue组件传值的方式竟然有13种之多，其实静下来想想，常用的也有五六种。 1、父组件传给子组件 在子组件里定义一个props,即props:[‘msg’]，msg可以是对象也可以是基本数据类型 如果你想定义一个默认值，即 props:{msg: {type: String, default: ‘hello world’}}, 需要注意的是这种传值是...
vue2传值方式总结 （十二种方法）
前端工程师，博文都是自己学习到的，或者开发中遇到的点，记录一下
04-23 2万+
一.父传子传递 （1）在父组件的子组件标签上绑定一个属性，挂载要传输的变量 ​ （2）在子组件中通过props来接受数据，props可以是数组也可以是对象，接受的数据可以直接使用 props: [“属性 名”] props:{属性名:数据类型} 代码示例： //父组件 父组件 //子组件 {{data}} 二.子传父传递 （1）在父组件的子组件标签上自定义一个事件，然后调用需要的方法 ​ （2）在子组件的方法中通过 this.$emit(“事件”)来
vue 组件之间相互传值的6种方法
一步一个脚印，踏实努力，向着目标前进
01-28 1万+
优点实现了数据从子组件向父组件的传递，遵循响应式设计原则。缺点只能实现相邻组件之间的通信，对于多层级嵌套组件间的通信较为复杂。如果组件间交互复杂，可能会导致大量自定义事件的使用，影响代码可读性和可维护性。
vue2.0组件之间传值、通信的多种方式(干货)
01-21
这次我们就来聊一聊vue2.0组件之间传值、通信的多种方式。 一、通过路由带参数进行传值 ①两个组件 A和B,A组件通过query把orderId传递给B组件（触发事件可以是点击事件、钩子函数等） this.$router.push({ path: '/...
vue实现组件之间传值功能示例
10-18
本篇文章将深入探讨如何在Vue中实现组件之间的传值功能，包括父子组件之间的双向通信。 首先，我们来看一下如何通过`props`实现父组件向子组件的传值。在Vue中，父组件可以通过在子组件标签上设置属性来传递数据。...
深入理解Vue 组件之间传值
10-18
本文将深入探讨Vue组件间的数据传递，包括父组件向子组件传递数据、子组件向父组件传递数据以及子组件之间的间接通信。 一、父组件向子组件传递数据 Vue中，最常用的数据传递方式是通过props（属性）。在子组件中...
vue父组件向子组件动态传值的两种方法
08-28
Vue 父组件向子组件动态传值的两种方法 在 Vue 中，父组件向子组件传值是非常常见的场景。在本文中，我们将介绍两种方法来实现父组件向子组件动态传值。 方法一：使用 Props 传值 在 Vue 中，我们可以使用 props ...
【Vue】组件传值的六种方法
weixin_42213951的博客
03-19 2205
Vue 组件之间的通信大概归类为： 父子组件通信: props/emit；ref/refs；emit；ref/refs；emit；ref/refs；attrs / listeners；listeners；listeners；parent / children兄弟组件通信:eventBus；vuex跨级通信:eventBus；Vuex；children 兄弟组件通信: eventBus；vuex 跨级通信: eventBus；Vuex；children兄弟组件通信:eventBus；vuex跨级通信:even
vue 组件之间传值
Y_Tiam的博客
04-04 100
创建一个子组件 Vue.component('组件的标签'，{ template: '模板内容' }) // 例如 定义一个子组件 Vue.component('child'，{ template: '<div></div>' }) // 定义一个父组件 将子组件在父组件中使用 Vue.component('parent'，{ template: `<div>
浅谈Vue组件之间的传值
chendu98的博客
10-26 356
一、主要方式 1、父子组件之间的传值 2、非父子组件之间的传值 二、父子组件之间的传值 1、父组件向子组件传值 第一种方式: 　props　　　 　　　　　　父组件嵌套的子组件中，使用v-bind:msg=‘xxxx’进行对象的绑定，子组件中通过定义props接收对应的msg对象 父组件代码 <template> <div> <!-- 注意 :msg 后面是一个对象，值是字符串时,需要写冒号，如果省略：就是一个字...
Vue---11种组件传值方式总结，总有一款适合你
COCOLI_BK的博客
08-08 2025
以上示例代码展示了Vue 2中不同组件间通信方法的实现方式。注意，对于Pinia和Vue 3+特有的通信方式，这里没有提供Vue 2的示例代码。
【vue】vue组件传值的三种方式
热门推荐
hello world_
10-22 6万+
前言 vue的组件传值分为三种方式：父传子、子传父、非父子组件传值 引用官网的一句话：父子组件的关系可以总结为 prop 向下传递，事件向上传递 父组件通过 prop 给子组件下发数据，子组件通过事件给父组件发送消息，如下图所示：   下面我们就开始用代码（一言不合就上代码）详细的介绍vue组件传值的三种方式 1、父传子 子组件的代码： &lt;template&gt; ...
vue组件之间的传值
起小点
05-09 335
1.vue非父子组价传值 非父子组件传值需要定义公共的实例文件sors.js,作为中间仓库来传值，要不然组件之间达不到传值效果。 公共sors.js //sors.js import vue from 'vue' export default new Vue() 组件A： <template> <div> A组件： <span>{{elementValue}}</span> <in
Vue 组件之间传值
忧郁的蛋的专栏
02-18 1万+
使用 props 和 $emit 可以实现父子组件之间的传值，使用 provide 和 inject 可以实现祖先组件向后代组件的传值，使用 Vuex 和 EventBus 可以实现任意组件之间的传值。假设我们有一个父组件和一个子组件，子组件需要接收父组件的一些属性和事件监听器，同时还需要把这些属性和事件传递给子组件的某个子元素。5、使用全局事件总线：可以使用 Vue 的事件机制，通过在 Vue 实例上使用 $on 来监听事件，然后在其他组件中使用 $emit 触发相应的事件来传递数据。
VUE 组件间传值
hey_lie的博客
07-20 870
vue中没有直接的实现方式，最原始的就是，将两个子组件合并到一个父组件中，通过父组件中转传值。父组件中自定义事件，名称为child-event，实际执行方法为parentEvent。这样是数据请求完成后才显示该组件，在该例子中显然不好，会出现空白，然后突然展示。组件A通过$ON接受组件B传递的事件componentB-event，处理消息。组件B通过$ON接受组件A传递的事件componentA-event，处理消息。父子组件传值时，如果数据是异步请求，则在请求耗时中，数据没有展示。...
vue组件传值面试题
02-29
Vue组件传值是Vue.js中非常重要的一个概念，它涉及到父子组件之间的数据传递和通信。下面是一些常见的Vue组件传值面试题及其答案： 1. 请介绍Vue组件之间的父子组件传值方式。 答：Vue组件之间的父子组件传值方式有props和$emit。通过props可以将数据从父组件传递给子组件，子组件通过props接收数据。而$emit则是在子组件中触发一个自定义事件，并通过事件参数将数据传递给父组件。 2. 请介绍Vue组件之间的兄弟组件传值方式。 答：Vue组件之间的兄弟组件传值方式可以通过共享状态管理工具（如Vuex）或者事件总线来实现。使用共享状态管理工具可以在全局定义一个状态，兄弟组件通过读取和修改该状态来进行数据传递。而事件总线则是在Vue实例上定义一个事件中心，兄弟组件通过$emit和$on来进行事件的发布和订阅，从而实现数据传递。 3. 请介绍Vue组件之间的跨级组件传值方式。 答：Vue组件之间的跨级组件传值方式可以通过provide和inject来实现。父级组件通过provide提供数据，然后子孙级组件通过inject来注入数据。这样就可以实现跨级组件之间的数据传递。 4. 请介绍Vue组件之间的非父子组件传值方式。 答：Vue组件之间的非父子组件传值方式可以通过事件总线、Vuex或者localStorage等方式来实现。事件总线和Vuex的方式在前面已经介绍过了，而localStorage则是通过将数据存储在浏览器的本地存储中，然后在其他组件中读取该数据来实现非父子组件之间的数据传递。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值