Frontend Academy · Lezione

TypeScript con React: generics, hook e FC

Tipizzare i componenti React con props generiche, annotare useState e useRef con tipi espliciti e tipizzare gli hook personalizzati che restituiscono tuple

TypeScript con React: generics, hook e FC è una lezione Frontend Academy gratuita su CoddyKit. Questa è la lezione 3 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.

Tipizzare i componenti

In React moderno, tipizzi le props con un'interfaccia e usi una semplice funzione. React.FC esiste, ma non è più consigliato (aggiunge implicitamente children e non supporta i generics).

// Recommended:
interface ButtonProps {
  label: string;
  onClick: () => void;
  disabled?: boolean;
}

function Button({ label, onClick, disabled }: ButtonProps) {
  return <button onClick={onClick} disabled={disabled}>{label}</button>;
}

Tipizzare children

Utilizzi React.ReactNode per qualsiasi children renderizzabile.

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

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

Tipizzare useState

useState in genere deduce il tipo dal valore iniziale. Fornisca un tipo esplicito quando il valore iniziale è null o non rappresenta tutte le possibilità del tipo.

const [count, setCount] = useState(0);              // number
const [name, setName] = useState('');                // string

const [user, setUser] = useState<User | null>(null); // explicit
const [items, setItems] = useState<Item[]>([]);      // explicit array type

Tipizzare useRef

Esistono due forme: un ref a un elemento DOM (inizializzato a null) oppure un contenitore mutabile.

const inputRef = useRef<HTMLInputElement>(null);
const timerRef = useRef<number | null>(null);

useEffect(() => {
  inputRef.current?.focus();
  timerRef.current = window.setInterval(tick, 1000);
  return () => clearInterval(timerRef.current!);
}, []);

Tipizzare i gestori degli eventi

Utilizzi i tipi degli eventi sintetici di React.

function Form() {
  function onSubmit(e: React.FormEvent<HTMLFormElement>) {
    e.preventDefault();
  }
  function onChange(e: React.ChangeEvent<HTMLInputElement>) {
    setValue(e.target.value);
  }
  function onClick(e: React.MouseEvent<HTMLButtonElement>) {
    /* ... */
  }
  return <form onSubmit={onSubmit}>...</form>;
}

Componenti generici

I componenti possono essere generici: TypeScript deduce il parametro di tipo dal punto in cui il componente viene chiamato.

interface ListProps<T> {
  items: T[];
  renderItem: (item: T) => React.ReactNode;
  keyOf: (item: T) => string | number;
}

function List<T>({ items, renderItem, keyOf }: ListProps<T>) {
  return <ul>{items.map(i => <li key={keyOf(i)}>{renderItem(i)}</li>)}</ul>;
}

<List<User>
  items={users}
  renderItem={u => u.name}
  keyOf={u => u.id}
/>

Tipizzare gli hook personalizzati

Gli hook personalizzati sono funzioni: li tipizzi come qualsiasi altra funzione. Le tuple restituite richiedono un'annotazione esplicita per evitare l'ampliamento ad array.

function useToggle(initial = false): [boolean, () => void] {
  const [value, setValue] = useState(initial);
  const toggle = () => setValue(v => !v);
  return [value, toggle]; // tuple — annotation makes this stable
}

const [isOpen, toggle] = useToggle();

Tipizzare Context

createContext richiede un valore iniziale dello stesso tipo del valore che verrà fornito. Utilizzi un'asserzione non-null oppure un oggetto predefinito.

interface AuthContextValue {
  user: User | null;
  signIn: (email: string, pw: string) => Promise<void>;
  signOut: () => void;
}

const AuthContext = createContext<AuthContextValue | null>(null);

export function useAuth() {
  const ctx = useContext(AuthContext);
  if (!ctx) throw new Error('useAuth must be inside AuthProvider');
  return ctx;
}

Tipizzare useReducer

Specifichi esplicitamente il tipo dello stato e l'unione delle azioni.

type State = { count: number };
type Action =
  | { type: 'increment' }
  | { type: 'decrement' }
  | { type: 'set'; value: number };

function reducer(state: State, action: Action): State {
  switch (action.type) {
    case 'increment': return { count: state.count + 1 };
    case 'decrement': return { count: state.count - 1 };
    case 'set':       return { count: action.value };
  }
}

const [state, dispatch] = useReducer(reducer, { count: 0 });

Evitare React.FC

React.FC è ormai meno utilizzato: aggiunge implicitamente children, non supporta in modo efficace i componenti generici e ostacola alcune ottimizzazioni. Preferisca componenti funzione semplici con props tipizzate.

Utility type ComponentPropsWithoutRef

Per ereditare le props di un elemento nativo, ad esempio estendendo button o input, utilizzi ComponentPropsWithoutRef.

type ButtonProps = React.ComponentPropsWithoutRef<'button'> & {
  variant?: 'primary' | 'secondary';
};

function Button({ variant = 'primary', ...rest }: ButtonProps) {
  return <button className={`btn ${variant}`} {...rest} />;
}

Verifica rapida

Perché in genere è sconsigliato usare React.FC invece di semplici componenti funzione tipizzati?

Riepilogo: TypeScript + React

Tipizzi le props con le interfacce e preferisca le funzioni semplici a React.FC. children: React.ReactNode. Spesso useState deduce il tipo; aggiunga un'annotazione per null o per gli array vuoti. Usi useRef per gli elementi DOM. Utilizzi i tipi di eventi React per gli handler. Usi componenti generici per liste e moduli riutilizzabili. Il valore restituito sotto forma di tupla dagli hook personalizzati richiede un'annotazione. Utilizzi ComponentPropsWithoutRef per estendere gli elementi nativi.

Domande Frequenti

La lezione «TypeScript con React: generics, hook e FC» è gratuita?

Sì — il testo completo di «TypeScript con React: generics, hook e FC» è 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 «TypeScript con React: generics, hook e FC»?

Tipizzare i componenti React con props generiche, annotare useState e useRef con tipi espliciti e tipizzare gli hook personalizzati che restituiscono tuple 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 3 di 4.

Quanto tempo richiede la lezione «TypeScript con React: generics, hook e FC»?

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

Tipi di literal template
Decorator e metadati
TypeScript con React: generics, hook e FC
Strict Mode ed eliminazione di any

← Torna a Frontend Academy