Next.js 15 Fullstack Web Apps · Pelajaran

Props dan Komunikasi Antarkomponen

Kuasai cara meneruskan data antara komponen induk dan anak menggunakan props untuk membangun antarmuka pengguna yang fleksibel.

Pelajaran 3 dari 410 langkah

Props dan Komunikasi Antarkomponen adalah pelajaran Next.js 15 Fullstack Web Apps gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Next.js 15 Fullstack Web Apps, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Next.js 15 Fullstack Web Apps mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

Intro to Component Props

In React, props (short for properties) are how you pass data from a parent component down to a child component.

Think of them like arguments to a function. They allow you to make your components reusable and dynamic, displaying different information based on the data they receive.

Unidirectional Data Flow

One of the core principles of React is unidirectional data flow. This means data always moves in one direction: from parent to child.

Parent components own and manage data.
They pass this data down to their children using props.
Child components receive props and render content based on them.
Children cannot directly modify the props they receive; props are read-only.

Your First Prop

Let's see how to pass a simple string prop. We'll create a Greeting component that receives a name prop.

Notice how App (parent) passes name="Alice" to Greeting (child).

import React from 'react';
import ReactDOM from 'react-dom/client';

// Child Component
function Greeting(props) {
  // Access the 'name' prop using props.name
  return <p>Hello, {props.name}!</p>;
}

// Parent Component
function App() {
  return (
    <div>
      <Greeting name="Alice" />
      <Greeting name="Bob" />
    </div>
  );
}

// Render the App component
const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(<App />);

Passing Different Data Types

Props aren't just for strings! You can pass numbers, booleans, arrays, and objects. When passing non-string values, wrap them in curly braces {}.

This example shows a ProductCard receiving various data types.

import React from 'react';
import ReactDOM from 'react-dom/client';

function ProductCard(props) {
  return (
    <div style={{ border: '1px solid gray', padding: '10px', margin: '10px' }}>
      <h3>{props.productName}</h3>
      <p>Price: ${props.price.toFixed(2)}</p>
      <p>In Stock: {props.inStock ? 'Yes' : 'No'}</p>
      <p>Features:</p>
      <ul>
        {props.features.map((feature, index) => (
          <li key={index}>{feature}</li>
        ))}
      </ul>
    </div>
  );
}

function App() {
  const laptop = {
    name: "Super Laptop",
    price: 1200.50,
    available: true,
    specs: ["Fast CPU", "16GB RAM", "512GB SSD"]
  };

  return (
    <div>
      <ProductCard
        productName={laptop.name}
        price={laptop.price}
        inStock={laptop.available}
        features={laptop.specs}
      />
    </div>
  );
}

const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(<App />);

Destructuring Props for Clarity

Accessing props like props.name can get repetitive. A cleaner way is to use object destructuring directly in your component's function signature.

This makes your code more readable by explicitly showing which props a component expects.

import React from 'react';
import ReactDOM from 'react-dom/client';

// Before: function Greeting(props) { return <p>Hello, {props.name}!</p>; }
// After destructuring:
function Greeting({ name }) {
  return <p>Hello, {name}!</p>;
}

function App() {
  return (
    <div>
      <Greeting name="Charlie" />
    </div>
  );
}

const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(<App />);

The Special 'children' Prop

React has a special prop called children. This prop automatically contains whatever content you pass between a component's opening and closing tags.

It's perfect for creating wrapper components like cards, layouts, or modals.

import React from 'react';
import ReactDOM from 'react-dom/client';

function Card({ title, children }) {
  return (
    <div style={{ border: '1px solid #ddd', padding: '15px', margin: '10px', borderRadius: '8px' }}>
      <h4>{title}</h4>
      <div style={{ marginTop: '10px' }}>
        {children}
      </div>
    </div>
  );
}

function App() {
  return (
    <div>
      <Card title="User Profile">
        <p>Name: <b>Jane Doe</b></p>
        <p>Email: jane@example.com</p>
        <button>Edit Profile</button>
      </Card>
    </div>
  );
}

const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(<App />);

Child to Parent: Callback Props

Since data flows down, how does a child component tell its parent something happened (e.g., a button was clicked)? You pass a function as a prop!

The child calls this function, and the parent can then react to the event. This is often called a 'callback prop'.

import React from 'react';
import ReactDOM from 'react-dom/client';

// Child Component
function MyButton({ onClick, label }) {
  return (
    <button onClick={onClick}>
      {label}
    </button>
  );
}

// Parent Component
function App() {
  const handleButtonClick = () => {
    alert("Button clicked inside the child component!");
  };

  return (
    <div>
      <p>Parent says: Click the button below!</p>
      <MyButton onClick={handleButtonClick} label="Trigger Parent" />
    </div>
  );
}

const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(<App />);

When Props Aren't Enough

While props are powerful, passing them through many layers of nested components can become cumbersome. This is known as prop drilling.

If you find yourself passing the same prop through 3+ components just to reach a deeply nested child, it might be a sign to consider other patterns like React Context API or state management libraries (which we'll cover in future lessons!).

Prop Challenge

Which of the following statements about React props are true?

Jawab di pelajaran interaktif

Recap: Props, Your UI's Data

You've mastered props, a fundamental concept in React!

Props pass data from parent to child components.
Data flow is unidirectional; children cannot modify props.
You can pass various data types (strings, numbers, objects, functions).
Destructuring props makes your code cleaner.
The children prop allows flexible content embedding.
Callback props enable child-to-parent communication.

Props are the backbone of building dynamic and reusable React components. Keep practicing, and you'll be building complex UIs in no time!

Gratis untuk memulai

Belajar TypeScript dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 12
Pelajaran: 48

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Props dan Komunikasi Antarkomponen” gratis?

Ya — teks lengkap “Props dan Komunikasi Antarkomponen” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Next.js 15 Fullstack Web Apps, upgrade ke CoddyKit PRO. Kursus Next.js 15 Fullstack Web Apps mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Props dan Komunikasi Antarkomponen”?

Kuasai cara meneruskan data antara komponen induk dan anak menggunakan props untuk membangun antarmuka pengguna yang fleksibel. Kamu berlatih Next.js 15 Fullstack Web Apps dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Next.js 15 Fullstack Web Apps?

Tidak diperlukan pengalaman sebelumnya. Next.js 15 Fullstack Web Apps di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Props dan Komunikasi Antarkomponen” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Next.js 15 Fullstack Web Apps ini?

Ya. Setiap pelajaran Next.js 15 Fullstack Web Apps menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Komponen React dan JSX
Pengelolaan State dengan Hook
Props dan Komunikasi Antarkomponen
Merender Daftar, Key, dan UI Kondisional

← Kembali ke Next.js 15 Fullstack Web Apps