Mastering Code Refactoring with ReactJS and TypeScript

In the fast-paced world of web development, it’s crucial to keep your codebase clean, efficient, and maintainable. Code refactoring plays a pivotal role in achieving these goals. In this blog post, we’ll explore how to refactor your NextJS project using ReactJS and TypeScript, focusing on best practices and optimizations.

Minimize Code Size

One of the primary goals in refactoring is to reduce the codebase’s size, leading to build times and improved performance faster. Aim to keep each file under 250 lines of code. Break down larger components into smaller, reusable pieces.

TypeScript Best Practices

Ensure your TypeScript code is clean and maintainable by using proper types for variables, functions, and props. Avoid the use of “any” as much as possible, as it undermines the benefits of static typing. This enhances code readability and helps catch potential bugs during development.

Leverage Enums for Fixed Options

Use TypeScript enums for variables that can only take one option from a fixed list. For instance, create an API_STATUS enum to represent different states of API calls, enhancing code clarity and preventing errors.

enum API_STATUS {
  LOADING,
  SUCCESS,
  ERROR,
}

Remove File Consoles and Warnings

Clean up your codebase by removing console.log statements and unnecessary warnings. This not only improves code quality but also prevents unnecessary noise during development.

Lazy Load Components

Separate HTML parts that render conditionally into their components and import them as lazy-loaded components with Server-Side Rendering (SSR) set to false. This optimizes the initial page load and improves overall performance.

const ConditionalComponent = React.lazy(() =>
   import('./ConditionalComponent'), {
      ssr: false
   }
);
// ...
<React.Suspense fallback={<LoadingSpinner />}>
 {shouldRender && <ConditionalComponent />}
</React.Suspense>

Modularize API Calls

Avoid cluttering your pages folder with API calls and functions. Create separate child files for these functions and import them into the parent component. This represents a modular and organized code structure.

Helper Functions in Separate Files

Create separate helper files for functions that take input and provide output. This not only improves code organization but also encourages reusability across your project.

Constants and Models

Organize your constants and models based on modules. Create separate constant and model files within the module and have a common folder for those used across multiple modules.

Custom Hooks for State Management

Create a separate custom hook to handle state management and other hooks. This represents code reuse and keeps your components clean and focused.

// useCustomHook.ts
import { useState, useEffect } from 'react';
const useCustomHook = () => {
  const [state, setState] = useState(initialState);
  useEffect(() => {
    // Effect logic here
  }, [dependencies]);
  return { state, setState };
};
export default useCustomHook;

Directory Structure Best Practices

Follow a consistent and organized directory structure. The recommended structure includes folders for store, assets, and components. Within the components folder, further segregate into common, utils, constant, models, reducers, and services.

src
 | - store
    | - assets
    | - components
       | - common
           | - utils
           | - constant
           | - models
           | - reducers
           | - Service ===> apis call
       |- module 1
           | - components
           | - constant
           | - models
           | - reducers
           | - Service ===> apis call
       |- module 2
           | - components
           | - constant
           | - models
           | - reducers
           | - Service ===> apis call
    | - pages
       | - module 1
           | - index.tsx
       | - module 2
           | - index.tsx

Conclusion

Mastering code refactoring is a continuous process that pays off in terms of maintainability, performance, and developer satisfaction. By following these best practices in your ReactJS project with TypeScript, you’ll be on the path to creating a robust and efficient web application.

Check out our other blog posts for more insights.