React Js

React JS Tutorial Learn React JS, the powerful JavaScript library for building dynamic and interactive user interfaces. This beginner-friendly tutorial covers core concepts like components, state, props, and hooks, with hands-on projects to create responsive web apps. Perfect for aspiring developers looking to master modern front-end development.

React Props

24 April 2025 | Category:

Welcome to this beginner-friendly tutorial on React Props! Props (short for properties) are a fundamental concept in React, allowing you to pass data from a parent component to a child component to create dynamic and reusable UI elements. In this guide, you’ll learn what props are, how to use them, and best practices for handling them. We’ll apply these concepts by building a Restaurant Menu App that displays menu items and allows users to add new dishes. By the end, you’ll be confident using props to build modular React applications.

What are Props?

Props are read-only inputs passed to React components to customize their behavior or appearance. Think of props as arguments you send to a function: they allow components to render different data without changing their internal logic. Props are essential for creating reusable and flexible components.

Why Use Props?

  • Reusability: Use the same component with different data (e.g., a MenuItem component for various dishes).
  • Modularity: Pass data from parent to child components, keeping logic organized.
  • Dynamic Rendering: Display content based on external data, like user input or API responses.
  • Separation of Concerns: Keep components focused on rendering UI while parents handle data.

Prerequisites

Before starting, you should have:

  • Basic knowledge of React (components, JSX) and JavaScript (ES6).
  • Node.js and npm installed (download from nodejs.org).
  • A code editor like Visual Studio Code.
  • A terminal for running commands.

We’ll use Create React App to set up our project and Tailwind CSS for responsive styling, aligning with your preference for attractive, responsive designs.

Key Props Concepts

Let’s explore the core concepts for using props in React.

1. Passing Props

Props are passed to a component as attributes in JSX, similar to HTML attributes. The child component receives them as an object.

Example:

const MenuItem = (props) => {
  return <h2>{props.name}</h2>;
};

// Usage
<MenuItem name="Pizza" />

2. Destructuring Props

Destructuring props in the component’s parameter list makes the code cleaner and more readable.

Example:

const MenuItem = ({ name }) => {
  return <h2>{name}</h2>;
};

3. Default Props

Default props provide fallback values if a prop isn’t passed, preventing undefined errors.

Example:

const MenuItem = ({ name }) => {
  return <h2>{name}</h2>;
};

MenuItem.defaultProps = {
  name: 'Unknown Dish'
};

4. Prop Validation (Optional)

Use the PropTypes library to validate prop types, ensuring components receive the correct data. This is especially useful in larger apps.

Example:

import PropTypes from 'prop-types';

const MenuItem = ({ name }) => {
  return <h2>{name}</h2>;
};

MenuItem.propTypes = {
  name: PropTypes.string.isRequired
};

5. Passing Functions as Props

Props can include functions, allowing child components to trigger actions in the parent.

Example:

const Button = ({ onClick }) => {
  return <button onClick={onClick}>Click Me</button>;
};

6. Children Props

The special children prop allows you to pass content between a component’s opening and closing tags.

Example:

const Card = ({ children }) => {
  return <div className="card">{children}</div>;
};

// Usage
<Card><p>Hello!</p></Card>

Setting Up the Project

