TypeScript Academy · Lezione

I tipi come linguaggio di calcolo

Comprenda il sistema dei tipi come linguaggio funzionale puro.

I tipi come linguaggio di calcolo è 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.

I tipi sono un linguaggio

TypeScript contiene due linguaggi affiancati. Uno è JavaScript a livello dei valori, che già conosce. L'altro è il livello dei tipi, che viene eseguito interamente in fase di compilazione. In questo corso imparerà a programmare in quel secondo linguaggio.

Il sistema dei tipi è un piccolo linguaggio funzionale e puro. Gli si forniscono tipi in ingresso e calcola tipi in uscita. Nulla di tutto questo sopravvive al runtime.

type Greeting = "hello";
type Loud = Uppercase<Greeting>;
// Loud is "HELLO" - computed by the type system

Tipi in ingresso, tipi in uscita

Un tipo generico è essenzialmente una funzione da tipi a tipi. Il parametro di tipo è l'argomento e il corpo è il valore restituito.

Di seguito, Boxed riceve un tipo T e produce un tipo oggetto che lo incapsula. Pensi a T come a un parametro che si passa alla funzione.

type Boxed<T> = { value: T };

type A = Boxed<number>; // { value: number }
type B = Boxed<string>; // { value: string }

I generics sono funzioni

Confronti una funzione a livello dei valori con una a livello dei tipi. Le strutture sono quasi identiche: parametri in ingresso e un unico risultato in uscita.

Valore: const id = (x) => x
Tipo: type Id<T> = T

Id a livello dei tipi restituisce semplicemente qualunque valore gli venga fornito.

type Id<T> = T;

type X = Id<boolean>; // boolean
type Y = Id<"abc">;  // "abc"

Nessun costo a runtime

Tutto ciò che appartiene al livello dei tipi viene eliminato prima dell'esecuzione del codice. L'output JavaScript non contiene alcuna traccia dei calcoli sui tipi. Il programma in esecuzione non subisce alcun costo in termini di prestazioni, indipendentemente dalla complessità dei tipi.

Per questo la programmazione a livello dei tipi viene talvolta chiamata gratuita: influisce solo sul compilatore, mai sul bundle.

type Pair<T> = [T, T];
const p: Pair<number> = [1, 2];
// Compiled JS is just: const p = [1, 2];
console.log(p);

Più parametri

Le funzioni a livello dei tipi possono ricevere diversi parametri, proprio come le funzioni normali. In questo caso Merge riceve due tipi oggetto e li combina.

Lo si può leggere così: dati A e B, restituisci un oggetto che possiede tutte le proprietà di entrambi.

type Merge<A, B> = A & B;

type User = { id: number };
type Named = { name: string };
type NamedUser = Merge<User, Named>;
// { id: number; name: string }

Valori predefiniti dei parametri

I parametri di tipo possono avere valori predefiniti, proprio come gli argomenti predefiniti delle funzioni. Se chi effettua la chiamata omette l'argomento, viene usato il valore predefinito.

type List<T = string> = T[];

type A = List;        // string[]
type B = List<number>; // number[]

I vincoli sono controlli

Un vincolo con extends limita i tipi che possono essere passati. È l'equivalente a livello di tipo della convalida di un argomento di funzione prima di utilizzarlo.

HasId accetta solo tipi che hanno già una proprietà id, quindi il corpo può leggerla in sicurezza.

type GetId<T extends { id: number }> = T["id"];

type A = GetId<{ id: number; name: string }>; // number
// GetId<{ name: string }> would be a compile error

Calcolo, non solo annotazione

I principianti usano i tipi solo per etichettare i valori. La programmazione a livello di tipo usa i tipi per calcolare risultati. L'utility integrata ReturnType, ad esempio, analizza un tipo funzione ed estrae il tipo del risultato.

type Fn = (a: number) => string;
type R = ReturnType<Fn>; // string

type Fn2 = () => boolean;
type R2 = ReturnType<Fn2>; // boolean

Mappatura delle proprietà

I tipi mappati consentono di trasformare ogni proprietà di un tipo oggetto. È un ciclo nel linguaggio dei tipi. Stringify trasforma ogni tipo di valore in string.

type Stringify<T> = { [K in keyof T]: string };

type Input = { a: number; b: boolean };
type Out = Stringify<Input>; // { a: string; b: string }

Puro e deterministico

Il linguaggio dei tipi è puro: gli stessi input producono sempre lo stesso tipo di output, senza effetti collaterali. Non ci sono mutazioni, operazioni di I/O o riferimenti al tempo. Questa purezza rende i programmi a livello di tipo prevedibili e componibili.

Grazie alla purezza, si ragiona sui tipi come sulla matematica: per sostituzione.

type Square<T extends { area: number }> = T["area"];
// Always the same result for the same input shape

Perché è importante

Padroneggiare questo secondo linguaggio consente di codificare regole che il compilatore applica automaticamente: route valide, switch esaustivi, manipolazione sicura delle stringhe e API che non possono essere usate in modo errato. Il resto del corso costruisce questa cassetta degli attrezzi.

Idea chiave: un tipo è un valore nel linguaggio dei tipi e un generico è una funzione.

type NonEmpty<T extends unknown[]> =
  T extends [unknown, ...unknown[]] ? T : never;
// Encodes a rule: the tuple must have at least one element

Verifica rapida

Metta alla prova la Sua comprensione dei tipi come linguaggio di calcolo.

Riepilogo

Ha imparato che i tipi TypeScript formano un linguaggio funzionale puro che viene eseguito in fase di compilazione.

I generics sono funzioni: ricevono tipi e restituiscono tipi.
I parametri supportano valori predefiniti e vincoli extends.
I tipi mappati eseguono un ciclo sulle proprietà.
Tutto viene rimosso, quindi non c'è alcun costo a runtime.

Successivamente, aggiungerà a questo linguaggio un if: i tipi condizionali.

Domande Frequenti

La lezione «I tipi come linguaggio di calcolo» è gratuita?

Sì — il testo completo di «I tipi come linguaggio di calcolo» è 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 «I tipi come linguaggio di calcolo»?

Comprenda il sistema dei tipi come linguaggio funzionale puro. 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 «I tipi come linguaggio di calcolo»?

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