Frontend Academy · Lezione

Componenti funzionali e props

Creare componenti come funzioni, accettare e destrutturare le props e usare PropTypes o i tipi TypeScript per documentare la struttura dei dati prevista.

Componenti funzionali e props è una lezione Frontend Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Frontend Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Frontend Academy include 4 lezioni in totale.

Che cos'è un componente React?

Un componente React è una funzione JavaScript che restituisce JSX. I componenti sono gli elementi costitutivi delle applicazioni React: parti dell'interfaccia utente riutilizzabili e componibili.

function Welcome() {
  return <h1>Welcome to CoddyKit!</h1>;
}

// Arrow function style:
const Welcome = () => <h1>Welcome to CoddyKit!</h1>;

Props — Passaggio dei dati verso il basso

Le props (proprietà) consentono di passare dati dal componente padre a quello figlio. Il componente le riceve come primo argomento, sotto forma di semplice oggetto.

function Greeting({ name, role }: { name: string; role: string }) {
  return <p>Hello, {name}! Your role is {role}.</p>;
}

// Usage:
<Greeting name="Alice" role="admin" />

Interfaccia TypeScript per le props

Definisca un'interfaccia con nome per le props, così da ottenere completamento automatico, verifica dei tipi e documentazione.

interface ButtonProps {
  label: string;
  onClick: () => void;
  disabled?: boolean;
  variant?: 'primary' | 'secondary' | 'ghost';
}

function Button({ label, onClick, disabled = false, variant = 'primary' }: ButtonProps) {
  return (
    <button
      onClick={onClick}
      disabled={disabled}
      className={`btn btn-${variant}`}
    >
      {label}
    </button>
  );
}

Prop children

La prop children contiene il contenuto compreso tra i tag di apertura e chiusura del componente. La tipizzi come React.ReactNode per accettare qualsiasi contenuto visualizzabile.

interface CardProps {
  title: string;
  children: React.ReactNode;
}

function Card({ title, children }: CardProps) {
  return (
    <div className="card">
      <h2>{title}</h2>
      <div className="card-body">{children}</div>
    </div>
  );
}

// Usage:
<Card title="Hello">
  <p>Card content goes here.</p>
</Card>

Props predefinite con la destrutturazione

Imposti i valori predefiniti direttamente nel pattern di destrutturazione. Questo è l'approccio moderno: l'API defaultProps, ormai deprecata, non è più consigliata.

function Alert({ type = 'info', message, onClose }: AlertProps) {
  return (
    <div className={`alert alert-${type}`}>
      <span>{message}</span>
      <button onClick={onClose}>×</button>
    </div>
  );
}

Composizione dei componenti

I componenti si compongono: una Page utilizza un Layout, che utilizza a sua volta Nav e Sidebar, ognuno dei quali utilizza atomi più piccoli come Button e Icon. Questo albero di componenti è l'albero dei componenti React.

Convenzioni di denominazione

I nomi dei componenti devono iniziare con una lettera maiuscola. I nomi in minuscolo vengono trattati come elementi HTML. <div> è un div HTML; <Div> è un componente React denominato Div.

Componenti puri

Un componente è puro se le stesse props producono sempre lo stesso output e durante il rendering non si verificano effetti collaterali. I componenti puri sono più facili da comprendere e ottimizzare.

// Pure:
const Greeting = ({ name }: { name: string }) => <h1>Hi, {name}</h1>;

// Impure (side effect in render):
const Bad = ({ id }: { id: string }) => {
  localStorage.setItem('id', id); // SIDE EFFECT in render — avoid
  return <p>{id}</p>;
};

Passaggio di funzioni come props

Le funzioni (callback) vengono passate come props per consentire ai componenti figli di comunicare verso l'alto con i componenti genitori. Il genitore definisce la funzione; il figlio la chiama.

function TodoItem({ text, onDelete }: { text: string; onDelete: () => void }) {
  return (
    <li>
      {text}
      <button onClick={onDelete}>Delete</button>
    </li>
  );
}

Prop spreading

L'operatore spread passa tutte le props da un oggetto a un componente. È utile per i componenti wrapper o pass-through, ma va usato con cautela: potrebbero essere passate props impreviste.

function InputWrapper(props: React.InputHTMLAttributes<HTMLInputElement>) {
  return <input {...props} className={`input-base ${props.className || ''}`} />;
}

Fragment e key nel contesto delle props

Quando si visualizza un elenco di componenti come figli, ognuno deve avere una prop key univoca. Le key aiutano React a identificare gli elementi che sono cambiati, sono stati aggiunti o sono stati rimossi.

Verifica rapida

Come si fornisce un valore predefinito per una prop in un moderno componente funzione React?

Riepilogo: componenti e props

I componenti funzionali sono funzioni JavaScript che restituiscono JSX. Le props passano dati dal genitore al figlio. Utilizzi interfacce TypeScript per i tipi delle props. children: React.ReactNode per il contenuto dello slot. Valori predefiniti nella destrutturazione. Passi le callback come props per la comunicazione dal figlio al genitore. I nomi iniziano con lettere maiuscole.

Domande Frequenti

La lezione «Componenti funzionali e props» è gratuita?

Sì — il testo completo di «Componenti funzionali e props» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Frontend Academy, passa a CoddyKit PRO. Il corso Frontend Academy include 4 lezioni in totale.

Cosa imparerò in «Componenti funzionali e props»?

Creare componenti come funzioni, accettare e destrutturare le props e usare PropTypes o i tipi TypeScript per documentare la struttura dei dati prevista. Eserciti Frontend Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Frontend Academy?

Non è richiesta alcuna esperienza precedente. Frontend Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Componenti funzionali e props»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Frontend Academy?

Sì. Ogni lezione Frontend Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Frontend Academy