TypeScript Academy · Lezione

Definizioni di tipi ricorsivi

Scriva in sicurezza tipi che fanno riferimento a sé stessi.

Definizioni di tipi ricorsivi è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 1 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 TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 4 lezioni in totale.

Che cos'è un tipo ricorsivo?

Un tipo ricorsivo è un tipo che fa riferimento a sé stesso nella propria definizione. Questo permette di descrivere strutture dati di profondità illimitata.

type LinkedList<T> = {
  value: T;
  next: LinkedList<T> | null;
};
// next is the same type again, ending at null.

Il tipo di una lista concatenata

L'esempio classico: ogni nodo contiene un value e un puntatore next a un altro nodo, oppure null per terminare la catena.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const list: LinkedList<number> = {
  value: 1,
  next: { value: 2, next: null }
};
console.log(list.value, list.next?.value);

Il caso base è importante

Ogni tipo ricorsivo ha bisogno di un terminatore, in questo caso null, affinché la ricorsione possa terminare. Senza di esso, il tipo avrebbe profondità infinita.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const single: LinkedList<string> = { value: "only", next: null };
console.log(single.next);

Costruire catene più lunghe

È possibile annidare gli elementi a qualsiasi profondità: il tipo ammette liste di qualunque lunghezza perché next è a sua volta una lista oppure null.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const chain: LinkedList<number> = {
  value: 10,
  next: { value: 20, next: { value: 30, next: null } }
};
console.log(chain.next?.next?.value);

Attraversare una lista concatenata

Una funzione può percorrere la catena seguendo next fino a raggiungere null. Il tipo ricorsivo rende l'operazione completamente sicura dal punto di vista dei tipi.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function toArray<T>(list: LinkedList<T> | null): T[] {
  const out: T[] = [];
  let cur = list;
  while (cur) { out.push(cur.value); cur = cur.next; }
  return out;
}
const l: LinkedList<number> = { value: 1, next: { value: 2, next: null } };
console.log(toArray(l));

Funzioni ricorsive su tipi ricorsivi

I tipi ricorsivi si combinano naturalmente con le funzioni ricorsive. Qui si calcola la lunghezza ricorrendo su next.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function length<T>(list: LinkedList<T> | null): number {
  return list === null ? 0 : 1 + length(list.next);
}
const l: LinkedList<string> = { value: "a", next: { value: "b", next: null } };
console.log(length(l));

Inserire un elemento all'inizio di una lista

Poiché il tipo è uniforme, creare nuove liste è semplice: basta inserire una lista esistente come next di un nuovo nodo iniziale.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function prepend<T>(value: T, list: LinkedList<T> | null): LinkedList<T> {
  return { value, next: list };
}
const l = prepend(1, prepend(2, null));
console.log(l.value, l.next?.value);

Terminatori facoltativi o nullable

È possibile terminare con null oppure rendere facoltativo next. Entrambe le opzioni terminano la ricorsione: scelga in base al modo in cui desidera rappresentare la fine.

type ListA<T> = { value: T; next: ListA<T> | null };
type ListB<T> = { value: T; next?: ListB<T> };
const a: ListA<number> = { value: 1, next: null };
const b: ListB<number> = { value: 1 };
console.log(a.value, b.value);

I tipi ricorsivi sono valutati in modo lazy

TypeScript espande un tipo ricorsivo solo fino al livello effettivamente utilizzato. La definizione può riferirsi a sé stessa senza causare un'elaborazione infinita.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
// Using two levels only expands two levels.
const l: LinkedList<number> = { value: 1, next: { value: 2, next: null } };
console.log(l.next?.value);

Applicare una trasformazione a una lista

Una funzione map ricorsiva trasforma ogni valore preservando la struttura e restituisce una nuova lista con la stessa forma.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function mapList<T, U>(list: LinkedList<T> | null, fn: (v: T) => U): LinkedList<U> | null {
  if (list === null) return null;
  return { value: fn(list.value), next: mapList(list.next, fn) };
}
const l: LinkedList<number> = { value: 1, next: { value: 2, next: null } };
console.log(mapList(l, x => x * 10)?.value);

Perché i tipi ricorsivi sono potenti

I tipi autoreferenziali permettono di modellare dati annidati a piacere, liste, alberi e JSON, con piena sicurezza dei tipi e senza un limite fisso di profondità nella progettazione.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const l: LinkedList<boolean> = { value: true, next: { value: false, next: null } };
console.log(l.value, l.next?.value);

Verifica rapida: tipi ricorsivi

Verifichi di aver compreso le definizioni dei tipi ricorsivi.

Riepilogo: definizioni di tipi ricorsivi

Ha imparato che un tipo ricorsivo fa riferimento a sé stesso, ha bisogno di un caso base come null per terminare e si combina naturalmente con funzioni ricorsive per attraversare, trasformare e costruire liste concatenate.

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const l: LinkedList<number> = { value: 1, next: null };
console.log(l.value);

Domande Frequenti

La lezione «Definizioni di tipi ricorsivi» è gratuita?

Sì — il testo completo di «Definizioni di tipi ricorsivi» è 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 TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 4 lezioni in totale.

Cosa imparerò in «Definizioni di tipi ricorsivi»?

Scriva in sicurezza tipi che fanno riferimento a sé stessi. Eserciti TypeScript 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 TypeScript Academy?

Non è richiesta alcuna esperienza precedente. TypeScript 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 1 di 4.

Quanto tempo richiede la lezione «Definizioni di tipi ricorsivi»?

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 TypeScript Academy?

Sì. Ogni lezione TypeScript 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 TypeScript Academy