Monitor react errors and resolve them faster with advanced devtools. Try Zipy!
Start free trial
With React devtools extension, developers can easily inspect and manipulate the state and props of components, analyze component hierarchies, and track component updates in real-time. In this blog, we will go through the features of React devtools extension, steps to set it up, and share how can you use it with examples.
Let’s get started.
React devtools is a browser extension meant to assist developers in debugging and optimizing React applications. It shows developers a visual depiction of the component hierarchy, properties, and state of each component in the application.
With this extension, developers can inspect and manipulate the components and their state in real-time. They can also identify performance issues in the application with its built-in profiler.
Due to its ability to enhance the development process, React Developer Tools seamlessly integrates with React ecosystem providing developers invaluable benefits.
Now that you have understood the benefits of using React Developer Tools, it’s a good time we explore some features.
Here’s how you can install and use React Developer Tools extension to your Chrome browser:
That's it! React Developer Tools is now installed and ready to use in Chrome. Use the method to use this extension in other browsers as well.
In React Developer Tools, the profiler and component serve different purposes when it comes to analyzing and understanding your React application. Let’s cover them one by one:
The Components feature offers a graphical view of your application's component hierarchy. It enables you to examine and troubleshoot individual components' state, props, and hooks.
By navigating to the Components tab, you gain access to a tree view presenting all rendered components in your application. When you select a particular component, you can explore its existing props, state, and context values, facilitating the process of debugging and comprehending the flow of data within your components.
For example, here is an image which showcases the component tree of a React app. You can explore the nested components and check if any error is popping off.
Furthermore, the Components tab provides visualization and inspection capabilities for a component's lifecycle, hooks, and the associated virtual DOM structure. This comprehensive view assists in understanding the inner workings and relationships of your components.
This extension helps is measuring and analyzing the performance of your React components. You can identify all the rendering bottlenecks and optimize it for better performance.
When using the Profiler, you can wrap specific parts of your component tree with the <Profiler> component from React. It allows you to measure the rendering time and interactions within that portion of the tree. Check out this image for a visual representation of how the Profiler works and provides performance insights.
With the Profiler, you can gain insights into how components are rendering, identify components that are causing performance issues, and optimize your application's rendering performance accordingly.
Here's a table summarizing the capabilities of React devtools Profiler and Components, along with their common use cases:
To summarize - once you have used the Components feature in devtools to inspect components in your React app and identify their properties, state, data flow, and interactions, you can move to the Profiler feature. With Profiler you can measure and analyze the rendering performance of these components.
In this section, let’s cover how to use React Developer Tools to inspect your React app and debug components and performance. We will use relevant examples that you can follow for your app as well.
We will share how you can inspect and debug performance with profiler. We will refer to this e-commerce website - https://buy-2-wear.netlify.app/ to share the steps.
To get started, you can press “Ctrl + shift + I” to go to the inspect window. From there you can monitor React Developer Tools easily.
For inspecting with React DevTools, you can then navigate to the panel shown below to see the component tree and view the props and state of the selected element.
When you open the “Component” tab it will show you a hierarchy tree for your React components. It also allows you to inspect the rendered DOM elements while hovering over the components.
Now, if we move further in the hierarchical tree view of our App component, you will find the child component called Routes. You can expand the Routes component to see the other component nested inside it. By clicking on the Route.Provider component, you can see its props and state in the panel to the right.
Performance debugging is an iterative process, and it's crucial to profile and test your application after each change to ensure you're moving in the right direction.
With the help of "Profiler" tab in this extension, you can measure and analyze the performance of your components. Start profiling by clicking on the "Record" button and interact with your application to capture performance data.
Now, analyze the recorded data, including component render times and call stack, to identify performance bottlenecks. Here’s a profiler tab to locate the renders, re-renders and updates over time.
In the above image, you can clearly examine the structure of the component tree and see how they are nested and composed with each other. For example, App → LocationProvider → NavigationProvider → Router and so on. It shows the render duration and commit timings in the commit information tab on the right side of the screen. The priorities of the components are also listed there.
Additionally, you get a Flamegraph for a visual representation of the call stack and timing information for different components. Using “Profiler” is a good option to identify areas where unnecessary re-renders are occurring or rendering can be optimized.
Now, it’s time to understand how debugging is done with React devtools. Let’s take an example of a simple React component which is not rendering properly. In this component the counter variable is incrementing by 1, every time when the setCounter function is called.
Here, the Count component is used for rendering a button and counting value which gets incremented when the button is clicked. However, when you run the application you will notice that the count value isn't updating properly after you click the button.
Now, open React devtools in your browser and select the “React” tab to debug this issue. From there, you can find the Count component in the component tree and inspect its props and state. If the state of the Count component isn't updating correctly when the button is clicked then you can modify the state of the component
For example, you could include a breakpoint in the click method and halt code execution when the breakpoint is reached. From there, you can use the console to log additional information, or modify the state of the component to see if that resolves the issue.
We've included a debugger statement in this example to pause code execution and observe the state of the component when the click function is called.
There are multiple ways to debug issues with React Developer Tools. Here are some:
Although React Developer Tools is the most common tool for debugging and profiling React apps, there are other devtools as well that support in React development. These devtools offer additional functionalities for debugging and optimizing your React apps. Here, are some tools worth knowing:
There are more such React tools for developers out there, that you can explore to simplify React development, testing, and debugging.
React developer tools compatibility with your favorite browsers and straight forward interface, no doubt makes it so popular. And I believe, by now you must have gained a comprehensive understanding about this extension, and how you can use it for debugging and profiling your React applications. So do give it a shot.
In this blog we have also mentioned some other tools that use for your React app, but this list is long and it won’t hurt to know about them. So before you get busy with coding, check out our blog on popular React devtools.