В Vue.js 2.x model.sync будет устаревшим.

Итак, каков правильный способ взаимодействия между родственными компонентами в Vue.js 2.x?


As I understand Vue.js 2.x, the preferred method for sibling communication is to use a store or an event bus.

According to Evan (creator of Vue.js):

It's also worth mentioning "passing data between components" is generally a bad idea, because in the end the data flow becomes untrackable and very hard to debug.

If a piece of data needs to be shared by multiple components, prefer global stores or Vuex.

[Link to discussion]


.once and .sync are deprecated. Props are now always one-way down. To produce side effects in the parent scope, a component needs to explicitly emit an event instead of relying on implicit binding.

So, Evan suggests using $emit() and $on().


What worries me is:

  • Each store and event has a global visibility (correct me if I'm wrong);
  • It's too wasteful to create a new store for each minor communication;

What I want is to some scope events or stores visibility for siblings components. (Or perhaps I didn't understand the above idea.)


So, what is the correct way to communicate between sibling components?

Ответы (7)

With Vue.js 2.0, I'm using the eventHub mechanism as demonstrated in the documentation.

  1. Define centralized event hub.

     const eventHub = new Vue() // Single event hub
     // Distribute to components using global mixin
         data: function () {
             return {
                 eventHub: eventHub
  2. Now in your component you can emit events with

     this.eventHub.$emit('update', data)
  3. And to listen you do

     this.eventHub.$on('update', data => {
     // do your thing


Please see the answer by alex, which describes a simpler solution.

What I usually do if I want to "hack" the normal patterns of communication in Vue.js, specially now that .sync is deprecated, is to create a simple EventEmitter that handles communication between components. From one of my latest projects:

import {EventEmitter} from 'events'

var Transmitter = Object.assign({}, EventEmitter.prototype, { /* ... */ })

With this Transmitter object you can then do, in any component:

import Transmitter from './Transmitter'

var ComponentOne = Vue.extend({
  methods: {
    transmit: Transmitter.emit('update')

And to create a "receiving" component:

import Transmitter from './Transmitter'

var ComponentTwo = Vue.extend({
  ready: function () {
    Transmitter.on('update', this.doThingOnUpdate)

Again, this is for really specific uses. Don't base your whole application on this pattern, use something like Vuex instead.

Okay, we can communicate between siblings via the parent using v-on events.

 |- List of items // Sibling 1 - "List"
 |- Details of selected item // Sibling 2 - "Details"

Let's assume that we want update Details component when we click some element in List.

In Parent:




  • v-on:select-item it's an event, that will be called in List component (see below);
  • setSelectedItem it's a Parent's method to update selectedModel;


data () {
  return {
    listModel: ['a', 'b']
    selectedModel: null
methods: {
  setSelectedItem (item) {
    this.selectedModel = item // Here we change the Detail's model

In List:



data () {
  return {
    selected: null
props: {
  list: {
    type: Array,
    required: true
methods: {
  select (item) {
    this.selected = item
    this.$emit('select-item', item) // Here we call the event we waiting for in "Parent"


  • this.$emit('select-item', item) will send an item via select-item directly in the parent. And the parent will send it to the Details view.

State scopes

When designing a Vue application (or in fact, any component based application), there are different types of data that depend on which concerns we're dealing with and each has its own preferred communication channels.

  • Global state: may include the logged in user, the current theme, etc.

  • Local state: form attributes, disabled button state, etc.

Note that part of the global state might end up in the local state at some point, and it could be passed down to child components as any other local state would, either in full or diluted to match the use-case.

Communication channels

A channel is a loose term I'll be using to refer to concrete implementations to exchange data around a Vue app.

Each implementation addresses a specific communication channel, which includes:

  • Global state
  • Parent-child
  • Child-parent
  • Siblings

Different concerns relate to different communication channels.

Props: Direct Parent-Child

The simplest communication channel in Vue for one-way data binding.

Events: Direct Child-Parent

$emit and $on. The simplest communication channel for direct Child-Parent communication. Events enable 2-way data binding.

Provide/Inject: Global or distant local state

Added in Vue 2.2+, and really similar to React's context API, this could be used as a viable replacement to an event bus.

At any point within the components tree could a component provide some data, which any child down the line could access through the inject component's property.

app.component('todo-list', {
  // ...
  provide() {
    return {
      todoLength: Vue.computed(() => this.todos.length)

app.component('todo-list-statistics', {
  inject: ['todoLength'],
  created() {
    console.log(`Injected property: ${this.todoLength.value}`) // > Injected property: 5

This could be used to provide global state at the root of the app, or localized state within a subset of the tree.

Centralized store (Global state)

Vuex is a state management pattern + library for Vue.js applications. It serves as a centralized store for all the components in an application, with rules ensuring that the state can only be mutated in a predictable fashion.

And now you ask:

[S]hould I create vuex store for each minor communication?

It really shines when dealing with global state, which includes but is not limited to:

  • data received from a backend,
  • global UI state like a theme,
  • any data persistence layer, e.g. saving to a backend or interfacing with local storage,
  • toast messages or notifications,
  • etc.

So your components can really focus on the things they're meant to be, managing user interfaces, while the global store can manage/use general business logic and offer a clear API through getters and actions.

It doesn't mean that you can't use it for component logic, but I would personally scope that logic to a namespaced Vuex module with only the necessary global UI state.

To avoid dealing with a big mess of everything in a global state, see the Application structure recommandations.

Refs and methods: Edge cases

Despite the existence of props and events, sometimes you might still need to directly access a child component in JavaScript.

It is only meant as an escape hatch for direct child manipulation - you should avoid accessing $refs from within templates or computed properties.

If you find yourself using refs and child methods quite often, it's probably time to lift the state up or consider the other ways described here or in the other answers.

$parent: Edge cases

Similar to $root, the $parent property can be used to access the parent instance from a child. This can be tempting to reach for as a lazy alternative to passing data with a prop.

In most cases, reaching into the parent makes your application more difficult to debug and understand, especially if you mutate data in the parent. When looking at that component later, it will be very difficult to figure out where that mutation came from.

You could in fact navigate the whole tree structure using $parent, $ref or $root, but it would be akin to having everything global and likely become unmaintainable spaghetti.

Event bus: Global/distant local state

See @AlexMA's answer for up-to-date information about the event bus pattern.

This was the pattern in the past to pass props all over the place from far up down to deeply nested children components, with almost no other components needing these in between. Use sparingly for carefully selected data.

Be careful: Subsequent creation of components that are binding themselves to the event bus will be bound more than once--leading to multiple handlers triggered and leaks. I personally never felt the need for an event bus in all the single page apps I've designed in the past.

The following demonstrates how a simple mistake leads to a leak where the Item component still triggers even if removed from the DOM.

// A component that binds to a custom 'update' event.
var Item = {
  template: `
  • {{text}}
  • `, props: { text: Number }, mounted() { this.$root.$on('update', () => { console.log(this.text, 'is still alive'); }); }, }; // Component that emits events var List = new Vue({ el: '#app', components: { Item }, data: { items: [1, 2, 3, 4] }, updated() { this.$root.$emit('update'); }, methods: { onRemove() { console.log('slice'); this.items = this.items.slice(0, -1); } } });

    Remember to remove listeners in the destroyed lifecycle hook.

    Component types

    Disclaimer: the following "containers" versus "presentational" components is just one way to structure a project and there are now multiple alternatives, like the new Composition API that could effectively replace the "app specific containers" I'm describing below.

    To orchestrates all these communications, to ease re-usability and testing, we could think of components as two different types.

    • App specific containers
    • Generic/presentational components

    Again, it doesn't mean that a generic component should be reused or that an app specific container can't be reused, but they have different responsibilities.

    App specific containers

    Note: see the new Composition API as an alternative to these containers.

    These are just simple Vue component that wraps other Vue components (generic or other app specific containers). This is where the Vuex store communication should happen and this container should communicate through other simpler means like props and event listeners.

    These containers could even have no native DOM elements at all and let the generic components deal with the templating and user interactions.

    scope somehow events or stores visibility for siblings components

    This is where the scoping happens. Most components don't know about the store and this component should (mostly) use one namespaced store module with a limited set of getters and actions applied with the provided Vuex binding helpers.

    Generic/presentational components

    These should receive their data from props, make changes on their own local data, and emit simple events. Most of the time, they should not know a Vuex store exists at all.

    They could also be called containers as their sole responsibility could be to dispatch to other UI components.

    Sibling communication

    So, after all this, how should we communicate between two sibling components?

    It's easier to understand with an example: say we have an input box and its data should be shared across the app (siblings at different places in the tree) and persisted with a backend.

    ❌ Mixing concerns

    Starting with the worst case scenario, our component would mix presentation and business logic.

    // MyInput.vue

    While it might look fine for a simple app, it comes with a lot of drawbacks:

    • Explicitly uses the global axios instance
    • Hard-coded API inside the UI
    • Tightly coupled to the root component (event bus pattern)
    • Harder to do unit tests

    ✅ Separation of concerns

    To separate these two concerns, we should wrap our component in an app specific container and keep the presentation logic into our generic input component.

    With the following pattern, we can:

    • Easily test each concern with unit tests
    • Change the API without impacting components at all
    • Configure HTTP communications however you'd like (axios, fetch, adding middlewares, tests, etc)
    • Reuse the input component anywhere (reduced coupling)
    • React to state changes from anywhere in the app through the global store bindings
    • etc.

    Our input component is now reusable and doesn't know about the backend nor the siblings.

    // MyInput.vue
    // the template is the same as above

    Our app specific container can now be the bridge between the business logic and the presentation communication.

    // MyAppCard.vue

    Since the Vuex store actions deal with the backend communication, our container here doesn't need to know about axios and the backend.

    You can even make it shorter and use the root Vue instance as the global Event Hub:

    Component 1:

    this.$root.$emit('eventing', data);

    Component 2:

    mounted() {
        this.$root.$on('eventing', data => {

    How to handle communication between siblings depends on the situation. But first I want to emphasize that the global event bus approach is going away in Vue.js 3. See this RFC. Hence this answer.

    Lowest Common Ancestor Pattern (or “LCA”)

    For most cases, I recommend using the lowest common ancestor pattern (also known as “data down, events up”). This pattern is easy to read, implement, test, and debug. It also creates an elegant, simple data flow.

    In essence, this means if two components need to communicate, put their shared state in the closest component that both share as an ancestor. Pass data from parent component to child component via props, and pass information from child to parent by emitting an event (example code below).

    For example, one might have an email app: the address component needs to communicate data to the message body component (perhaps for pre-populating "Hello "), so they use their closest shared ancestor (perhaps an email form component) to hold the addressee data.

    LCA can be annoying if events and props need to pass through many "middlemen" components.

    For more detail, I refer colleagues to this excellent blog post. (Ignore the fact that its examples use Ember, its concepts are applicable to many frameworks).

    Data Container Pattern (e.g., Vuex)

    For complex cases or situations where parent–child communication would involve too many middlemen, use Vuex or an equivalent data container technology.

    Use namespaced modules when a single store becomes too complicated or disorganized. For example, it might be reasonable to create a separate namespace for a complex collection of components with many interconnections, such as a complex calendar.

    Publish/Subscribe (Event Bus) Pattern

    If the event bus (i.e. publish/subscribe) pattern makes more sense for your app (from an architecture standpoint), or you need to remove Vue.js's global event bus from an existing Vue.js app, the Vue.js core team now recommends using a third party library such as mitt. (See the RFC referenced in paragraph 1.).


    Here's a small (perhaps overly simplistic) example of an LCA solution for sibling-to-sibling communication. This is a game called whack-a-mole.

    In this game the player gets points when they "whack" a mole, which causes it to hide and then another mole appears in a random spot. To build this app, which contains "mole" components, one might think , “mole component N should tell mole component Y to appear after it is whacked”. But Vue.js discourages this method of component communication, since Vue.js apps (and html) are effectively tree data structures.

    This is probably a good thing. A large/complex app, where nodes communicated to each-other without any centralized manager, might be very difficult to debug. Additionally, components that use LCA tend to exhibit low coupling and high reusability.

    In this example, the game manager component passes mole visibility as a prop to mole child components. When a visible mole is "whacked" (clicked), it emits an event. The game manager component (the common ancenstor) receives the event and modifies its state. Vue.js automatically updates the props, so all of the mole components receive new visibility data.

    Vue.component('whack-a-mole', {
      data() {
        return {
          stateOfMoles: [true, false, false],
          points: 0
      template: `
    WHACK - A - MOLE!

    Score: {{points}}

    `, methods: { moleClicked(n) { if(this.stateOfMoles[n]) { this.points++; this.stateOfMoles[n] = false; this.stateOfMoles[Math.floor(Math.random() * 3)] = true; } } } }) Vue.component('a-mole', { props: ['hasMole'], template: `` }) var app = new Vue({ el: '#app', data() { return { name: 'Vue' } } })
    .mole-button {
      font-size: 2em;

    In my case i have a table with editable cells. I only want one cell to be editable at a time as the user clicks from one to another to edit the contents. The solution is to use parent-child (props) and child-parent (event). In the example below i'm looping over a dataset of 'rows' and using the rowIndex and cellIndex to create a unique (coordinate) identifier for each cell. When a cell is clicked an event is fired from the child element up to the parent telling the parent which coordinate has been clicked. The parent then sets the selectedCoord and passes this back down to the child components. So each child component knows its own coordinate and the selected coordinate. It can then decide whether to make itself editable or not.


    2022 WebDevInsider