Understanding React and JavaScript Closures: The Ticker Issue

A deep dive into the relationship between React props and closures, illustrating how to manage changing props effectively in functional components.
---

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: React and JS closure issue

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding React and JavaScript Closures: The Ticker Issue

When working with React, you may encounter challenges involving closures and state management. In this guide, we will explore a common problem that arises during the use of JavaScript closures in React functional components, particularly when dealing with changing values in a prop.

Background of the Problem

Imagine you have a simple Ticker class that holds a callback function. This class executes the callback approximately every second using setInterval. Here's a simplified version of the code:

[[See Video to Reveal this Text or Code Snippet]]

You may also have a functional component in another file that utilizes the Ticker class to register a listener. Here’s a snippet of that component:

[[See Video to Reveal this Text or Code Snippet]]

The Problem

Initially, when the TimerDuration component renders, both the displayed changingValue and the value inside executeCallbackInterval are in sync. However, when changingValue gets updated, the updated value is not reflected inside executeCallbackInterval, although it is correctly displayed on the screen.

Solution to the Problem

To tackle this issue, the solution is to update the callback of the Ticker whenever changingValue changes. This means you want to unsubscribe and then subscribe again when changingValue updates. Here's the revised code:

[[See Video to Reveal this Text or Code Snippet]]

Why This Works

It's essential to understand why this adjustment works. Without including changingValue in the dependency array of useEffect, the runEachSecond function remains stale, holding a reference to the initial value of changingValue.

What Happens Without the Dependency?

The component mounts.

runEachSecond (Instance # 1) is created and subscribes to Ticker.

When changingValue updates, runEachSecond is created again (Instance # 2).

However, Ticker continues to reference runEachSecond (Instance # 1) which does not reflect the recent change in changingValue.

What Changes With the Dependency?

The component mounts.

runEachSecond (Instance # 1) is created and subscribes to Ticker.

When changingValue updates, a new runEachSecond (Instance # 2) is created.

The Ticker unsubscribes from runEachSecond (Instance # 1) and subscribes to the new runEachSecond (Instance # 2).

By managing subscriptions properly, the Ticker can always execute the latest version of the runEachSecond function with the current changingValue, resolving the initial issue.

Conclusion

Understanding how closures operate in combination with React's state management is crucial for eliminating stale values in your callback functions. By ensuring that your subscriptions respond promptly to prop changes, you can create more robust and efficient React applications.

Next time you face similar issues, remember the significance of maintaining up-to-date references in your intervals or time loops.