React Components Explained: The Ultimate Beginner’s Guide
Posted on March 30, 2025 • 7 min read • 1,298 wordsLearn about React components in this beginner's guide. Explore functional vs. class components, props, state, JSX, and more for efficient React development.
React is one of the most popular JavaScript libraries for building user interfaces. Its component-based architecture allows developers to create reusable, maintainable, and efficient UI elements. Understanding components is the first step to mastering the library.
In React, components are the building blocks of the user interface. Each component is a JavaScript function or class that returns a part of the UI, which React can render to the DOM. Think of a component as a small, reusable unit of the UI that you can combine to create complex interfaces.
React allows developers to break down complex UIs into smaller, isolated components that manage their own state and behavior.
The primary advantage of React components lies in their reusability and modularity. By breaking down an application into smaller components, you can:
React components come in two primary types: Functional Components and Class Components.
Functional components are the simpler of the two types. They are JavaScript functions that return JSX (JavaScript XML), which is a syntax extension for JavaScript that looks similar to HTML. In modern React, functional components are the preferred way to write components.
import React from 'react';
function Greeting() {
return <h1>Hello, welcome to React!</h1>;
}
export default Greeting;In the above example, the Greeting component is a function that returns a simple heading element. Notice how the function doesn’t have any internal state or lifecycle methods.
Class components are a more traditional way to define React components. They use ES6 classes and must extend React.Component. Class components are more powerful because they can have internal state and lifecycle methods, but they are less commonly used in modern React development in favor of functional components and hooks.
import React, { Component } from 'react';
class Greeting extends Component {
render() {
return <h1>Hello, welcome to React!</h1>;
}
}
export default Greeting;While class components were once the norm, React’s move towards functional components with hooks has significantly reduced their use.
JSX (JavaScript XML) is a syntax extension for JavaScript used in React components. It allows you to write HTML-like code within JavaScript, making it easier to visualize the component’s structure.
import React from 'react';
function HelloWorld() {
return (
<div>
<h1>Hello, World!</h1>
<p>This is a JSX example.</p>
</div>
);
}
export default HelloWorld;In the above example, we used JSX to return a <div> element containing an <h1> and a <p> tag. Notice that JSX tags are written similarly to HTML, but they are ultimately transformed into JavaScript function calls by React’s build tools.
JSX is not mandatory in React, but it greatly enhances readability and development efficiency. It allows you to combine the logic (JavaScript) and the view (HTML-like structure) in one place. This makes React code more intuitive and easier to maintain.
Props (short for “properties”) are used to pass data from a parent component to a child component. In React, props are read-only and cannot be modified by the child component. They allow for dynamic rendering of UI elements based on the data passed down from the parent.
import React from 'react';
function Greeting(props) {
return <h1>Hello, {props.name}!</h1>;
}
function App() {
return <Greeting name="John" />;
}
export default App;In this example, the Greeting component receives a name prop from its parent component, App, and uses that prop to render a personalized greeting message. The props object holds all the data passed into a component, and you can access individual values using dot notation (props.name).
State is a special JavaScript object that stores data that can change over time and trigger a re-render of the component. While props are immutable and passed from parent to child, state is local to a component and can be updated by that component itself.
In functional components, state is managed using the useState hook.
useState Hook
import React, { useState } from 'react';
function Counter() {
const [count, setCount] = useState(0);
return (
<div>
<p>You clicked {count} times</p>
<button onClick={() => setCount(count + 1)}>Click me</button>
</div>
);
}
export default Counter;In this example, the Counter component manages a count state variable. When the button is clicked, the setCount function updates the state, and React re-renders the component with the updated count.
In class components, state is initialized in the constructor and updated with this.setState().
import React, { Component } from 'react';
class Counter extends Component {
constructor(props) {
super(props);
this.state = { count: 0 };
}
increment = () => {
this.setState({ count: this.state.count + 1 });
};
render() {
return (
<div>
<p>You clicked {this.state.count} times</p>
<button onClick={this.increment}>Click me</button>
</div>
);
}
}
export default Counter;In this class-based example, we manage the count state by initializing it in the constructor and updating it with this.setState.
Class components in React have a lifecycle, which consists of a series of methods that get called at different points in a component’s existence. These methods allow you to perform specific actions, such as fetching data or cleaning up resources.
componentDidMount(): Called once the component has been rendered to the screen.componentDidUpdate(): Called after the component’s updates are applied.componentWillUnmount(): Called just before the component is removed from the DOM.In functional components, lifecycle methods are handled with React Hooks, such as useEffect. This allows you to perform side effects (e.g., data fetching or subscriptions) in functional components.
useEffect
import React, { useState, useEffect } from 'react';
function FetchData() {
const [data, setData] = useState(null);
useEffect(() => {
fetch('https://api.example.com/data')
.then(response => response.json())
.then(data => setData(data));
}, []); // Empty dependency array means this effect runs only once, similar to componentDidMount
return <div>{data ? JSON.stringify(data) : 'Loading...'}</div>;
}
export default FetchData;In this example, the useEffect hook fetches data when the component mounts. This is similar to the componentDidMount method in class components.
A Higher-Order Component (HOC) is a function that takes a component and returns a new component with additional props or functionality. HOCs are useful for reusing component logic.
A render prop is a function prop that a component uses to know what to render. This pattern allows you to pass a function to a component, which gives it control over how to render the UI.
React components are the foundation of any React application. Understanding the different types of components, how to manage props and state, and how to utilize React’s lifecycle methods will make you a more effective React developer. While the React ecosystem continues to evolve, the principles of components, hooks, and JSX remain central to React development.
By breaking your app down into components and leveraging the power of React’s tools, you can create dynamic, scalable applications that are easy to maintain and extend.