TypeScript Academy · Lezione

Funzioni generiche: parametri di tipo

Aggiunga parametri di tipo alle funzioni per renderle riutilizzabili.

Funzioni generiche: parametri di tipo è 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.

Benvenuto

I generics consentono di scrivere funzioni che funzionano con qualsiasi tipo preservando la sicurezza dei tipi. Invece di usare `any`, si utilizza un parametro di tipo che viene risolto quando viene chiamata la funzione.

Il problema risolto dai generics

Una funzione che restituisce `any` perde le informazioni di tipo. I generics preservano la relazione tra i tipi di input e di output.

// Without generics — loses type info
function first(arr: any[]): any { return arr[0]; }

// With generics — type-safe
function first<T>(arr: T[]): T { return arr[0]; }

Sintassi dei parametri di tipo

Dichiari un parametro di tipo con le parentesi angolari `` prima dell'elenco dei parametri. Utilizzi T nei parametri e nel tipo restituito.

function identity<T>(value: T): T {
  return value;
}
const n = identity(42);       // T is number
const s = identity('hello');  // T is string

Inferenza dei tipi per le funzioni generiche

TypeScript deduce l'argomento di tipo dall'argomento effettivo. Raramente è necessario specificarlo in modo esplicito.

function wrap<T>(val: T): T[] { return [val]; }
const nums = wrap(42);    // T inferred as number -> number[]
const strs = wrap('hi');  // T inferred as string -> string[]

Più parametri di tipo

Le funzioni possono avere più parametri di tipo.

function pair<A, B>(a: A, b: B): [A, B] {
  return [a, b];
}
const p = pair(1, 'hello'); // [number, string]

Funzioni generiche per gli array

I generics sono essenziali per le funzioni di utilità degli array che funzionano con qualsiasi tipo di elemento.

function filterNull<T>(arr: (T | null)[]): T[] {
  return arr.filter((x): x is T => x !== null);
}

Argomenti di tipo espliciti

È possibile fornire esplicitamente gli argomenti di tipo quando TypeScript non riesce a dedurli.

function create<T>(): T | null { return null; }
const user = create<User>(); // T cannot be inferred — must be explicit

Generics e any

A differenza di `any`, i generics mantengono la relazione tra i tipi all'interno della funzione. Il tipo restituito è collegato al tipo di input.

function echo<T>(val: T): T { return val; }
const n: number = echo(42);   // OK
// const s: string = echo(42); // Error — T is number

Funzioni freccia generiche

Le funzioni freccia utilizzano la stessa sintassi, ma nei file .tsx richiedono una virgola per distinguerle dai tag JSX.

const identity = <T>(val: T): T => val;
// In .tsx files:
const identity2 = <T,>(val: T): T => val;

Restituire un tipo diverso

Le funzioni generiche possono utilizzare il parametro di tipo in modi trasformati.

function mapArray<T, U>(arr: T[], fn: (item: T) => U): U[] {
  return arr.map(fn);
}
const lengths = mapArray(['hello', 'world'], s => s.length);
// lengths: number[]

Parametri generici con valori predefiniti

Fornisca un tipo predefinito per un parametro di tipo per renderlo facoltativo.

function createList<T = string>(): T[] { return []; }
const list = createList(); // T defaults to string

Controllo rapido

Qual è il tipo restituito da `identity(42)`?

Riepilogo

Le funzioni generiche utilizzano parametri di tipo (T) per preservare le relazioni tra input e output. TypeScript deduce automaticamente gli argomenti di tipo. Utilizzi i generics invece di any per scrivere utility riutilizzabili e sicure dal punto di vista dei tipi.

Domande Frequenti

La lezione «Funzioni generiche: parametri di tipo» è gratuita?

Sì — il testo completo di «Funzioni generiche: parametri di tipo» è 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 «Funzioni generiche: parametri di tipo»?

Aggiunga parametri di tipo alle funzioni per renderle riutilizzabili. 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 «Funzioni generiche: parametri di tipo»?

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