Can you force a React component to rerender without calling setState? – Dev

The best answers to the question “Can you force a React component to rerender without calling setState?” in the category Dev.


I have an external (to the component), observable object that I want to listen for changes on. When the object is updated it emits change events, and then I want to rerender the component when any change is detected.

With a top-level React.render this has been possible, but within a component it doesn’t work (which makes some sense since the render method just returns an object).

Here’s a code example:

export default class MyComponent extends React.Component {

  handleButtonClick() {

  render() {
    return (
        <button onClick={this.handleButtonClick.bind(this)}>
          Click me

Clicking the button internally calls this.render(), but that’s not what actually causes the rendering to happen (you can see this in action because the text created by {Math.random()} doesn’t change). However, if I simply call this.setState() instead of this.render(), it works fine.

So I guess my question is: do React components need to have state in order to rerender? Is there a way to force the component to update on demand without changing the state?


forceUpdate should be avoided because it deviates from a React mindset. The React docs cite an example of when forceUpdate might be used:

By default, when your component’s state or props change, your component will re-render. However, if these change implicitly (eg: data deep within an object changes without changing the object itself) or if your render() method depends on some other data, you can tell React that it needs to re-run render() by calling forceUpdate().

However, I’d like to propose the idea that even with deeply nested objects, forceUpdate is unnecessary. By using an immutable data source tracking changes becomes cheap; a change will always result in a new object so we only need to check if the reference to the object has changed. You can use the library Immutable JS to implement immutable data objects into your app.

Normally you should try to avoid all uses of forceUpdate() and only read from this.props and this.state in render(). This makes your component “pure” and your application much simpler and more efficient.forceUpdate()

Changing the key of the element you want re-rendered will work. Set the key prop on your element via state and then when you want to update set state to have a new key.

<Element key={this.state.key} /> 

Then a change occurs and you reset the key

this.setState({ key: Math.random() });

I want to note that this will replace the element that the key is changing on. An example of where this could be useful is when you have a file input field that you would like to reset after an image upload.

While the true answer to the OP’s question would be forceUpdate() I have found this solution helpful in different situations. I also want to note that if you find yourself using forceUpdate you may want to review your code and see if there is another way to do things.

NOTE 1-9-2019:

The above (changing the key) will completely replace the element. If you find yourself updating the key to make changes happen you probably have an issue somewhere else in your code. Using Math.random() in key will re-create the element with each render. I would NOT recommend updating the key like this as react uses the key to determine the best way to re-render things.


In class components, you can call this.forceUpdate() to force a rerender.


In function components, there’s no equivalent of forceUpdate, but you can contrive a way to force updates with the useState hook.


In 2021, this is the official way to forceUpdate a React Functional Component.

const [, forceUpdate] = useReducer(x => x + 1, 0);

  function handleClick() {

I know the OP is for a class component. But the question was asked in 2015 and now that hooks are available, many may search for forceUpdate in functional components. This little bit is for them.


Actually, forceUpdate() is the only correct solution as setState() might not trigger a re-render if additional logic is implemented in shouldComponentUpdate() or when it simply returns false.


Calling forceUpdate() will cause render() to be called on the component, skipping shouldComponentUpdate(). more…


setState() will always trigger a re-render unless conditional rendering logic is implemented in shouldComponentUpdate(). more…

forceUpdate() can be called from within your component by this.forceUpdate()

Hooks: How can I force component to re-render with hooks in React?

BTW: Are you mutating state or your nested properties don’t propagate?

  • How to update nested state properties in React
  • Sandbox