5 Pro-Level React Do’s & Don’ts

Hey, I’m Jack Harrington, a React developer with seven years of experience, and I’ve got some great tips for you on how to take your React coding skills to a pro level. In this video, brought to you by Traversy Media, we’ll cover five essential do’s and don’ts in React development. Trust me, these tips will help you become a better React developer and JavaScript engineer in general. We’ll cover everything from using functional components and React hooks, to the importance of TypeScript and optimizing rendering performance. Plus, I’ll share my insights on when to use custom hooks and state management libraries like React Query or SWR. And here’s a friendly reminder: no need to worry about building your own UI library when React already has excellent ones like Material UI, Bootstrap, AntD, Chakra, and Mantine. So let’s dive right in and level up your React skills together. Believe me, it’s going to be worth it!

Table of Contents

Utilize Functional Components

Understanding functional components

Functional components in React are JavaScript functions that render UI based on the input props they receive. They are the recommended approach for building UI in React, as they offer several advantages over class components. Functional components bring simplicity, reusability, and improved state management to React development.

Why functional components are better than class components

Functional components are considered the future of React for a few reasons. Firstly, they provide a better state management mechanism through the use of hooks. Hooks like useState and useEffect allow developers to manage state and lifecycles in a more intuitive and flexible way. Hooks have become the standard practice in React development and have fostered the growth of a robust ecosystem of hooks.

Secondly, functional components address the limitations of class components. Class components tend to be more complex and verbose, leading to harder-to-read code. They also encourage excessive nesting and tight coupling between components, making it difficult to achieve code reusability. Functional components, on the other hand, promote a more declarative and modular approach to UI development, making code cleaner and more maintainable.

How to use hooks for better state management with functional components

Hooks are a powerful feature of functional components that enable better state management. The useState hook allows you to declare and update state variables within a functional component. By calling useState with an initial value, you can create a state variable and a setter function for that variable. This allows you to manage and update the state of your component as needed.

The useEffect hook is another useful tool that allows you to perform side effects in your components. Side effects can include fetching data, subscribing to events, or manually updating the DOM. By using useEffect, you can handle these side effects without breaking the declarative nature of React. useEffect takes a function as an argument and executes it after the component has rendered.

Hooks like useCallback and useMemo are also essential for optimizing performance in functional components. useCallback allows you to memoize functions so that they are only recreated when their dependencies change. This can prevent unnecessary re-renders of child components. useMemo, on the other hand, allows you to memoize the value of a variable so that it is only recalculated when its dependencies change.

By leveraging these hooks, you can achieve better state management, improve performance, and enhance the overall development experience in React.

Avoid Excessive Nesting

The problem with excessive nesting

Excessive nesting in React components can lead to several issues that hinder code readability and maintainability. When components are deeply nested, it becomes challenging to understand the flow of data and logic within the application. This can make it difficult to debug issues and add new features efficiently.

Another problem with excessive nesting is the tight coupling of components. When components are tightly coupled, it becomes harder to reuse them in different parts of the application. Components should be modular and independent so that they can be easily composed and composed to build complex UIs.

Strategies for reducing component nesting

To reduce component nesting, you can employ a few strategies:

  1. Break down complex components into smaller, reusable ones: Instead of creating a single large component, break it down into smaller components with specific responsibilities. This makes the code more modular and easier to understand.

  2. Use composition to create complex UIs: Rather than nesting components deeply, use composition to build complex UIs. This involves using a combination of reusable components to create more significant components without excessive nesting.

  3. Utilize container and presentational components: Separate your components into container components, which handle data and logic, and presentational components, which focus on rendering UI. This separation of concerns helps reduce nesting and makes components more reusable.

The impact on performance

Excessive nesting can have an impact on performance. When components are deeply nested, updating the state in one component can trigger unnecessary re-renders in other components. This can lead to decreased performance and slower UI updates.

By reducing nesting, you can minimize the number of components that need to be re-rendered when a state change occurs. This optimization can result in improved performance and a smoother user experience.

Use TypeScript For Better React Code

What is TypeScript

TypeScript is a statically typed superset of JavaScript that adds optional type checking. It allows developers to define types for variables, parameters, and return values, making it easier to catch and prevent type-related bugs. TypeScript compiles down to plain JavaScript and can be used in any JavaScript project, including React.

The benefits of using TypeScript in React

