• Articles
  • Tutorials
  • Interview Questions

How to Create Tabs in React

How to Create Tabs in React

We will walk you through the process of constructing a highly customizable Tab Component in React that can simply be incorporated into any project in this blog article. Let’s begin by reviewing the steps required to make this component.

Check out this Full Stack Development Course video to learn more about its concepts:

What is React Tab?

React Tabs is a popular open-source framework for creating React tabbed interfaces. It provides a straightforward and adaptable API for constructing tab components that can be readily integrated into any React application. 

React Tabs allows you to construct tabbed interfaces with a variety of styles, layouts, and behaviors, such as vertical, horizontal, and scrollable tabs. The library also includes keyboard navigation, ARIA accessibility characteristics, and touch events for mobile devices. React Tabs is an excellent solution for developers who want to rapidly and easily add tabbed interfaces to their React applications. This is without having to design everything from scratch.

Setting up the Environment

Setting up the Environment

Let’s start by configuring our development environment. You must have Node.js and npm (Node Package Manager) installed on your PC to follow along. If you don’t have them, you can download the latest version from the official Node.js website.

Once Node.js and npm are installed, you can create a new React project using the Create React App command-line tool:

npx create-react-app react-tab-component

This will create a new folder named react-tab-component with all the necessary files and dependencies. Now, navigate to the project folder

cd react-tab-component

To start the development server, run

npm start

You should now see your new React app running in your default web browser. Let’s dive into building our tab component!

Get the knowledge you need to implement React in real world scenarios through our React JS Course.

Creating a Basic Tab Component

In this section, we’ll create a simple tab component using React’s built-in state management features.

  1. First, open the src folder and create a new folder named components. Inside the components folder, create a new file named
TabComponent.js.
  1. In TabComponent.js, start by importing the necessary React dependencies
import React, { useState } from 'react';
  1. Next, define a functional component called TabComponent
const TabComponent = () => {
  // Component logic goes here
};
export default TabComponent;
  1. Inside the TabComponent function, define an array of tab names and the initial state for the active tab
const tabs = ['Tab 1', 'Tab 2', 'Tab 3'];
const [activeTab, setActiveTab] = useState(tabs[0]);
  1. Now, create a function to handle tab clicks
const handleTabClick = (tab) => {
  setActiveTab(tab);
};
  1. Finally, render the tab component
return (
  <div>
    <ul className="tab-list">
      {tabs.map((tab, index) => (
        <li
          key={index}
          className={`tab-item ${activeTab === tab ? 'active' : ''}`}
          onClick={() => handleTabClick(tab)}
        >
          {tab}
        </li>
      ))}
    </ul>
    <div className="tab-content">
      <p>{`This is the content for ${activeTab}.`}</p>
    </div>
  </div>
);
  1. In the src folder, open the App.js file, and import the TabComponent
import TabComponent from './components/TabComponent';
  1. Replace the contents of the App component with the TabComponent
function App() {
  return (
    <div className="App">
      <TabComponent />
    </div>
  );
}
export default App;

Now, if you open your browser, you should see a basic tab component with three tabs. When you click on a tab, it becomes active and displays the corresponding content.

Integrating React Bootstrap Tabs

In this section, we’ll learn how to use React Bootstrap, a popular UI library, to enhance the appearance and functionality of our tab component.

  1. First, install the react-bootstrap package
npm install react-bootstrap@next bootstrap
  1. Import the Bootstrap CSS file in the src/index.js file
import 'bootstrap/dist/css/bootstrap.min.css';
  1. Open the TabComponent.js file, and import the necessary React Bootstrap components
import { Tab, Nav, Container } from 'react-bootstrap';
  1. Modify the TabComponent to use React Bootstrap components
const TabComponent = () => {
  const tabs = ['Tab 1', 'Tab 2', 'Tab 3'];
  const [activeTab, setActiveTab] = useState(tabs[0]);
  const handleTabClick = (tab) => {
    setActiveTab(tab);
  };
  return (
    <Container>
      <Nav variant="tabs" activeKey={activeTab} onSelect={handleTabClick}>
        {tabs.map((tab, index) => (
          <Nav.Item key={index}>
            <Nav.Link eventKey={tab}>{tab}</Nav.Link>
          </Nav.Item>
        ))}
      </Nav>
      <Tab.Content>
        <Tab.Pane eventKey={activeTab}>
          <p>{`This is the content for ${activeTab}.`}</p>
        </Tab.Pane>
      </Tab.Content>
    </Container>
  );
};
export default TabComponent;

