TypeScript Academy · Leçon

Types Option et Maybe

Modéliser explicitement la présence ou l’absence d’une valeur.

Types Option et Maybe 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.

Modéliser l'absence

Parfois, une valeur peut simplement être absente, sans qu'il y ait d'erreur à signaler. Une Option (également appelée type « peut-être ») modélise explicitement la présence ou l'absence, comme alternative à null et undefined.

Définir Option

Option est une union discriminée dotée de l'étiquette some. Lorsque some vaut true, une valeur est présente ; lorsqu'il vaut false, il n'y a rien.

type Option<T> =
  | { some: true; value: T }
  | { some: false };

Constructeurs

Les fonctions auxiliaires some et none facilitent la création de valeurs Option, sur le même modèle que ok/err pour Result.

const some = <T>(value: T): Option<T> => ({ some: true, value });
const none: Option<never> = { some: false };

Renvoyer une Option

Une recherche qui peut ne rien trouver renvoie une Option plutôt que T | undefined. Le caractère facultatif est ainsi explicite dans le type.

function find<T>(arr: T[], pred: (x: T) => boolean): Option<T> {
  const hit = arr.find(pred);
  return hit === undefined ? none : some(hit);
}

Affiner le type avec some

Vérifiez opt.some pour accéder à la valeur en toute sécurité. Le compilateur n'autorise la lecture de value que dans la branche où la valeur est présente.

const r = find([1, 2, 3], n => n > 1);
if (r.some) console.log(r.value); // 2
else console.log("not found");

Pourquoi ne pas utiliser simplement null ?

null et undefined sont faciles à oublier et se confondent avec d'autres types. Une Option explicite impose de gérer le cas d'absence et montre clairement qu'il est intentionnel.

Option ou T | indéfini

Les deux peuvent modéliser l'absence, mais Option est une structure nommée et intentionnelle à laquelle vous pouvez associer des fonctions auxiliaires (map, getOrElse), ce qui encourage une gestion cohérente dans toute la base de code.

// undefined is implicit and easy to ignore;
// Option is explicit and self-documenting.

Une fonction getOrElse

Pour ramener une Option à une valeur concrète, fournissez une valeur de repli pour le cas d'absence. La gestion de l'absence reste ainsi regroupée à un endroit évident.

function getOrElse<T>(o: Option<T>, fallback: T): T {
  return o.some ? o.value : fallback;
}
console.log(getOrElse(none, 0)); // 0

Appliquer une transformation à une Option

Une fonction map transforme la valeur interne uniquement lorsqu'elle est présente, tout en laissant l'absence inchangée. Vous pouvez ainsi enchaîner les transformations sans vérifications répétées.

function mapOpt<T, U>(o: Option<T>, f: (t: T) => U): Option<U> {
  return o.some ? some(f(o.value)) : none;
}
console.log(mapOpt(some(5), n => n * 2)); // { some: true, value: 10 }

Option ou Résultat

Utilisez Option lorsque l'absence n'a aucune raison particulière (une recherche infructueuse). Utilisez Résultat lorsque l'échec s'accompagne d'une erreur explicative. Choisissez selon que vous devez expliquer pourquoi.

Composer des Options

Comme Option possède map et getOrElse, les chaînes d'étapes facultatives restent lisibles, l'absence interrompant automatiquement la chaîne.

const out = getOrElse(mapOpt(find([1,2], n => n > 1), n => n + 100), -1);
console.log(out); // 102

Vérification rapide

Vérification rapide de cette leçon.

Récapitulatif

Option<T> est soit { some: true; value }, soit { some: false } ; elle modélise explicitement l'absence plutôt que null. Construisez-la avec some/none, affinez le type avec some et utilisez des fonctions auxiliaires comme getOrElse et map. Préférez Option lorsque l'absence n'a pas besoin d'explication, et Résultat lorsque l'échec en nécessite une.

Questions Fréquemment Posées

La leçon « Types Option et Maybe » est-elle gratuite ?

Oui — le texte complet de « Types Option et Maybe » 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 « Types Option et Maybe » ?

Modéliser explicitement la présence ou l’absence d’une valeur. 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 « Types Option et Maybe » ?

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

← Retour à TypeScript Academy