0Pricing
TypeScript Academy · Leçon

Comparaisons au niveau des types

Comparer des nombres entièrement au niveau des types.

Comparaisons au niveau des types est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 4 leçons au total.

Comparer les nombres

Pour comparer des types littéraux numériques, vous vous appuyez de nouveau sur les tuples. L'idée consiste à réduire les deux nombres au même rythme et à voir lequel atteint zéro en premier. Celui qui atteint le tuple vide en premier est le plus petit nombre.

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

Égalité des littéraux

L'égalité des littéraux numériques repose sur l'assignabilité mutuelle. Deux littéraux sont égaux lorsque chacun étend l'autre. Les encapsuler dans des tuples évite les surprises liées aux unions.

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

Supériorité par réduction

Pour A > B, construisez des tuples pour les deux nombres et supprimez un élément de chacun à chaque étape. Si B devient vide en premier alors que A contient encore des éléments, A est le plus grand.

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

Interpréter le motif

Le motif [...BuildTuple<B>, unknown, ...unknown[]] signifie : un préfixe de longueur B, puis au moins un élément supplémentaire. Si A peut correspondre à cela, A contient plus d'éléments que B, donc A > B.

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

Inférieur à

LessThan n'est que GreaterThan avec les arguments inversés. Réutilisez plutôt que de tout redériver.

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

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

Supérieur ou égal

Combinez comparaison et égalité. A >= B est vrai lorsque A > B ou 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

Comparaison récursive

Une autre méthode compare les nombres en décrémentant les deux jusqu'à ce que l'un atteigne zéro. Elle montre explicitement l'idée du traitement au même rythme : celui qui atteint zéro en premier est le plus petit.

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 dépendance envers la décrémentation

La version récursive a besoin de Dec, présenté dans la leçon précédente. Chaque étape retire une marque de chaque côté. Lorsque les deux valent zéro, ils sont égaux ; si un seul vaut zéro, l'autre est le plus grand.

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

Égalité et assignabilité

Attention : number extends number est vrai, mais il ne s'agit pas d'une égalité littérale. Les comparaisons présentées ici supposent des types littéraux précis, comme 3 et 5, et non le type général number.

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

Construire une clé de tri

Grâce à la comparaison, vous pouvez encoder des règles d'ordre. Par exemple, déterminez au niveau des types si un tuple de deux nombres est trié par ordre croissant.

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

À utiliser avec parcimonie

Les comparaisons consomment de la récursion. Elles sont excellentes pour protéger de petites valeurs bornées (indices, limites fixes), mais ne constituent pas une bibliothèque numérique générale. Gardez les opérandes petits et préférez la forme fondée sur le motif du préfixe, moins profonde que la récursion complète au même rythme.

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

Vérification rapide

Vérifiez votre compréhension des comparaisons au niveau des types.

Récapitulatif

Vous pouvez désormais ordonner les nombres dans le système de types.

  • Égalité par assignabilité mutuelle des littéraux.
  • GreaterThan grâce à un préfixe de longueur B suivi d'un élément supplémentaire.
  • LessThan inverse les arguments ; Gte ajoute l'égalité.
  • Cette méthode fonctionne avec de petits nombres littéraux, et non avec le type général number.

Ensuite : transformer tout cela en utilitaires pratiques.

Questions Fréquemment Posées

La leçon « Comparaisons au niveau des types » est-elle gratuite ?

Oui — le texte complet de « Comparaisons au niveau des types » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Comparaisons au niveau des types » ?

Comparer des nombres entièrement au niveau des types. Tu pratiques TypeScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer TypeScript Academy ?

Aucune expérience préalable n'est requise. TypeScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Comparaisons au niveau des types » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon TypeScript Academy ?

Oui. Chaque leçon TypeScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Compter avec la longueur des tuples
  2. Addition et soustraction au niveau des types
  3. Comparaisons au niveau des types
  4. Utilitaires pratiques pour les types numériques
← Retour à TypeScript Academy