Let’s create a React app to build our Restaurant Menu App, which will use props to display and add menu items.

  1. Create a New React App:
    Open your terminal and run: npx create-react-app restaurant-menu cd restaurant-menu
  2. Install Tailwind CSS:
    Install and configure Tailwind CSS for responsive styling: npm install -D tailwindcss npx tailwindcss init Update tailwind.config.js: /** @type {import('tailwindcss').Config} */ module.exports = { content: ['./src/**/*.{js,jsx,ts,tsx}'], theme: { extend: {} }, plugins: [] }; Update src/index.css: @tailwind base; @tailwind components; @tailwind utilities; body { font-family: Arial, sans-serif; margin: 0; background-color: #f5f5f5; }
  3. Start the Development Server: npm start This opens your app at http://localhost:3000.
  4. Clean Up:
    Open src/App.js and replace its content with: const App = () => { return ( <div className="container mx-auto p-4"> <h1 className="text-3xl font-bold text-gray-800">Restaurant Menu</h1> </div> ); }; export default App; Delete src/App.css and src/logo.svg.

Building the Restaurant Menu App

Our Restaurant Menu App will:

  • Display a list of menu items using a MenuItem component, with props for name, price, and description.
  • Allow users to add new dishes via a MenuForm component, passing a callback function as a prop.
  • Use Tailwind CSS for a responsive, attractive design, based on your preference for visually appealing UI.

Step 1: Create the MenuItem Component

  1. In src, create a file named MenuItem.js:const MenuItem = ({ name, price, description }) => { return ( <div className="bg-white p-4 rounded-lg shadow-md mb-4 max-w-md"> <h3 className="text-xl font-semibold text-gray-800">{name}</h3> <p className="text-gray-600">${price.toFixed(2)}</p> <p className="text-gray-500 mt-2">{description}</p> </div> ); }; MenuItem.defaultProps = { name: 'Unknown Dish', price: 0, description: 'No description available' }; export default MenuItem;
    • Props Features:
      • Receives name, price, and description as props.
      • Destructures props for cleaner code ({ name, price, description }).
      • Sets default props to handle missing values.
      • Uses Tailwind CSS for responsive, modern styling.

Step 2: Create the MenuForm Component

  1. In src, create a file named MenuForm.js:const MenuForm = ({ onAddItem }) => { const [name, setName] = React.useState(''); const [price, setPrice] = React.useState(''); const [description, setDescription] = React.useState(''); const handleSubmit = (e) => { e.preventDefault(); if (name.trim() && price && description.trim()) { onAddItem({ name, price: parseFloat(price), description }); setName(''); setPrice(''); setDescription(''); } }; return ( <form onSubmit={handleSubmit} className="mb-6 max-w-md"> <div className="mb-4"> <input type="text" value={name} onChange={(e) => setName(e.target.value)} placeholder="Dish name" className="w-full p-2 border rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500" /> </div> <div className="mb-4"> <input type="number" step="0.01" value={price} onChange={(e) => setPrice(e.target.value)} placeholder="Price" className="w-full p-2 border rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500" /> </div> <div className="mb-4"> <textarea value={description} onChange={(e) => setDescription(e.target.value)} placeholder="Description" className="w-full p-2 border rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500" /> </div> <button type="submit" className="bg-green-500 text-white px-4 py-2 rounded-md hover:bg-green-600" > Add Dish </button> </form> ); }; export default MenuForm;
    • Props Features:
      • Receives onAddItem as a function prop to pass new dish data to the parent.
      • Uses state to manage form inputs, but relies on the parent for data storage.
      • Styled with Tailwind CSS for responsiveness and visual appeal.

Step 3: Update the App Component

  1. Update src/App.js to manage the menu items and compose components:import MenuItem from './MenuItem'; import MenuForm from './MenuForm'; const App = () => { const [items, setItems] = React.useState([ { name: 'Margherita Pizza', price: 12.99, description: 'Classic pizza with tomato, mozzarella, and basil.' }, { name: 'Grilled Salmon', price: 18.50, description: 'Fresh salmon fillet with lemon herb sauce.' } ]); const addItem = (newItem) => { setItems([...items, newItem]); }; return ( <div className="container mx-auto p-4"> <h1 className="text-3xl font-bold text-gray-800 mb-6">Restaurant Menu</h1> <MenuForm onAddItem={addItem} /> <div className="grid grid-cols-1 sm:grid-cols-2 gap-4"> {items.length > 0 ? ( items.map((item, index) => ( <MenuItem key={index} name={item.name} price={item.price} description={item.description} /> )) ) : ( <p className="text-gray-500">No menu items yet. Add one!</p> )} </div> </div> ); }; export default App;
    • Props Features:
      • Passes name, price, and description props to MenuItem for each item.
      • Passes onAddItem function prop to MenuForm to handle new items.
      • Uses map to render multiple MenuItem components dynamically.
      • Includes a responsive grid layout with Tailwind CSS, aligning with your interest in responsive design.

Step 4: Test the App

  • Save all files and ensure the development server is running (npm start).
  • Open http://localhost:3000. You should see:
    • Two initial menu items (“Margherita Pizza” and “Grilled Salmon”) displayed as cards.
    • A form to add new dishes with name, price, and description fields.
    • New dishes added to the menu when submitted, rendered as new MenuItem components.
  • Try adding a dish (e.g., “Chocolate Cake,” $6.99, “Rich chocolate layered cake.”) and verify it appears in the grid. Check responsiveness by resizing the browser or using mobile view in dev tools.

Understanding the Code

Let’s recap how props power our Restaurant Menu App:

  • Passing Props: App passes name, price, and description to MenuItem and onAddItem to MenuForm, enabling dynamic rendering and interaction.
  • Destructuring Props: MenuItem destructures { name, price, description } for cleaner code.
  • Default Props: MenuItem defines fallback values to handle missing props gracefully.
  • Function Props: MenuForm uses the onAddItem prop to communicate with App, adding new items to the state.
  • Responsive Design: Tailwind CSS ensures a grid layout that adapts to different screen sizes, aligning with your preference for responsive UI.
  • ES6 Features:
    • Arrow functions for components and handlers.
    • Destructuring in function parameters and state updates.
    • Spread operator to update state ([...items, newItem]).
    • Modules for organizing components.

Best Practices for Props

  • Keep Props Read-Only: Never modify props directly in a child component; use state or callbacks instead.
  • Use Descriptive Prop Names: Choose clear names like name or onAddItem to indicate purpose.
  • Set Default Props: Provide fallbacks for optional props to avoid errors:MenuItem.defaultProps = { price: 0 };
  • Validate Props (Optional): Use PropTypes for type checking in larger apps:MenuItem.propTypes = { price: PropTypes.number.isRequired };
  • Avoid Prop Drilling: If props are passed through multiple layers, consider using Context API for deeply nested components.
  • Use Children Sparingly: Only use children for content that needs flexibility, not for core data.

Common Props Pitfalls and Fixes

  • Undefined Props:
    Problem: Accessing a prop that wasn’t passed causes errors (e.g., props.name is undefined).
    Fix: Set default props or use conditional rendering:const MenuItem = ({ name = 'Unknown' }) => <h2>{name}</h2>;
  • Incorrect Prop Types:
    Problem: Passing a string when a number is expected (e.g., price="10" instead of price={10}).
    Fix: Use PropTypes or check types manually, and pass props correctly in JSX.
  • Overusing Props:
    Problem: Passing too many props makes components hard to maintain.
    Fix: Group related props into objects or use Context for shared data:<MenuItem data={{ name, price, description }} />
  • Callback Issues:
    Problem: Function props not triggering parent actions.
    Fix: Ensure the function is passed and called correctly:<MenuForm onAddItem={addItem} />

Props in Functional vs. Class Components

Since you’ve explored class components previously, here’s how props differ:

  • Functional Components: Props are received as a parameter and typically destructured:const MenuItem = ({ name }) => <h2>{name}</h2>;
  • Class Components: Props are accessed via this.props:class MenuItem extends React.Component { render() { return <h2>{this.props.name}</h2>; } }

Our app uses functional components, as they’re simpler and standard in React 19, but the props concept is identical.

What’s Next?

You’ve built a Restaurant Menu App using React props! Here are some next steps:

  • Add Features: Implement a button to remove menu items or filter by price.
  • Learn State Management: Explore useState and useReducer for more complex interactions.
  • Enhance Styling: Add hover effects or animations with Tailwind CSS or Framer Motion.
  • Build Another App: Create a product catalog or event planner to practice props.

Practice Challenge

Add an isAvailable prop to MenuItem to display a “Sold Out” badge if isAvailable is false. Pass this prop from App and update MenuForm to include a checkbox for availability.

Resources

Congratulations on mastering React props! You’re now equipped to build dynamic, reusable components with clean data flow. Keep practicing and happy coding!