TypeScript Academy · Lezione

Tipizzare le funzioni variadiche

Costruisca API flessibili con tipi tupla variadici.

Tipizzare le funzioni variadiche è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 4 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.

Funzioni generiche variadiche

I tipi tupla variadici consentono ai generics di acquisire e manipolare le liste di argomenti. In questo modo è possibile creare utility che concatenano tuple, inoltrano parametri e rimodellano le firme delle chiamate con piena sicurezza dei tipi.

Acquisizione degli argomenti come tupla

Un generic vincolato a unknown[] può acquisire un'intera lista di argomenti come tipo tupla T, mantenendo il tipo e la posizione di ogni parametro.

function tuple<T extends unknown[]>(...args: T): T {
  return args
}
const t = tuple("a", 1, true) // type [string, number, boolean]
console.log(t)

Applicazione di spread a una tupla generica

È possibile applicare spread a una tupla generica acquisita all'interno di un'altra lista di parametri. In questo modo gli argomenti vengono inoltrati mantenendo i tipi esatti.

function wrap<T extends unknown[]>(fn: (...args: T) => void) {
  return (...args: T) => fn(...args)
}
const log = wrap((n: number, s: string) => console.log(n, s))
log(1, "hi")

Concatenazione di due tuple

I tipi tupla variadici mostrano il loro potenziale quando si combinano tuple. Applicare spread a due tuple generiche nel tipo restituito produce la loro concatenazione.

function concat<A extends unknown[], B extends unknown[]>(a: A, b: B): [...A, ...B] {
  return [...a, ...b]
}
const r = concat([1, 2], ["a"]) // [number, number, string]
console.log(r)

Perché il tipo risultante è preciso

Poiché [...A, ...B] applica spread alle tuple generiche, il risultato mantiene il tipo e l'ordine di ogni elemento, invece di essere soltanto un array con un tipo unione ampliato.

function concat<A extends unknown[], B extends unknown[]>(a: A, b: B): [...A, ...B] {
  return [...a, ...b]
}
const r = concat([true], [42])
const flag: boolean = r[0]
const num: number = r[1]
console.log(flag, num)

Aggiunta di un argomento all'inizio

Le tuple variadiche consentono di rimodellare le liste di parametri, ad esempio per una funzione che aggiunge un argomento iniziale alla firma di una callback.

function withId<T extends unknown[]>(fn: (...args: T) => void) {
  return (id: number, ...rest: T) => {
    console.log("id", id)
    fn(...rest)
  }
}
const f = withId((msg: string) => console.log(msg))
f(7, "hello")

Estrazione del tipo della testa

Con un parametro tupla è possibile separare il tipo del primo elemento dal resto usando una tupla con etichette, per poi operare su ciascuna parte.

function head<H, T extends unknown[]>(...args: [H, ...T]): H {
  return args[0]
}
const h = head("first", 2, 3) // type string
console.log(h)

Tipo utility Parameters

Il tipo incorporato Parameters<F> estrae la lista degli argomenti di una funzione come tupla, basandosi a sua volta sui tipi tupla variadici. È possibile riutilizzare altrove i parametri di una firma.

function greet(name: string, age: number) {}
type GreetArgs = Parameters<typeof greet> // [string, number]
const args: GreetArgs = ["Ada", 36]
console.log(args)

Inoltro con Parameters

È possibile combinare Parameters con uno spread rest per creare un wrapper che inoltra gli argomenti a una funzione esistente mantenendo una tipizzazione identica.

function add(a: number, b: number) { return a + b }
function traced(...args: Parameters<typeof add>): number {
  console.log("calling add", args)
  return add(...args)
}
console.log(traced(2, 3))

Creazione di una firma simile al currying

Le tuple variadiche consentono di creare utility per l'applicazione parziale: alcuni argomenti vengono acquisiti subito, mentre i restanti vengono richiesti in seguito, con verifica completa dei tipi.

function partial<A extends unknown[], B extends unknown[], R>(
  fn: (...args: [...A, ...B]) => R,
  ...a: A
) {
  return (...b: B) => fn(...a, ...b)
}
const addThree = (x: number, y: number, z: number) => x + y + z
const add5 = partial(addThree, 5)
console.log(add5(2, 3)) // 10

Potenza e cautela

I generics con tuple variadiche offrono strumenti precisi e riutilizzabili per modellare le funzioni: wrapper, inoltri e concatenazioni. Sono funzionalità avanzate, quindi è opportuno utilizzarle quando la precisione dei tipi offre un vantaggio concreto.

function pipe2<A extends unknown[], B, C>(
  f: (...a: A) => B,
  g: (b: B) => C
) {
  return (...a: A) => g(f(...a))
}
const fn = pipe2((n: number) => n * 2, (n) => n + 1)
console.log(fn(5)) // 11

Verifica rapida

Verifichi la comprensione dei generics con tuple variadiche.

Riepilogo

I tipi tupla variadici consentono ai generics di acquisire le liste di argomenti come tuple e di applicare loro spread nelle posizioni dei parametri o del valore restituito. Questo permette di concatenare tuple ([...A, ...B]), inoltrare argomenti, separare testa e coda e realizzare l'applicazione parziale, mantenendo sempre i tipi esatti degli elementi. Anche i tipi incorporati come Parameters<F> si basano sullo stesso meccanismo. Utilizzi questi strumenti quando vale la pena affrontare la loro complessità per ottenere una tipizzazione precisa della struttura delle funzioni.

Domande Frequenti

La lezione «Tipizzare le funzioni variadiche» è gratuita?

Sì — il testo completo di «Tipizzare le funzioni variadiche» è 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 «Tipizzare le funzioni variadiche»?

Costruisca API flessibili con tipi tupla variadici. 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 4 di 4.

Quanto tempo richiede la lezione «Tipizzare le funzioni variadiche»?

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