Async Nature Of setState()

On the Async nature of setState()

Gist:

React batches updates and flushes it put once per frame (perf optimization)
However, in some cases React has no control over batching, hence updates are made synchronously
eg. eventListeners, Ajax, setTimeout and similar Web APIs

Main Idea

setState() does not immediately mutate this.state but creates a pending state transition.
Accessing this.state after calling this method can potentially return the existing value.
There is no guarantee of synchronous operation of calls to setState and calls may be batched for performance gains.

Run the below code and you will make the following observations:

You can see that in every situation (addEventListener, setTimeout or AJAX call) the state before and the state after are different.
And that render was called immediately after triggering the setState method. But why is that?
Well, it turns out React does not understand and thus cannot control code that doesn’t live inside the library.
Timeouts or AJAX calls for example, are developer authored code that executes outside of the context of React.

So why does React synchronously update the state in these cases? Well, because it’s trying to be as defensive as possible.
Not being in control means it’s not able to do any performance optimisations so it’s better to update the state on spot and
make sure the code that follows has access to the latest information available.

  1. class TestComponent extends React.Component {
  2.   constructor(...args) {
  3.     super(...args);
  4.     this.state = {
  5.       dollars: 10
  6.     };
  7.     this._saveButtonRef = (btn => { this._btnRef = btn });
  8.     [
  9.       '_onTimeoutHandler',
  10.       '_onMouseLeaveHandler',
  11.       '_onClickHandler',
  12.       '_onAjaxCallback',
  13.     ].forEach(propToBind => {
  14.       this[propToBind] = this[propToBind].bind(this);
  15.     });
  16.   }
  18.   componentDidMount() {
  19.     // Add custom event via `addEventListener`
  20.     //
  21.     // The list of supported React events does include `mouseleave`
  22.     // via `onMouseLeave` prop
  23.     //
  24.     // However, we are not adding the event the `React way` - this will have
  25.     // effects on how state mutates
  26.     //
  27.     // Check the list here - https://facebook.github.io/react/docs/events.html
  28.     this._btnRef.addEventListener('mouseleave', this._onMouseLeaveHandler);
  30.     // Add JS timeout
  31.     //
  32.     // Again,outside React `world` - this will also have effects on how state
  33.     // mutates
  34.     setTimeout(this._onTimeoutHandler, 10000);
  36.     // Make AJAX request
  37.     fetch('https://api.github.com/users')
  38.       .then(this._onAjaxCallback);
  39.   }
  41.   render() {
  42.     console.log('State in render: ' + JSON.stringify(this.state));
  44.     return (
  45.        <button
  46.          ref={this._saveButtonRef}
  47.          onClick={this._onClickHandler}>
  48.          'Click me'
  49.       </button>
  50.     );
  51.   }
  53.   _onClickHandler() {
  54.     console.log('State before (_onClickHandler): ' + JSON.stringify(this.state));
  55.     this.setState({
  56.       dollars: this.state.dollars + 10
  57.     });
  58.     console.log('State after (_onClickHandler): ' + JSON.stringify(this.state));
  59.   }
  61.   _onMouseLeaveHandler() {
  62.     console.log('State before (mouseleave): ' + JSON.stringify(this.state));
  63.     this.setState({
  64.       dollars: this.state.dollars + 20
  65.     });
  66.     console.log('State after (mouseleave): ' + JSON.stringify(this.state));
  67.   }
  69.   _onTimeoutHandler() {
  70.     console.log('State before (timeout): ' + JSON.stringify(this.state));
  71.     this.setState({
  72.       dollars: this.state.dollars + 30
  73.     });
  74.     console.log('State after (timeout): ' + JSON.stringify(this.state));
  75.   }
  77.   _onAjaxCallback(response) {
  78.     if (response.status !== 200) {
  79.       console.log('Error in AJAX call: ' + response.statusText);
  80.       return;
  81.     }
  82.     console.log('State before (AJAX call): ' + JSON.stringify(this.state));
  83.     this.setState({
  84.       dollars: this.state.dollars + 40
  85.     });
  86.     console.log('State after (AJAX call): ' + JSON.stringify(this.state));
  87.   }
  88. };
  90. // Render to DOM
  91. ReactDOM.render(
  92.   <TestComponent />,
  93.   document.getElementById('app')
  94. );

Possible solution?

We’re used to calling setState with one parameter only, but actually, the method’s signature support two.
The second argument that you can pass in is a callback function that will always be executed after the state has been updated (whether it’s inside React’s known context or outside of it).

An example might be:

  1. _onClickHandler: function _onClickHandler() {
  2.    console.log('State before (_onClickHandler): ' + JSON.stringify(this.state));
  3.    this.setState({
  4.    dollars: this.state.dollars + 10
  5.    }, () => {
  6.    console.log('Here state will always be updated to latest version!');
  7.    console.log('State after (_onClickHandler): ' + JSON.stringify(this.state));
  8.    });
  9. }

A note on the async nature of setstate

To be politically correct, setState, as a method, is always synchronous.
It’s just a function that calls something behind the scenes - enqueueState or enqueueCallback on updater.

In fact, here’s setState taken directly from React source code:

  1. ReactComponent.prototype.setState = function(partialState, callback) {
  2.   invariant(
  3.     typeof partialState === 'object' ||
  4.     typeof partialState === 'function' ||
  5.     partialState == null,
  6.     'setState(...): takes an object of state variables to update or a ' +
  7.     'function which returns an object of state variables.'
  8.   );
  9.   this.updater.enqueueSetState(this, partialState);
  10.   if (callback) {
  11.     this.updater.enqueueCallback(this, callback, 'setState');
  12.   }
  13. };

What’s actually sync or async are the effects of calling setState in a React application - the reconciliation algorithm, doing the VDOM comparisons and calling render to update the real DOM.

Related links: