Navigating between routes in a React application typically involves using the React Router library, which provides a collection of navigational components that you can use to manage navigation and rendering of components in your React applications. Here’s a basic guide on how to set up and use React Router for navigation:

1. Installation

First, you need to install React Router. If you’re using npm, you can install it by running:

npm install react-router-dom

Or, if you’re using yarn, you can install it by running:

yarn add react-router-dom

2. Setting Up Router

You’ll need to wrap your app in a <BrowserRouter> component at the root level. This component provides the foundational routing context needed for the navigational components to work. Here’s an example of how to set it up in your main application file (e.g., App.js or index.js):

import React from ‘react’
import ReactDOM from ‘react-dom’
import { BrowserRouter } from ‘react-router-dom’
import App from ‘./App’ // Import your main App component
<App />

3. Configuring Routes

Within your App component (or any subcomponent), use <Route> components to define mappings between pathnames and components. You’ll also use a <Switch> component to group <Route>s together, ensuring that only the first matching route is rendered. Here’s a basic setup:

import React from ‘react’
import { BrowserRouter as Router, Route, Link, Routes } from ‘react-router-dom’
import AboutPage from ‘./AboutPage’
import HomePage from ‘./HomePage’

const App = () => {
return (
<Link to=’/’>Home</Link>
<Link to=’/about’>About</Link>

<Route path=’/about’ element={<AboutPage />} />
<Route path=’/’ element={<HomePage />} />

export default App

4.Creating Components


import React from ‘react’

export default function HomePage() {
return <div>This is a HomePage</div>


import React from ‘react’

export default function AboutPage() {
return <div>This is AboutPage</div>

5. Navigating with Links

To navigate between pages, you’ll use the <Link> component instead of <a> tags. This lets you navigate without reloading the page. Here’s how you might set it up in a component:

import React from ‘react’;
import { Link } from ‘react-router-dom’;
function NavBar() {
return (
<li><Link to="/">Home</Link></li>
<li><Link to="/about">About</Link></li>
export default NavBar;

6. Programmatically Navigating

Sometimes, you might need to navigate programmatically, such as after a form submission. You can use the useHistory hook (for React Router v5) or the useNavigate hook (for React Router v6) in your components to do this:

For React Router v6:

import React from ‘react’;
import { useNavigate } from ‘react-router-dom’;
function MyComponent() {
let navigate = useNavigate();
function handleClick() {
navigate(‘/about’); // Navigate to the about page
return <button onClick={handleClick}>Go to About</button>;

For React Router v5, you would use useHistory instead:

import { useHistory } from ‘react-router-dom’;
// Inside your component
let history = useHistory();

This guide should help you get started with basic navigation in a React application using React Router. Remember, React Router’s documentation is a great resource for deeper exploration of its capabilities and features.

Common Gotchas with React Router

React Router is a powerful tool for managing navigation in React applications, but like any library, it has its quirks and common pitfalls that developers might encounter. Here are some of the common “gotchas” to watch out for when using React Router:

  1. Not Wrapping Your App with a Router
    One of the most common mistakes is forgetting to wrap your application’s root component with a <BrowserRouter> (or another router component, depending on your environment). This wrapping provides the necessary context for all nested route components.
  2. Using <a> Tags Instead of <Link> or <NavLink>
    Using standard HTML <a> tags for navigation will cause the page to reload, which defeats the purpose of a single-page application (SPA). Instead, you should use <Link> or <NavLink> components provided by React Router for internal navigation to prevent full page reloads.
  3. Confusing the exact Prop
    When you use the exact prop on a <Route>, it will only match if the path matches the location.pathname exactly. Without exact, the route will match the beginning segment of the URL. This can lead to unexpected behavior where multiple routes are matched and rendered.
  4. Nested Routes Not Rendering
    For nested routes, ensure that the parent route does not have the exact prop if you want the child routes to render. The exact prop on a parent route can prevent child routes from rendering because it restricts the match to be exact, not allowing for additional path segments.
  5. Misunderstanding Switch Behavior
    The <Switch> component renders the first child <Route> or <Redirect> that matches the location. Without <Switch>, multiple routes might match and render simultaneously. It’s essential to structure your routes correctly within a <Switch> to ensure only the desired component is rendered.
  6. Ignoring the basename Prop of <BrowserRouter>
    If your application is served from a subdirectory on your server, you might forget to set the basename prop on <BrowserRouter>. This prop ensures that all navigation is relative to the specified base URL.
  7. Forgetting to Handle 404 Pages
    Not configuring a catch-all route can leave users without feedback when they navigate to a non-existent route in your application. You can create a catch-all route by adding a <Route> without a path prop or with a path=”*” at the end of your <Switch>.
  8. Overlooking the Importance of useHistory and useLocation Hooks
    React Router v5 introduced hooks like useHistory and useLocation that can be used to programmatically navigate or access the current location’s details. Not leveraging these hooks when needed can complicate component logic, especially when trying to perform navigation or location checks.
  9. Misusing Query Parameters
    React Router does not have built-in support for parsing query parameters. You often need to use an external library like query-string to parse and stringify query parameters, which some developers might overlook.
  10. Not Updating Components on Route Changes
    Sometimes, components fail to update when the route changes because they are not directly connected to the route’s state. This issue can often be resolved by using the useParams or useRouteMatch hooks to make the component react to route changes.
  11. Handling Redirects Incorrectly:
    Redirects are commonly used for various purposes such as authentication and page redirection. However, incorrect usage or placement of redirect components like <Redirect> or useHistory().push() can lead to unexpected behavior, such as infinite redirection loops or incorrect page rendering.
  12. Route Component Re-Rendering:
    React Router’s <Route> components re-render whenever the route’s path or location changes. While this behavior is usually desired, it can lead to performance issues if not managed properly, especially if your route components contain heavy computations or side effects.
  13. Memory Leaks with Route Components:
    Be cautious when using route components with event listeners or subscriptions. If these components are not properly cleaned up when unmounted, they can lead to memory leaks over time. Ensure to unsubscribe from event listeners or dispose of subscriptions in the componentWillUnmount lifecycle method or useEffect cleanup function.
  14. Dynamic Route Changes with Route Props:
    When using dynamic route parameters (e.g., /:id) with <Route> components, be aware that changes to these parameters might not trigger a re-render of the route component by default. You may need to use the component or render props of <Route> to manually handle updates based on changes in route parameters.
  15. Performance Impact of Route Rendering:
    Rendering multiple nested routes or deeply nested route components can impact performance, especially on lower-end devices or slower networks. Consider optimizing your route structure by splitting complex components into smaller ones and using techniques like code splitting to reduce the initial bundle size.
  16. SEO and Server-Side Rendering (SSR):
    React Router’s client-side routing may not be sufficient for applications that require server-side rendering (SSR) or search engine optimization (SEO). Ensure to implement server-side rendering solutions or pre-rendering techniques to improve SEO and provide better performance for crawlers and initial page loads.
  17. Context and Route State Management:
    Managing application state and context alongside React Router’s route navigation can be challenging, especially in larger applications. Consider using state management libraries like Redux or React Context API to manage shared state across routes and components effectively.

Understanding these common pitfalls and how to avoid them can lead to a smoother development experience and a more robust application. Always refer to the latest React Router documentation for guidance on best practices and updates to the library.

< React 16:

Route Configuration with component Prop:

In the earlier versions of React Router, routes were often configured using the component prop in the Route component. This prop would take a reference to the component class, as demonstrated in the following example:

import React from ‘react’;
import { Route } from ‘react-router-dom’;
const Home = () => <div>Home Component</div>;
<Route path="/home" component={Home} />;

Switch for Exclusive Rendering:

The Switch component was utilized to wrap Route components. It rendered the first Route that matched the current location, providing exclusive rendering of components.

import React from ‘react’;
import { Route, Switch } from ‘react-router-dom’;

const Home = () => <div>Home Component</div>;
const About = () => <div>About Component</div>;
<Route path="/home" component={Home} />
<Route path="/about" component={About} />

After React 16:

Route Configuration with element Prop:

With the introduction of functional components and hooks, the component prop has been replaced by the element prop. Now, you can pass the JSX element directly.

import React from ‘react’;
import { Route } from ‘react-router-dom’;
const Home = () => <div>Home Component</div>;
<Route path="/home" element={<Home />} />;

 Routes for Nested Routing:

The Routes component was introduced as a replacement for Switch. It is designed for better support of nested routes and is used to group multiple Route components, providing a more flexible approach.

import React from ‘react’;
import { Routes, Route } from ‘react-router-dom’;
const Home = () => <div>Home Component</div>;
const About = () => <div>About Component</div>;
<Route path="/home" element={<Home />} />
<Route path="/about" element={<About />} />

Dynamic Routes with * Wildcard:

Dynamic route segments are now handled more flexibly with the introduction of the * wildcard. This allows for dynamic parameter handling in route paths.

import React from ‘react’;
import { Routes, Route } from ‘react-router-dom’;

const UserProfile = () => <div>User Profile Component</div>;

<Route path="/users/:userId" element={<UserProfile />} />

Other Alternatives

Apart from React Router, several other libraries can be used for routing in React applications. Each of these libraries offers unique features and approaches to handling navigation and routing. Here’s an overview of some notable alternatives:

1. Reach Router

  • Website: Reach Router
  • Features:
    • Accessibility: Designed with accessibility in mind, Reach Router automatically manages focus for navigated components, ensuring a positive experience for users with disabilities.
    • Simplicity: Offers a simple and intuitive API similar to React Router, making it easy to pick up and use.
    • Merged with React Router: While Reach Router was merged with React Router in version 6, it continues to be a good choice for projects that specifically require its accessibility features or for smaller projects that benefit from its simplicity.

2. Next.js Router

  • Website: Next.js
  • Features:
    • Built-in Routing: Next.js includes a built-in routing system with a file-based approach, where routes are defined by the file structure in the pages directory.
    • Dynamic Routing: Supports dynamic routing, allowing for the creation of pages with dynamic content based on parameters.
    • Nested Routes: Enables nested routes, providing a flexible structure for organizing components.
    • Server-Side Rendering (SSR): Supports server-side rendering out of the box, which can be beneficial for performance and SEO.
    • Static Site Generation (SSG): Allows for static site generation, enhancing performance and reducing server load.

3. Gatsby Router

  • Website: Gatsby
  • Features:
    • Static Site Generator: Gatsby is primarily a static site generator optimized for building fast and efficient static websites.
    • File-Based Routing: Utilizes a file-based routing system similar to Next.js, making it easy to organize routes.
    • GraphQL Integration: Integrates seamlessly with GraphQL for efficient data fetching and manipulation.
    • Plugin Ecosystem: Provides a rich plugin ecosystem for extending functionality, including routing enhancements.
    • Optimized for Static Websites: Ideal for projects where static site generation is a priority.

4. Navigo

  • Website: Navigo
  • Features:
    • Vanilla JavaScript Router: Navigo is a simple and lightweight vanilla JavaScript router that can be used in React projects.
    • Straightforward API: Offers a straightforward API for handling routing with minimal setup, suitable for projects that do not require React-specific features.
    • Minimal Dependencies: Has minimal dependencies, making it a lightweight choice for basic routing needs.

5. React Location

  • Website: React Location
  • Features:
    • Modern Router Library: React Location is a modern router library designed for React applications.
    • Asynchronous Data Loading: Supports features like asynchronous data loading, allowing for efficient fetching of data during navigation.
    • Search Parameters Handling: Provides built-in support for handling search parameters in URLs.
    • Nested Routing: Designed for React apps that require complex routing solutions and have specific data fetching needs.

6. Hookrouter

  • Website: Hookrouter
  • Features:
    • Hook-Based Router: Hookrouter is a hook-based router for React, emphasizing simplicity and the use of React hooks.
    • Simplicity: Offers a simple and clean API, making it suitable for smaller projects or developers who want to leverage hooks fully within their routing logic.
    • Lightweight: With a focus on simplicity, it provides a lightweight option for basic routing requirements.

Choosing the Right Router

The choice of routing library depends on several factors, including:

  • Project Requirements: Consider if you need server-side rendering, static site generation, or a single-page application.
  • Complexity: Some routers offer more straightforward APIs than others, which can be beneficial for smaller projects.
  • Community and Support: Consider the library’s community support and documentation.
  • Performance: For highly dynamic and interactive applications, router performance can be a critical factor.

It’s essential to evaluate these factors in the context of your specific project needs to choose the most suitable routing library.