Strict Mode in React


StrictMode is a Reply Inventor Tool for highlighting potential problems in an application. It is primarily used for pressing possible problems in a web application. It activates fresh deprecation checks and warnings for its child factors. One of the reasons for its fashionability is the fact that it provides visual feedback such as warning and error dispatches whenever the React guidelines and recommended practices aren’t followed. Just like the React Fragment, the React StrictMode Component doesn’t render any visible UI.

In this article, we are going to discuss the Strict Mode in React in depth.


The React StrictMode may be viewed as a helper element. It enables inventors to decode efficiently and brings to their attention any suspicious law that might have been accidentally included in the operation. The StrictMode may be implemented to any section of the operation, not inescapably to the whole operation. It’s especially helpful to use while developing new canons or remedying the operation.

We can allow a strict mode for any part of our application. For instance:

import React from 'react';

function ExampleApplication() {
  return (
      <Header />
      <React.StrictMode>        <div>
          <ComponentOne />
          <ComponentTwo />
      </React.StrictMode>      <Footer />

In this example, strict mode checks would not be run against the Header and Footer components. Though, ComponentOne and ComponentTwo, as well as all of their descendants, will have the checks.

StrictMode  now supports with:

  • Identifying components with unsafe lifecycles
  • Warning about legacy string ref API usage
  • Warning about deprecated findDOMNode usage
  • Detecting unexpected side effects
  • Detecting legacy context API

Extra functionality would be included with future releases of React.


The React StrictMode help us to recognize and detect many warnings and errors during the development phase, such as;

Supports to find those components having unsafe lifecycles:

Few of the legacy components, lifecycle methods are determined to be unsafe to use in async applications. The React StrictMode supports finding the use of such unsafe methods. Once allowed, it shows a list of all components using unsafe lifecycle methods as warning messages.

Alerts about the use of the legacy string ref API:

At the start-up, there were two methods to manage refs- legacy string ref API and the callback API. After that, a third alternate method, the create API was included that replaces the string refs with object refs, which enabled the StrictMode to provide warning messages whenever string refs are used.

Alerts about the use of the deprecated findDOMNode:

As the findDOMNode is only a one-time read API, it is impossible to control changes when a child component attempts to render a different node. These issues were found by the React StrictMode and showed as warning messages.

Recognizing unsafe lifecycles

As we know that certain legacy lifecycle methods are unsafe for use in async React applications. Therefore, it may be complex to make sure that these lifecycles aren’t being used if our application uses third-party libraries. Luckily, the strict mode may support this. React compiles a list of all class components using the unsafe lifecycles when strict mode is enabled. And logs a warning message with information about these components, like this:

Strict mode in react

Alerts about legacy string ref API usage

Earlier, React has given two ways for managing refs:

  • the legacy string ref API and
  • the callback API.

React 16.3 added a third option, which delivers the convenience of a string ref without any of the downsides:

class MyComponent extends React.Component {
  constructor(props) {

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }

Alerts about the use of deprecated findDOMNode

React used to help findDOMNode to search the tree for a DOM node provided a class example. Usually, we don’t require this as we can attach a ref directly to a DOM node.

findDOMNode may similarly be used on class components. This was breaking abstraction levels by enabling a parent to demand that certain children were rendered. It generates a refactoring hazard where we can’t alter the application details of a component as a parent might be reaching into its DOM node. findDOMNode only returns back the first child. Through, the use of Fragments, it is convenient for a component to render various DOM nodes. findDOMNode is a one-time read API. It only provided us a reply when we asked for it. There is no other way to control this change if a child component renders a different node. Therefore, only worked if components remained to return a single DOM node that never alters.

We may instead make this explicit by passing a ref to our custom component and passing that along to the DOM using ref forwarding. We can also include a wrapper DOM node in our component and attach a ref directly to it.

class MyComponent extends React.Component {
  constructor(props) {
    this.wrapper = React.createRef();  }
  render() {
    return <div ref={this.wrapper}>{this.props.children}</div>;  }