Using TypeScript in React projects offers several benefits:

  1. Type safety: TypeScript helps catch type-related errors during development, preventing bugs at runtime. By explicitly defining the types of variables and props, TypeScript provides better code accuracy and reliability.

  2. Easier refactoring: With TypeScript, refactoring becomes more manageable as the IDE can provide type-related suggestions and automatically update the affected code. This saves time and reduces the chances of introducing new bugs.

  3. Improved maintainability: TypeScript improves code documentation by making the types explicit. This makes it easier for developers to understand and maintain the codebase, especially when collaborating with others.

  4. Enhanced tooling support: TypeScript provides advanced tooling support in modern IDEs, such as code completion, inline documentation, and static analysis. This improves productivity and helps developers write cleaner and more error-free code.

How TypeScript ensures type safety and eases maintenance

TypeScript enforces type checking at compile-time, catching type-related errors early in the development process. This prevents many common bugs and improves code reliability. By using TypeScript’s static typing features, developers can:

  • Define prop and state types for React components, ensuring that the correct data types are passed between components.
  • Implement strict null checks, reducing the chances of encountering runtime errors related to null or undefined values.
  • Utilize enums and union types to define a restricted set of allowed values for variables, reducing the likelihood of invalid inputs.
  • Use interfaces to enforce a consistent structure for objects and their properties, making code more maintainable.

By leveraging these TypeScript features, developers can write more reliable code, reduce bugs, and enhance the maintainability of their React applications.

React Re-renders and When To Worry

Understanding React’s virtual DOM and re-rendering

React uses a virtual DOM to efficiently update the UI and minimize the number of re-renders. The virtual DOM is a lightweight representation of the actual DOM and allows React to compare the previous and current states of the UI and apply only the necessary changes.

Re-renders occur when there is a change in the state or props of a component. React identifies these changes by performing a diffing algorithm between the previous and current virtual DOM representations. It then updates only the parts of the UI that require modification, leading to better performance.

When to worry about re-renders

In most cases, re-renders in React are harmless and do not pose a significant performance issue. React’s diffing algorithm is designed to optimize re-renders, ensuring that only the necessary updates are made.

However, there are situations where excessive re-renders can impact performance:

  1. Large components with expensive calculations: If a component performs complex calculations during every render, it can cause performance degradation. In such cases, optimization techniques like memoization or using shouldComponentUpdate can be employed to minimize unnecessary re-renders.

  2. Frequent state updates: Components that undergo frequent state changes can lead to excessive re-renders. To mitigate this, developers can use hooks like useCallback and useMemo to optimize the rendering process.

  3. Inefficient prop passing: Passing large or frequently changing objects as props can trigger unnecessary re-renders in child components. Careful consideration should be given to prop design to avoid unnecessary re-renders.

How to handle unnecessary re-renders

To handle unnecessary re-renders in React, developers can employ a few techniques:

  1. Memoization: By using hooks like useCallback and useMemo, functions and values can be memoized, ensuring they are only recalculated when their dependencies change. This helps optimize performance by preventing unnecessary re-renders.

  2. Virtualization: When dealing with lists or grids with a large number of items, virtualization techniques like windowing or infinite scrolling can be used to improve performance. These techniques render only the visible portion of the list, reducing the number of components that need to be rendered and updated.

  3. Pure components or shouldComponentUpdate: By implementing shouldComponentUpdate or extending the PureComponent class, developers can fine-tune the rendering process and prevent unnecessary re-renders. These methods allow control over when a component should update based on changes in props or state.

By understanding the causes of unnecessary re-renders and leveraging optimization techniques, developers can ensure their React applications have optimal performance.

The Power Dependency Arrays in React Hooks

Exploring useEffect, useMemo, and useCallback hooks

Dependency arrays are an essential concept in React hooks like useEffect, useMemo, and useCallback. They allow developers to specify the dependencies that trigger the effect or memoization function.

The useEffect hook is used to perform side effects, such as fetching data or subscribing to events, in a function component. By providing a dependency array as the second argument to useEffect, developers can specify which values the effect relies on. React will only call the effect when one of the dependencies has changed.

The useMemo and useCallback hooks are used to memoize values and functions, respectively. They are particularly useful when dealing with expensive calculations or callbacks that depend on specific values. By specifying a dependency array, the memoized value or function will only be recalculated when the dependencies have changed.

How dependency arrays optimize re-renders and avoid bugs

Dependency arrays play a crucial role in optimizing re-renders and preventing bugs in React applications:

  1. Optimizing re-renders: By specifying dependencies in the dependency array, developers can control when a function or effect runs. This prevents unnecessary re-renders and ensures that calculations or side effects are only performed when needed.

  2. Preventing stale closures: In JavaScript, closures capture the values of variables from their surrounding scope. When a closure relies on a variable that can change, it can lead to bugs and unexpected behavior. By including the variable as a dependency, React ensures that the closure always has access to the latest value.

  3. Avoiding infinite loops: When using useEffect, omitting the dependency array can lead to an infinite loop if the effect updates the same value it depends on. By providing the correct dependencies, React can detect and prevent infinite loops caused by these circular dependencies.