Now, our tab component uses the React Bootstrap library to style the tabs and manage their behavior. This makes the component more visually appealing and easier to maintain.

Preparing for a Job Interview? Check out our blog on React Interview Questions!

Benefits of Creating Reusable Components

Benefits of creating reusable components

Creating reusable components is a fundamental concept in modern software development, and it offers several benefits, including:

  • Increased Productivity: Reusable components can save time and effort in development because they can be used in multiple places throughout an application. This means that developers can focus on creating new features and functionality rather than reinventing the wheel with every new project or task.
  • Consistency: Reusable components help ensure consistency in the user interface and design of an application. By using the same components throughout the application, developers can ensure that the user experience is consistent and that the application looks and behaves in a predictable manner.
  • Simplified Maintenance: Reusable components can simplify maintenance and updates to an application. If a bug is found in a reusable component, fixing it once will ensure that the fix is applied to all instances of the component. This can save significant time and effort compared to fixing the same bug in multiple places throughout the application.
  • Scalability: Reusable components can make an application more scalable by allowing for easier integration with new features and functionality. As the application grows and new features are added, existing components can be reused and adapted to accommodate the new requirements, rather than starting from scratch.

Overall, creating reusable components is a best practice in software development that can save time, ensure consistency, simplify maintenance, and make an application more scalable.

Building React Native Tabs

React Native is a popular framework for building native mobile applications using React. In this section, we’ll build a tab component using React Native components.

  1. First, install the react-native package
npm install -g react-native
  1. Create a new React Native project
react-native init ReactNativeTabComponent
  1. Navigate to the project folder, and start the development server
cd ReactNativeTabComponent
npm start
  1. Open a new terminal window, and run the app on an iOS simulator or Android emulator
npm run ios
npm run android
  1. In the src folder, create a new file named ReactNativeTabComponent.js.
  2. Import the necessary React Native components
import React, { useState } from 'react';
import { View, Text, TouchableOpacity, StyleSheet } from 'react-native';
  1. Define a functional component called ReactNativeTabComponent
const ReactNativeTabComponent = () => {
 // Component logic goes here
};
export default ReactNativeTabComponent;
  1. Inside the ReactNativeTabComponent function, define an array of tab names and the initial state for the active tab
const tabs = ['Tab 1', 'Tab 2', 'Tab 3'];
const [activeTab, setActiveTab] = useState(tabs[0]);
  1. Now, create a function to handle tab clicks
const handleTabClick = (tab) => {
  setActiveTab(tab);
};
  1. Finally, render the tab component using React Native components
return (
  <View style={styles.container}>
    <View style={styles.tabList}>
      {tabs.map((tab, index) => (
        <TouchableOpacity
          key={index}
          style={[
            styles.tabItem,
            activeTab === tab ? styles.activeTab : null,
          ]}
          onPress={() => handleTabClick(tab)}
        >
          <Text style={styles.tabText}>{tab}</Text>
        </TouchableOpacity>
      ))}
    </View>
    <View style={styles.tabContent}>
      <Text>{`This is the content for ${activeTab}.`}</Text>
    </View>
  </View>
);
  1. Add a basic stylesheet for the tab component
const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
  },
  tabList: {
    flexDirection: 'row',
    marginBottom: 20,
  },
  tabItem: {
    paddingHorizontal: 20,
    paddingVertical: 10,
    borderBottomWidth: 2,
    borderBottomColor: 'transparent',
  },
  activeTab: {
    borderBottomColor: 'blue',
  },
  tabText: {
    fontSize: 16,
  },
  tabContent: {
    paddingHorizontal: 20,
  },
});
  1. In the App.js file, import the ReactNativeTabComponent and replace the contents of the App component with it
import ReactNativeTabComponent from './components/ReactNativeTabComponent';
const App = () => {
  return (
    <View style={{ flex: 1 }}>
      <ReactNativeTabComponent />
    </View>
  );
};
export default App;

You should now see a React Native tab component in the emulator or simulator.

Get your React JS basics clear through our React JS Tutorial.

Implementing React Native Scrollable Tabs

To implement React Native Scrollable Tabs, you can use a popular library called react-native-scrollable-tab-view. Here are the steps you can follow

  1. Install the library using npm or yarn
