0Pricing
TypeScript Academy · Lezione

Confronti a livello di tipo

Confronti numeri interamente a livello di tipo.

Confronti a livello di tipo è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 3 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.

Confrontare i numeri

Per confrontare i tipi letterali numerici si ricorre nuovamente alle tuple. L'idea è ridurre entrambi i numeri allo stesso ritmo e vedere quale raggiunge per prima lo zero. Il numero che raggiunge per primo la tupla vuota è il più piccolo.

type BuildTuple<N extends number, Acc extends unknown[] = []> =
  Acc["length"] extends N ? Acc : BuildTuple<N, [...Acc, unknown]>;

Uguaglianza dei letterali

L'uguaglianza tra letterali numerici usa l'assegnabilità reciproca. Due letterali sono uguali quando ciascuno si estende all'altro. Racchiuderli nelle tuple evita risultati inattesi con le unioni.

type NumEquals<A extends number, B extends number> =
  [A] extends [B] ? ([B] extends [A] ? true : false) : false;

type X = NumEquals<3, 3>; // true
type Y = NumEquals<3, 4>; // false

Maggiore di riducendo

Per A > B, costruisca le tuple per entrambi e rimuova un elemento da ciascuna a ogni passaggio. Se B si svuota mentre A contiene ancora elementi, allora A è maggiore.

type GreaterThan<A extends number, B extends number> =
  BuildTuple<A> extends [...BuildTuple<B>, unknown, ...unknown[]]
    ? true : false;

type X = GreaterThan<5, 3>; // true
type Y = GreaterThan<3, 5>; // false

Come si legge il pattern

Il pattern [...BuildTuple<B>, unknown, ...unknown[]] significa: un prefisso di lunghezza B, seguito da almeno un altro elemento. Se A corrisponde a questo pattern, contiene più elementi di B, quindi A > B.

type A = GreaterThan<4, 4>; // false (no extra element)
type B = GreaterThan<6, 2>; // true

Minore di

LessThan è semplicemente GreaterThan con gli argomenti invertiti. Riutilizzi invece di ridefinire da zero.

type LessThan<A extends number, B extends number> =
  GreaterThan<B, A>;

type X = LessThan<3, 5>; // true
type Y = LessThan<5, 3>; // false

Maggiore o uguale

Combini il confronto con l'uguaglianza. A >= B è vero quando A > B oppure A == B.

type Gte<A extends number, B extends number> =
  GreaterThan<A, B> extends true
    ? true
    : NumEquals<A, B>;

type X = Gte<5, 5>; // true
type Y = Gte<3, 5>; // false

Confronto ricorsivo

Un'alternativa confronta i valori decrementandoli entrambi finché uno non raggiunge lo zero. Questo mostra esplicitamente l'idea di procedere allo stesso ritmo: il valore che raggiunge per primo lo zero è il più piccolo.

type Cmp<A extends number, B extends number> =
  A extends 0
    ? (B extends 0 ? "eq" : "lt")
    : B extends 0
      ? "gt"
      : Cmp<Dec<A>, Dec<B>>;

type X = Cmp<3, 5>; // "lt"

La dipendenza da Dec

La versione ricorsiva richiede Dec dalla lezione precedente. A ogni passaggio rimuove un segno da ciascun lato. Quando entrambi sono zero, sono uguali; se solo uno è zero, l'altro è maggiore.

type Dec<N extends number> =
  BuildTuple<N> extends [unknown, ...infer R] ? R["length"] : 0;

Uguaglianza e assegnabilità

Faccia attenzione: number extends number è vero, ma non indica l'uguaglianza tra letterali. I confronti qui descritti presuppongono tipi letterali specifici, come 3 e 5, non il tipo ampio number.

type A = NumEquals<3, 3>;          // true
type B = 3 extends number ? 1 : 0; // 1 (assignability, not equality)

Costruire una chiave di ordinamento

Con il confronto può codificare regole di ordinamento. Per esempio, può decidere a livello di tipo se una tupla di due numeri è ordinata in senso crescente.

type IsSorted<A extends number, B extends number> =
  GreaterThan<A, B> extends true ? false : true;

type X = IsSorted<2, 5>; // true
type Y = IsSorted<5, 2>; // false

Da usare con moderazione

I confronti richiedono ricorsione. Sono ottimi per proteggere valori piccoli e limitati (indici, limiti fissi), ma non costituiscono una libreria numerica generale. Mantenga piccoli gli operandi e preferisca la forma basata sul pattern del prefisso, che è meno profonda della ricorsione completa allo stesso ritmo.

type A = GreaterThan<9, 4>; // true (cheap, prefix pattern)

Verifica rapida

Verifichi la sua comprensione dei confronti a livello di tipo.

Riepilogo

Ora può ordinare i numeri nel sistema dei tipi.

  • Uguaglianza tramite assegnabilità reciproca dei letterali.
  • GreaterThan tramite un prefisso della lunghezza di B più un elemento aggiuntivo.
  • LessThan inverte gli argomenti; Gte aggiunge l'uguaglianza.
  • Funziona su numeri letterali piccoli, non sul tipo ampio number.

Prossimo argomento: trasformare tutto questo in utility pratiche.

Domande Frequenti

La lezione «Confronti a livello di tipo» è gratuita?

Sì — il testo completo di «Confronti 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 «Confronti a livello di tipo»?

Confronti numeri interamente a livello di tipo. 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 3 di 4.

Quanto tempo richiede la lezione «Confronti 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

  1. Contare con la lunghezza delle tuple
  2. Addizione e sottrazione a livello di tipo
  3. Confronti a livello di tipo
  4. Utility pratiche per i tipi numerici
← Torna a TypeScript Academy