Best practices for using dependency arrays

To effectively use dependency arrays in React hooks, it is important to follow these best practices:

  1. Specify all dependencies: Ensure that all variables or values that the function or effect depends on are included in the dependency array. This helps prevent bugs caused by stale closures or missing dependencies.

  2. Avoid empty dependency arrays: In most cases, providing an empty dependency array ([]), which means the effect or memoization only runs once, is not recommended. It is important to carefully consider the dependencies and specify them correctly.

  3. Functional dependencies: When a dependency is a function, it is essential to wrap it in useCallback. This memoizes the function and prevents unnecessary re-renders if the function reference remains the same.

By following these best practices, developers can take full advantage of dependency arrays in React hooks, optimizing performance and avoiding common bugs.

The Importance of useCallback and useMemo Hooks

Understanding useCallback and useMemo hooks

The useCallback and useMemo hooks are crucial tools for optimizing performance in React applications by retaining referential identity. While they both involve memoization, they serve different purposes:

  • useCallback: useCallback is used to memoize functions so that they are only created when their dependencies change. It returns a memoized version of the provided function, preventing unnecessary re-creation of the function on each render.

  • useMemo: useMemo is used to memoize values or complex calculations. It takes a function and a dependency array and returns a memoized value. The value is recalculated only when one of the dependencies in the array changes.

When to use useCallback and useMemo hooks

It is important to use useCallback and useMemo hooks in specific situations to optimize the performance of React applications:

  • useCallback: useCallback is useful when passing functions as props to child components. By wrapping the function with useCallback, you ensure that the function reference remains the same, preventing unnecessary re-renders of child components. This is especially important in scenarios where child components heavily rely on the prop function.

  • useMemo: useMemo is useful when performing expensive calculations or deriving values from props or state. By memoizing the calculation with useMemo, you can avoid re-computing the value on every render, thus optimizing performance.

In both cases, it is vital to provide the correct dependency array. The dependency array should include all variables that the function or value depends on. This ensures that the memoization is triggered only when necessary.

How these hooks enhance performance through retaining referential identity

By retaining referential identity, useCallback and useMemo hooks optimize performance in React applications:

  • Retaining function references: By using useCallback, you can ensure that a function reference remains the same unless its dependencies change. This prevents unnecessary re-creation of the function, leading to improved performance. It ensures that child components do not re-render unnecessarily when a prop function remains the same.

  • Caching complex calculations: useMemo allows you to cache the result of complex calculations, preventing recomputation on each render. By providing a dependency array, you indicate when the calculation needs to be recalculated. This optimization technique can dramatically improve performance when dealing with computationally intensive operations.

By utilizing useCallback and useMemo hooks appropriately, developers can optimize their React applications and provide a smoother user experience.

Custom Hooks for Better Code Organization

What are custom hooks

Custom hooks are JavaScript functions that allow you to reuse stateful logic across multiple components. They enable encapsulating complex logic into a single function, making the code more modular and reusable. Custom hooks can be shared between different components, reducing code duplication and improving code organization.

To create a custom hook, you start by prefixing the function name with “use.” This naming convention indicates that the function follows the rules of React hooks and can be used in functional components.

Why use custom hooks

Using custom hooks offers several benefits for code organization in React applications:

  1. Reusability: Custom hooks allow you to extract common stateful logic and reuse it across multiple components. This promotes code reuse and reduces the amount of repetitive code.

  2. Modularization: By encapsulating logic in custom hooks, you can create smaller, more focused components. This enhances code modularity, making it easier to understand, test, and maintain.

  3. Simplified testing: Custom hooks can simplify testing by isolating complex logic. Since hooks are separate functions, they can be tested independently, improving the overall testability of the codebase.

Examples of custom hooks and how they can aid code reusability and organization

Custom hooks can be used for a wide range of purposes, depending on the requirements of the application. Here are a few examples of custom hooks and their benefits:

  1. UseForm: This custom hook helps manage form state by abstracting away the boilerplate code for form validation and handling. It can be reused across different forms in the application, reducing duplication and improving code organization.

  2. UseLocalStorage: This custom hook simplifies the process of storing and retrieving data from localStorage. By encapsulating the localStorage logic, it becomes easy to use this hook in various components that require persistent data storage.

  3. UseMediaQuery: This custom hook detects changes in the viewport size and allows components to respond accordingly. By extracting this logic into a custom hook, it becomes reusable across different components that need to adapt their rendering based on the screen size.

By creating and utilizing custom hooks, developers can achieve better code reusability, encapsulate complex logic, and improve the overall organization of their React applications.

