Typing React Components: Enhancing Your Codebase with TypeScript


React is a popular library for building user interfaces that has gained tremendous traction in the web development community. In this article, we will discuss how to enhance your React components with TypeScript, a statically-typed superset of JavaScript that adds optional types to the language. TypeScript can significantly improve the developer experience and catch potential errors early, leading to more maintainable and robust codebases.

Let's dive into how to type React components and explore some code examples along the way!

Defining Props with TypeScript Interfaces

When using TypeScript with React, you can define your component's prop types using interfaces. Interfaces allow you to describe the shape of an object, making it easier to catch errors when using incorrect prop types.

Let's create a simple Greeting component that takes a name prop of type string

import React from 'react';

interface GreetingProps {
  name: string;

const Greeting: React.FC<GreetingProps> = ({ name }) => {
  return <h1>Hello, {name}!</h1>;

export default Greeting;

Here, we define an interface called GreetingProps with a single property name of type string. We then use the React.FC (Function Component) type to define our Greeting component, which expects props of type GreetingProps.

Optional Props and Default Values

You can also use TypeScript to define optional props and provide default values for them.

interface UserProfileProps {
  name: string;
  age?: number;

const UserProfile: React.FC<UserProfileProps> = ({ name, age = 25 }) => {
  return (
      <h1>Name: {name}</h1>
      <h2>Age: {age}</h2>

export default UserProfile;

In this example, we have a UserProfile component with name and age props. The age prop is marked as optional using the ? syntax , and we provide a default value of 25using the default parameter syntax.

Typing Event Handlers

When using event handlers in your components, you can use TypeScript to ensure that the correct event types are being passed.

interface ButtonProps {
  text: string;
  onClick: (event: React.MouseEvent<HTMLButtonElement>) => void;

const CustomButton: React.FC<ButtonProps> = ({ text, onClick }) => {
  return <button onClick={onClick}>{text}</button>;

export default CustomButton;

In the ButtonProps interface, we define an onClick prop with a specific event type React.MouseEvent<HTMLButtonElement>, which allows us to use the correct event type in our event handlers.

Using Generics for Reusable Components

TypeScript's generics can help create reusable components that work with various prop types.

interface ListProps<T> {
  items: T[];
  renderItem: (item: T) => React.ReactNode;

const List = <T,>(props: ListProps<T>) => {
  const { items, renderItem } = props;

  return (
      {items.map((item, index) => (
        <li key={index}>{renderItem(item)}</li>

export default List;

In this List component, we use a generic type T to represent the type of items in the items prop. This allows the component to be reused with different types of data.


This article demonstrates enhancing React components with TypeScript for improved developer experience and maintainability. We explore defining props, creating typed functional components, and using typed event handlers for robust, efficient applications.