Addizione e sottrazione a livello di tipo
Costruisca operazioni aritmetiche manipolando tuple.
Addizione e sottrazione a livello di tipo è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 2 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.
Aritmetica basata sulla lunghezza
Con la rappresentazione basata sulla lunghezza delle tuple, l'addizione diventa concatenazione e la sottrazione diventa rimozione di un prefisso. Esegua il calcolo sulle tuple, quindi legga la lunghezza risultante.
type BuildTuple<N extends number, Acc extends unknown[] = []> =
Acc["length"] extends N ? Acc : BuildTuple<N, [...Acc, unknown]>;Addizione
Per calcolare A + B: costruisca una tupla di lunghezza A, ne costruisca una di lunghezza B, espanda entrambe in una nuova tupla e ne legga la lunghezza.
type Add<A extends number, B extends number> =
[...BuildTuple<A>, ...BuildTuple<B>]["length"];
type S = Add<3, 4>; // 7Perché la concatenazione somma
Una tupla di lunghezza 3 seguita da una tupla di lunghezza 4 produce una tupla di lunghezza 7. Unendo i segni di due conteggi si ottiene un conteggio combinato, quindi le lunghezze si sommano.
type A = Add<2, 2>; // 4
type B = Add<0, 5>; // 5
type C = Add<1, 6>; // 7Sottrazione tramite prefisso
Per calcolare A - B: costruisca una tupla di lunghezza A, quindi la faccia corrispondere a un prefisso di lunghezza B seguito da un resto. Il rest ha lunghezza A - B.
type Sub<A extends number, B extends number> =
BuildTuple<A> extends [...BuildTuple<B>, ...infer Rest]
? Rest["length"]
: never;
type D = Sub<7, 4>; // 3Sottrazione passo per passo
Per Sub<7, 4>: costruisca una tupla di lunghezza 7, faccia corrispondere un prefisso di lunghezza 4, catturi Rest (di lunghezza 3) e ne legga la lunghezza. Il prefisso rimosso corrisponde esattamente a B segni.
type A = Sub<5, 2>; // 3
type B = Sub<4, 4>; // 0Il risultato dell'underflow è never
I numeri a livello di tipo sono non negativi. Se B > A, non esiste alcun prefisso valido, il pattern non corrisponde e il risultato è never. Se preferisce, può impostarlo per impostazione predefinita su 0.
type A = Sub<2, 5>; // never
type SubSafe<A extends number, B extends number> =
[Sub<A, B>] extends [never] ? 0 : Sub<A, B>;
type B = SubSafe<2, 5>; // 0Incremento e decremento
I casi speciali dell'aggiunta e della sottrazione di uno sono abbastanza comuni da meritare un nome. Inc aggiunge un elemento; Dec ne rimuove uno.
type Inc<N extends number> = [...BuildTuple<N>, unknown]["length"];
type Dec<N extends number> =
BuildTuple<N> extends [unknown, ...infer R] ? R["length"] : 0;
type A = Inc<4>; // 5
type B = Dec<4>; // 3Moltiplicazione per ripetizione
La moltiplicazione è un'addizione ripetuta. Aggiunga B a un accumulatore A volte, contando alla rovescia con Dec e accumulando con Add.
type Mul<A extends number, B extends number, Acc extends number = 0> =
A extends 0 ? Acc : Mul<Dec<A>, B, Add<Acc, B>>;
type A = Mul<3, 4>; // 12L'helper BuildTuple
Ogni operazione qui descritta dipende da BuildTuple. È l'unico elemento primitivo riutilizzabile: gli fornisca un numero e otterrà una tupla di quella lunghezza. Lo mantenga in un unico punto e costruisca tutto il resto su di esso.
type Five = BuildTuple<5>; // [unknown, unknown, unknown, unknown, unknown]
type N = Five["length"]; // 5Comporre le operazioni
Poiché ogni operazione riceve e restituisce un numero, può comporle liberamente. Può scrivere espressioni come Add<Mul<2, 3>, 4> e il compilatore le valuta.
type Result = Add<Mul<2, 3>, 4>; // 10Una cautela pratica
Queste tecniche sono ottime per conteggi piccoli: indici di array, dimensioni fisse e intervalli limitati. Per numeri grandi o per l'aritmetica generale, il limite della ricorsione e l'assenza di numeri negativi le rendono poco pratiche. Le utilizzi quando i valori sono piccoli e statici.
type A = Add<8, 7>; // 15 (fine)
// Add<5000, 5000> would exceed recursion limitsVerifica rapida
Verifichi la sua comprensione dell'aritmetica a livello di tipo.
Riepilogo
Ha implementato l'aritmetica nel sistema dei tipi.
- Add: concatena le tuple e ne legge la lunghezza.
- Sub: deduce un prefisso e legge la lunghezza del resto.
Inc/Decsono le versioni a un solo passaggio.BuildTupleè l'elemento primitivo condiviso.
Prossimo argomento: confrontare i numeri a livello di tipo.
Domande Frequenti
La lezione «Addizione e sottrazione a livello di tipo» è gratuita?
Sì — il testo completo di «Addizione e sottrazione a livello 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 «Addizione e sottrazione a livello di tipo»?
Costruisca operazioni aritmetiche manipolando tuple. 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 2 di 4.
Quanto tempo richiede la lezione «Addizione e sottrazione a livello 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
- Contare con la lunghezza delle tuple
- Addizione e sottrazione a livello di tipo
- Confronti a livello di tipo
- Utility pratiche per i tipi numerici