Alternative State Management Techniques

The fallacy of Redux compulsion

Redux is a popular state management library for React applications, but it is not always necessary. Many developers feel compelled to use Redux in their projects, assuming that it is the only solution for managing complex application state. However, this is a fallacy. While Redux has its advantages, it is not always the most efficient or appropriate choice for every project.

Redux adds additional complexity and boilerplate code, which can make simple applications more complicated than necessary. It is essential to carefully evaluate the requirements of your project before deciding to use Redux.

Opting for React context over Redux

React context is a built-in feature of React that provides a simple and scalable alternative to Redux for managing state. It allows you to create a shared state accessible to all components without the need for prop drilling. React context provides a convenient and lightweight solution for state management in applications with moderate complexity.

When considering whether to use React context or Redux, it is important to assess the scale and complexity of your application. For smaller projects or cases where the state management requirements are not overly complex, React context may be more appropriate and can help avoid unnecessary complexity.

Exploring libraries like React Query or SWR for state management

React Query and SWR are powerful libraries that provide alternative state management solutions specifically designed for handling asynchronous data-fetching. These libraries simplify the process of fetching, caching, and synchronizing data from APIs, making them great choices for applications with extensive data-fetching needs.

React Query simplifies the process of managing remote data by providing hooks that handle fetching, caching, invalidation, and refetching of data. SWR (Stale-While-Revalidate) takes a similar approach but focuses on providing a simple API for caching and revalidating data.

These libraries offer great alternatives to Redux when the primary focus of state management is data-fetching. They provide a more streamlined and intuitive way to manage async data without the need for complex reducers and actions.

By evaluating the requirements and complexities of your state management needs, you can choose the most appropriate solution, whether it’s React context, Redux, React Query, SWR, or a combination thereof.

Efficient Data Fetching with Query Libraries

Understanding query libraries

Query libraries like React Query and SWR are efficient data-fetching solutions designed to simplify interactions with remote APIs. They provide a declarative and intuitive way to manage data fetching, caching, and synchronization.

These libraries have built-in features like automatic caching, background refresh, and intelligent revalidation. They handle the complexities of data fetching, allowing developers to focus on building UI components that consume and display the fetched data.

The advantages of using React Query or SWR for data fetching

React Query and SWR offer several advantages over traditional data-fetching techniques:

  1. Automatic caching: Both libraries handle data caching automatically, reducing the need for developers to manage complex caching logic manually. This improves performance by minimizing unnecessary API requests.

  2. Background data refetching: Query libraries proactively refetch data in the background, ensuring that data is always up to date without requiring explicit user actions. This provides a better user experience by displaying the latest information without delay.

  3. Intelligent revalidation: React Query and SWR have built-in revalidation mechanisms that intelligently determine when to refetch data based on various conditions like time since last fetch or dependencies. This helps eliminate stale data and keeps the UI in sync with the API.

How these libraries handle caching effectively

Both React Query and SWR use caching mechanisms to optimize data fetching:

  • React Query: React Query provides a powerful cache system that stores the fetched data locally in memory. It intelligently updates the cache based on various triggers, including mutations that modify the data. This enables the UI to react instantly to state changes without additional API requests.

  • SWR: SWR uses a clever caching strategy called “Stale-While-Revalidate.” It first returns the data from the cache (stale data) while simultaneously sending a background request to the server for fresh data. Once the server responds, it updates the cache and triggers a re-render of the component, ensuring that the UI displays the latest data.

These caching strategies effectively balance performance and data freshness, allowing applications to provide fast and up-to-date user experiences.


In this comprehensive article, we have explored various best practices and techniques for developing React applications. We have discussed the advantages of functional components and the use of React hooks for state management. We have also highlighted the importance of avoiding excessive nesting and utilizing TypeScript for better code quality and maintainability.

Additionally, we have delved into the concepts of React re-renders and when to be concerned, as well as the power of dependency arrays in optimizing performance. We have emphasized the significance of useCallback and useMemo hooks for better performance and referential identity retention.

Furthermore, we have discussed the benefits of using custom hooks for code organization and reusability. We have shed light on alternative state management techniques, such as React context and libraries like React Query and SWR. Lastly, we have explored efficient data fetching with query libraries and the advantages they offer.

By following these do’s and don’ts of React development, you can enhance the quality, maintainability, and performance of your React projects. Whether it be utilizing functional components, leveraging React hooks, implementing TypeScript, optimizing re-renders, or exploring alternative state management techniques, these best practices will empower you to write better code and create exceptional React applications.

To delve deeper into React development techniques, you can explore online resources, official documentation, tutorials, and communities dedicated to React. Happy coding!

Watch Now