Contare con la lunghezza delle tuple
Rappresenti i numeri come lunghezze di tuple nei tipi.
Contare con la lunghezza delle tuple è 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 numeri hanno bisogno di una rappresentazione
Il sistema dei tipi non può sommare direttamente i letterali numerici. La soluzione classica consiste nel rappresentare un numero N come una tupla con N elementi. Il contenuto non è importante; conta solo la lunghezza.
type Three = [unknown, unknown, unknown];
type N = Three["length"]; // 3Lettura della lunghezza
Ogni tipo tupla ha una proprietà length che è un tipo letterale numerico. L'indicizzazione con ["length"] la restituisce come un numero utilizzabile.
type A = [1, 2, 3, 4]["length"]; // 4
type B = []["length"]; // 0
type C = ["x"]["length"]; // 1Perché usare unknown come riempitivo
Usiamo unknown come tipo degli elementi perché i valori sono irrilevanti: conta solo il numero di elementi. Va bene qualsiasi tipo, ma unknown comunica chiaramente l'idea di "segnaposto".
type Two = [unknown, unknown];
type N = Two["length"]; // 2Costruire una tupla di lunghezza N
Per procedere nella direzione opposta, costruisca una tupla della lunghezza desiderata usando la ricorsione. Aggiunga elementi finché la lunghezza non corrisponde a N, quindi restituisca la tupla. Questo è il famoso helper BuildTuple.
type BuildTuple<N extends number, Acc extends unknown[] = []> =
Acc["length"] extends N ? Acc : BuildTuple<N, [...Acc, unknown]>;
type A = BuildTuple<3>; // [unknown, unknown, unknown]Come funziona il ciclo di BuildTuple
Seguiamo BuildTuple<3>:
- Lunghezza di Acc 0, non è 3: aggiunga un elemento
- Lunghezza di Acc 1, non è 3: aggiunga un elemento
- Lunghezza di Acc 2, non è 3: aggiunga un elemento
- Lunghezza di Acc 3, è uguale a 3: restituisca la tupla
La lunghezza dell'accumulatore è il contatore del ciclo.
type A = BuildTuple<2>; // [unknown, unknown]La lunghezza è il ponte
Due operazioni permettono di passare dai numeri alle tuple e viceversa:
- Da numero a tupla:
BuildTuple<N> - Da tupla a numero:
T["length"]
Tutta l'aritmetica sui tipi si basa sull'attraversamento di questo ponte.
type FromN = BuildTuple<4>; // tuple of length 4
type BackToN = FromN["length"]; // 4Confrontare in base alla lunghezza
Poiché la lunghezza di una tupla è un letterale, è possibile verificare l'uguaglianza tra quantità. Costruisca le tuple e confronti le loro lunghezze tramite l'assegnabilità.
type SameLength<A extends unknown[], B extends unknown[]> =
A["length"] extends B["length"] ? true : false;
type X = SameLength<[1, 2], ["a", "b"]>; // true
type Y = SameLength<[1], ["a", "b"]>; // falseUn contatore generico della lunghezza
È possibile reimplementare length tramite la ricorsione per comprenderne il funzionamento, anche se leggere ["length"] è più veloce. Questo dimostra che contare significa semplicemente percorrere una tupla.
type Len<T extends unknown[], Acc extends unknown[] = []> =
T extends [unknown, ...infer R]
? Len<R, [...Acc, unknown]>
: Acc["length"];
type A = Len<["a", "b", "c"]>; // 3Le tuple come contatori
Consideri la tupla come una tacca: ogni elemento corrisponde a un segno. Aggiungere un elemento incrementa il conteggio; rimuoverne uno lo decrementa. Questo modello mentale rende l'aritmetica intuitiva.
type Inc<N extends number> = [...BuildTuple<N>, unknown]["length"];
type A = Inc<3>; // 4Anteprima del decremento
Il decremento costruisce la tupla per N, quindi deduce tutto tranne l'ultimo elemento e legge la lunghezza più corta. Formalizzerà questo procedimento nella lezione successiva.
type Dec<N extends number> =
BuildTuple<N> extends [unknown, ...infer R] ? R["length"] : 0;
type A = Dec<3>; // 2
type B = Dec<0>; // 0Limiti da ricordare
Questa tecnica funziona per interi non negativi piccoli. Un valore N molto grande raggiunge i limiti della ricorsione e non esiste alcun supporto integrato per numeri negativi o decimali. Entro questi limiti, la tecnica è affidabile e completamente statica.
type A = BuildTuple<5>["length"]; // 5 (fine)
// BuildTuple<10000> would error: too deepVerifica rapida
Verifichi la sua comprensione del conteggio basato sulla lunghezza delle tuple.
Riepilogo
Il conteggio è la base della matematica a livello di tipo.
- Rappresenti
Ncome una tupla di lunghezzaN. - Legga il numero con
T["length"]. BuildTuple<N>converte un numero in una tupla.- Funziona solo per interi non negativi piccoli.
Prossimo argomento: addizione e sottrazione reali.
Impara TypeScript con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 101
- Lezioni
- 352
Domande Frequenti
La lezione «Contare con la lunghezza delle tuple» è gratuita?
Sì — il testo completo di «Contare con la lunghezza delle tuple» è 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 «Contare con la lunghezza delle tuple»?
Rappresenti i numeri come lunghezze di tuple nei tipi. 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 «Contare con la lunghezza delle tuple»?
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
- Contare con la lunghezza delle tuple
- Addizione e sottrazione a livello di tipo
- Confronti a livello di tipo
- Utility pratiche per i tipi numerici