0Pricing
TypeScript Academy · Leçon

Compter avec la longueur des tuples

Représenter les nombres comme des longueurs de tuples dans les types.

Compter avec la longueur des tuples est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Les nombres ont besoin d’une représentation

Le système de types ne peut pas additionner directement des littéraux numériques. La solution classique consiste à représenter un nombre N par un tuple de N éléments. Le contenu n’a pas d’importance ; seule la longueur compte.

type Three = [unknown, unknown, unknown];
type N = Three["length"]; // 3

Lecture de la longueur

Chaque type tuple possède une propriété length qui est un type littéral numérique. L'indexation avec ["length"] la lit sous forme de nombre que vous pouvez utiliser.

type A = [1, 2, 3, 4]["length"]; // 4
type B = []["length"];           // 0
type C = ["x"]["length"];        // 1

Pourquoi utiliser le type inconnu comme remplissage

Nous utilisons unknown comme type des éléments, car les valeurs sont sans importance : seul le nombre compte. N'importe quel type convient, mais unknown indique clairement une « valeur de remplissage ».

type Two = [unknown, unknown];
type N = Two["length"]; // 2

Construire un tuple de longueur N

Pour faire l'inverse, construisez un tuple de la longueur souhaitée à l'aide de la récursion. Ajoutez des éléments jusqu'à ce que la longueur corresponde à N, puis renvoyez le tuple. Il s'agit de l'utilitaire célèbre 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]

Fonctionnement de BuildTuple

Suivez BuildTuple<3> :

  • Longueur de l'accumulateur : 0, différente de 3, ajout d'un élément
  • Longueur de l'accumulateur : 1, différente de 3, ajout d'un élément
  • Longueur de l'accumulateur : 2, différente de 3, ajout d'un élément
  • Longueur de l'accumulateur : 3, égale à 3, renvoi du résultat

La longueur de l'accumulateur sert de compteur de boucle.

type A = BuildTuple<2>; // [unknown, unknown]

La longueur est le pont

Deux opérations permettent de passer des nombres aux tuples et inversement :

  • Nombre vers tuple : BuildTuple<N>
  • Tuple vers nombre : T["length"]

Toute l'arithmétique des types repose sur le franchissement de ce pont.

type FromN = BuildTuple<4>;        // tuple of length 4
type BackToN = FromN["length"];    // 4

Comparer par la longueur

Comme la longueur d'un tuple est un littéral, vous pouvez vérifier l'égalité des nombres d'éléments. Construisez des tuples et comparez leurs longueurs par assignabilité.

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"]>;      // false

Un compteur de longueur générique

Vous pouvez réimplémenter length par récursion pour comprendre son fonctionnement, même si lire ["length"] est plus rapide. Cela montre que compter consiste simplement à parcourir un tuple.

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"]>; // 3

Les tuples comme compteurs

Imaginez le tuple comme un décompte : chaque élément correspond à une marque. Ajouter un élément incrémente le compteur ; en supprimer un le décrémente. Ce modèle mental rend l'arithmétique intuitive.

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

type A = Inc<3>; // 4

Aperçu de la décrémentation

La décrémentation construit le tuple correspondant à N, puis infère tout sauf le dernier élément et lit la longueur plus courte. Vous formaliserez cela dans la prochaine leçon.

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

type A = Dec<3>; // 2
type B = Dec<0>; // 0

Limites à retenir

Cette technique fonctionne pour les petits entiers positifs ou nuls. Une valeur N très élevée atteint les limites de récursion, et il n'existe aucun mécanisme intégré pour les nombres négatifs ou décimaux. Dans ces limites, elle est fiable et entièrement statique.

type A = BuildTuple<5>["length"]; // 5 (fine)
// BuildTuple<10000> would error: too deep

Vérification rapide

Vérifiez votre compréhension du comptage fondé sur la longueur des tuples.

Récapitulatif

Le comptage est la base de l'arithmétique des types.

  • Représentez N par un tuple de longueur N.
  • Lisez le nombre avec T["length"].
  • BuildTuple<N> permet de passer d'un nombre à un tuple.
  • Cette technique fonctionne uniquement pour les petits entiers positifs ou nuls.

Ensuite : l'addition et la soustraction réelles.

Questions Fréquemment Posées

La leçon « Compter avec la longueur des tuples » est-elle gratuite ?

Oui — le texte complet de « Compter avec la longueur des tuples » 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 « Compter avec la longueur des tuples » ?

Représenter les nombres comme des longueurs de tuples dans les 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 1 sur 4.

Combien de temps prend la leçon « Compter avec la longueur des tuples » ?

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