npm install react-native-scrollable-tab-view
or
yarn add react-native-scrollable-tab-view
  1. Import the library into your component and use it to render your tabbed interface
import ScrollableTabView from 'react-native-scrollable-tab-view';
// ...
render() {
  return (
    <ScrollableTabView>
      <Text tabLabel="Tab 1">Tab 1 content</Text>
      <Text tabLabel="Tab 2">Tab 2 content</Text>
      <Text tabLabel="Tab 3">Tab 3 content</Text>
    </ScrollableTabView>
  );
}
  1. Customize the appearance and behavior of your tabs using the props provided by the library
<ScrollableTabView
  tabBarActiveTextColor="#FFFFFF"
  tabBarBackgroundColor="#000000"
  tabBarUnderlineStyle={{ backgroundColor: '#FFFFFF' }}
>
  {/* ... */}
</ScrollableTabView>

That’s it! With just a few lines of code, you can easily add a scrollable tabbed interface to your React Native application using the react-native-scrollable-tab-view library.

React Native Tab Navigation

React Native Tab Navigation is a popular navigation pattern in mobile apps, where the user can navigate between different screens or sections of the app by tapping on tabs at the bottom or top of the screen. React Navigation is a popular library that provides a simple and customizable API for implementing React Native Tab Navigation. Here are the steps you can follow

  1. Install the library using npm or yarn
npm install @react-navigation/native
Or
yarn add @react-navigation/native
  1. Install the required dependencies:
npm install react-native-reanimated react-native-gesture-handler react-native-screens react-native-safe-area-context @react-native-community/masked-view

Or

yarn add react-native-reanimated react-native-gesture-handler react-native-screens react-native-safe-area-context @react-native-community/masked-view
  1. Import the required components from the library and use them to define your tab navigation
import { createBottomTabNavigator } from '@react-navigation/bottom-tabs';
import { NavigationContainer } from '@react-navigation/native';

const Tab = createBottomTabNavigator();

function App() {
  return (
    <NavigationContainer>
      <Tab.Navigator>
        <Tab.Screen name="Home" component={HomeScreen} />
        <Tab.Screen name="Settings" component={SettingsScreen} />
      </Tab.Navigator>
    </NavigationContainer>
  );
}
  1. Customize the appearance and behavior of your tabs using the props provided by the library
<Tab.Navigator
  tabBarOptions={{
    activeTintColor: '#FFFFFF',
    inactiveTintColor: '#BBBBBB',
    style: {
      backgroundColor: '#000000',
      borderTopWidth: 0,
      shadowColor: '#000000',
      shadowOffset: { width: 0, height: -1 },
      shadowOpacity: 0.2,
      shadowRadius: 3,
    },
    labelStyle: {
      fontSize: 16,
      fontWeight: 'bold',
      marginBottom: 5,
    },
    tabStyle: {
      paddingTop: 10,
      paddingBottom: 5,
    },
  }}
>
  {/* ... */}
</Tab.Navigator>

That’s it! With just a few lines of code, you can easily add tab navigation to your React Native application using the React Navigation library.

Conclusion

Finally, creating a Tab Component in React is an excellent method to improve the user experience of your web application. You can organize your material in a clean and intuitive fashion by designing reusable components, making it easy for visitors to navigate and discover the information they need. In this blog, we looked at how to create a custom Tab Component from scratch using React in this article. 

We also talked about the advantages of developing reusable components and how they may help you speed up development while also improving code maintainability. You can now develop your own tabbed interfaces and take your React applications to the next level with the skills and information you’ve obtained from this lesson.

If you have any queries, drop them on Intellipaat’s Web Technology Community.

Course Schedule

Name Date Details
Web Development Courses 20 Jul 2024(Sat-Sun) Weekend Batch
View Details
Web Development Courses 27 Jul 2024(Sat-Sun) Weekend Batch
View Details
Web Development Courses 03 Aug 2024(Sat-Sun) Weekend Batch
View Details

About the Author

Techical Research Analyst - Front End Development

As a Technical Research Analyst, Kislaya specializes in Front End Development. He is a Full Stack Developer, known for crafting scalable architectures and user-centric interfaces. He has a massive international client base and is an expert in cloud computing, Linux, and Java Script, personifying a commitment to quality and information sharing.