0Pricing
TypeScript Academy · Leçon

Utilitaires pratiques pour les types numériques

Appliquer l’arithmétique des types aux contraintes d’intervalle et de longueur.

Utilitaires pratiques pour les types numériques est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

De la théorie aux outils

L'arithmétique et la comparaison deviennent utiles lorsqu'elles sont regroupées en utilitaires pratiques : plages, tableaux à longueur imposée, indices bornés. Cette leçon transforme les primitives en outils que vous pourriez réellement intégrer à votre code.

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

Énumérer : de 0 à N-1

Un utilitaire fondamental produit une union de tous les nombres de 0 à N-1. Construisez un tuple de longueur N et lisez tous ses indices de clé.

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

type A = Enumerate<4>; // 0 | 1 | 2 | 3

Types d'intervalle

Un Range<Start, End> produit les nombres de Start jusqu'à End - 1. Prenez Enumerate<End> et excluez les valeurs inférieures à Start.

type Range<S extends number, E extends number> =
  Exclude<Enumerate<E>, Enumerate<S>>;

type A = Range<2, 6>; // 2 | 3 | 4 | 5

Restreindre un paramètre

Utilisez une plage pour restreindre les arguments valides. Une fonction qui n'accepte qu'un petit résultat de lancer de dé peut prendre Range<1, 7>, afin que le compilateur rejette les valeurs hors limites.

type DiceFace = Range<1, 7>; // 1|2|3|4|5|6
declare function roll(face: DiceFace): void;
roll(4); // ok
// roll(8); // compile error

Imposer une longueur de tableau

Un type de tableau à longueur fixe rejette les tableaux dont la taille est incorrecte. Construisez par récursion un tuple de N éléments du type T.

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

type RGB = FixedArray<number, 3>; // [number, number, number]

Utiliser une longueur fixe

Désormais, une mauvaise utilisation provoque une erreur de compilation. Un point en 3D doit avoir exactement trois coordonnées.

type Vec3 = FixedArray<number, 3>;
const v: Vec3 = [1, 2, 3]; // ok
// const w: Vec3 = [1, 2]; // error: missing element

Borner les indices

Vous pouvez borner un type d'indice aux positions valides d'un tableau. Combinez une longueur de tuple avec Enumerate afin de n'accepter que les indices compris dans les limites.

type Indices<T extends readonly unknown[]> = Enumerate<T["length"]>;

type Arr = readonly ["a", "b", "c"];
type I = Indices<Arr>; // 0 | 1 | 2

Accès indexé sûr

Avec un type d'indice valide, vous pouvez écrire un accesseur dont le paramètre d'indice ne peut pas sortir des limites, ce qui détecte les erreurs de décalage d'une unité lors de la compilation.

declare function at<T extends readonly unknown[]>(
  arr: T,
  i: Indices<T>
): T[Indices<T>];

const x = at(["a", "b", "c"] as const, 2); // ok
// at(["a", "b", "c"] as const, 3); // error

Utilitaires de minimum et de maximum

Ajoutez la comparaison pour choisir le plus grand ou le plus petit de deux nombres, ce qui est utile pour borner une valeur dans une plage.

type Max<A extends number, B extends number> =
  GreaterThan<A, B> extends true ? A : B;
type Min<A extends number, B extends number> =
  GreaterThan<A, B> extends true ? B : A;

type X = Max<3, 8>; // 8
type Y = Min<3, 8>; // 3

Composer des utilitaires

Ces utilitaires se combinent. Un tuple dont la longueur appartient à une plage, un indice borné aux positions de son tableau, une valeur encadrée par un minimum et un maximum : chacun est une petite fonction réutilisable au niveau des types.

type ValidPort = Range<1, 4>; // 1 | 2 | 3 (toy example)
type Slots = FixedArray<ValidPort, 2>; // [1|2|3, 1|2|3]

Quand cela en vaut la peine

L'arithmétique des types est particulièrement utile pour les bornes petites et fixes : tuples RGB, faces de dés, coordonnées de plateau, tailles de champs de protocole. Elle ne vaut pas la peine pour les nombres grands ou dynamiques, lorsque les limites de récursion et la complexité l'emportent sur la sûreté. Utilisez-la lorsque la borne est petite et la garantie précieuse.

type Board = FixedArray<FixedArray<0 | 1, 3>, 3>; // 3x3 grid

Vérification rapide

Vérifiez votre compréhension des utilitaires numériques pratiques.

Récapitulatif

Vous avez construit une petite bibliothèque d'utilitaires numériques pour les types.

  • Enumerate et Range produisent des unions de nombres.
  • FixedArray impose des longueurs exactes.
  • Indices borne l'accès aux positions valides.
  • Min/Max encadrent les valeurs.

Utilisez-les pour les petites bornes fixes. Ensuite, cours 23 : simuler les types de niveau supérieur.

Questions Fréquemment Posées

La leçon « Utilitaires pratiques pour les types numériques » est-elle gratuite ?

Oui — le texte complet de « Utilitaires pratiques pour les types numériques » 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 « Utilitaires pratiques pour les types numériques » ?

Appliquer l’arithmétique des types aux contraintes d’intervalle et de longueur. 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 4 sur 4.

Combien de temps prend la leçon « Utilitaires pratiques pour les types numériques » ?

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