Using Javascript Events to share data between components

As web applications become complex everyday, the data being processed in these apps also become complex. Complex data processing requires an easy way for the data to be shared between components when building a complex web application. At featureOS , we process thousands of data points per hour to help our customers capture customer feedback from their users.

In this post, let us tell you how we use Javascript Events to share data between components with some examples of these Javascript Events.

Take an instance of an app with which has to sync preferences from child to global root, or update theme data from theme picker in a leaf component to parents.

But people could as that we can do this with frameworks like Redux or features like context so why do we need to rely on Events? The major reason is that global state are used for data that are long lived in the application like list of posts, notification list, counters. But for short lived data like configuration change or toggle actions we don’t have to bloat the global state and use events.

Setup

For the purpose of the article, I’ll be setting up a NextJS app and creating the entire setup on top of it.

As a first step we need to create an event bus that manages all the new event dispatch and subscription. So lets create events.js file and create three key functions dispatch, subscribe, unsubscribe

1
export const EventEmitter = {
2
  events: {},
3
  subscribe(event, callback) {},
4
  dispatch(event, data) {},
5
  unsubscribe(event) {}
6
}

Subscriber

The subscriber function we need to register the provided event handler with the corresponding event. So we need to check if the event is already registered and push the new handler to the list of registered events.

1
subscribe(event, callback) {
2
  if (!this.events[event]) this.events[event] = []
3
  this.events[event].push(callback)
4
},

Dispatcher

In the dispatch function we need to call all the handlers registered for the given event when the dispatch is called in the application.

1
  dispatch(event, data) {
2
    if (!this.events[event]) return
3
    this.events[event].forEach((callback) => callback(data))
4
  },

Unsubscriber

Finally in the unsubscribe function we need to remove the handlers when the application calls it so that the events are not emitted anymore for those events

1
unsubscribe(event) {
2
  if (!this.events[event]) return
3
  delete this.events[event]
4
}

Now lets put it all together and see how it can be used in our application

1
export const EventEmitter = {
2
  events: {},
3
  subscribe(event, callback) {
4
    if (!this.events[event]) this.events[event] = []
5
    this.events[event].push(callback)
6
  },
7
  dispatch(event, data) {
8
    if (!this.events[event]) return
9
    this.events[event].forEach(callback => callback(data))
10
  },
11
  unsubscribe(event) {
12
    if (!this.events[event]) return
13
    delete this.events[event]
14
  }
15
}

Using Javascript Events in application

We’ll create a simple counter application which will be trigger with help of events. Lets name the events for this case as incrementCounter and decrementCounter

1
import { useState, useEffect } from 'react'
2
import { EventEmitter } from '../lib/events'
3
import styles from '../styles/Home.module.css'
4

5
export default function Home() {
6
  const [counter, setCounter] = useState(0)
7

8
  useEffect(() => {
9
    EventEmitter.subscribe('incrementCounter', value =>
10
      setCounter(counter => counter + value)
11
    )
12
    EventEmitter.subscribe('decrementCounter', value =>
13
      setCounter(counter => counter - value)
14
    )
15
    return () => {
16
      EventEmitter.unsubscribe('incrementCounter')
17
      EventEmitter.unsubscribe('decrementCounter')
18
    }
19
  }, [])
20

21
  return (
22
    <div className={styles.container}>
23
      <h1>Current Value: {counter}</h1>
24
    </div>
25
  )
26
}

Since we want to try events for sharing data between two different components of different level, let’s create a child component and add the increment and decrement buttons there

1
import React from 'react'
2
import { EventEmitter } from '../lib/events'
3

4
export default function CounterButton({ label, type }) {
5
  const handleClick = () => {
6
    if (type === 'increment') {
7
      EventEmitter.dispatch('incrementCounter', 1)
8
    } else if (type === 'decrement') {
9
      EventEmitter.dispatch('decrementCounter', 1)
10
    }
11
  }
12
  return <button onClick={handleClick}>{label}</button>
13
}

Now lets import and use it in our main index.js file and see the final result.

1
import { useState, useEffect } from 'react'
2
import CounterButton from '../Components/CounterButton'
3
import { EventEmitter } from '../lib/events'
4
import styles from '../styles/Home.module.css'
5

6
export default function Home() {
7
  const [counter, setCounter] = useState(0)
8

9
  useEffect(() => {
10
    EventEmitter.subscribe('incrementCounter', value =>
11
      setCounter(counter => counter + value)
12
    )
13
    EventEmitter.subscribe('decrementCounter', value =>
14
      setCounter(counter => counter - value)
15
    )
16
    return () => {
17
      EventEmitter.unsubscribe('incrementCounter')
18
      EventEmitter.unsubscribe('decrementCounter')
19
    }
20
  }, [])
21

22
  return (
23
    <div className={styles.container}>
24
      <h1>Current Value: {counter}</h1>
25
      <CounterButton label='Increment' type='increment' />
26
      <CounterButton label='Decrement' type='decrement' />
27
    </div>
28
  )
29
}

So with all setup, when we click on the increment or decrement button the counter value changes and if you noticed we didn’t pass any props or have any global state to achieve this. Also with this mechanism it will be easier to create multiple events for minor data changes between different components of the application

The code of this demo can be found here -> Codesandbox