TypeScript Academy · Leçon

Rétrécissement avec typeof et la véracité

Utilisez des vérifications typeof pour affiner les types primitifs

Leçon 1 sur 413 étapes

Rétrécissement avec typeof et la véracité 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.

Bienvenue

TypeScript affine les types d’union dans les blocs conditionnels. Les vérifications avec `typeof` et les vérifications de véracité sont les techniques d’affinage les plus courantes.

Affinage avec typeof

Utilisez `typeof` pour vérifier les types primitifs. TypeScript comprend les vérifications avec typeof et affine le type à l’intérieur du bloc.
function process(val: string | number) {
  if (typeof val === 'string') {
    return val.toUpperCase(); // val: string
  }
  return val.toFixed(2); // val: number
}

Valeurs renvoyées par typeof

typeof renvoie 'string', 'number', 'boolean', 'bigint', 'symbol', 'undefined', 'object' ou 'function'. Remarque : typeof null === 'object' est une particularité de JavaScript.
typeof 'hello'    // 'string'
typeof 42         // 'number'
typeof true       // 'boolean'
typeof null       // 'object' (quirk!)
typeof undefined  // 'undefined'

Affinage par véracité

Les valeurs JavaScript sont évaluées comme vraies ou fausses. TypeScript affine `T | null | undefined` en `T` à l’intérieur d’une vérification de véracité.
function greet(name: string | null) {
  if (name) {
    console.log('Hello, ' + name); // name: string
  } else {
    console.log('Hello, stranger');
  }
}

Valeurs fausses

Valeurs fausses en JavaScript : false, 0, '', null, undefined, 0n et NaN. L’affinage par véracité les retire du type lorsque la vérification réussit.

Affinage par conversion booléenne

L’utilisation de `Boolean(val)` ou de `!!val` retire également null et undefined du type affiné.
const items: (string | null)[] = ['a', null, 'b', null];
const strings = items.filter((x): x is string => x !== null);

Conditions négatives

TypeScript affine également les types dans les branches else et après les retours anticipés.
function getLength(val: string | null): number {
  if (!val) return 0; // early return narrows
  return val.length;  // val: string here
}

Combinaison de typeof et de l’égalité

L’égalité stricte (===) combinée à typeof permet un affinage précis.
function accept(x: string | number | boolean) {
  if (typeof x === 'string' || typeof x === 'number') {
    console.log(x); // x: string | number
  }
}

typeof ne peut pas affiner vers null

Pour affiner vers null, utilisez l’égalité stricte `=== null`. La vérification de véracité ne permet pas de distinguer null des autres valeurs fausses.
function check(x: string | null | 0) {
  if (x === null) { /* x: null */ }
  else if (x === 0) { /* x: 0 */ }
  else { /* x: string */ }
}

Affinage dans les boucles

TypeScript applique également l’affinage à l’intérieur des corps de boucle, et pas uniquement dans les instructions if.

Analyse du flux de contrôle

TypeScript suit le type à chaque emplacement de votre code grâce à l’analyse du flux de contrôle. Les affectations mettent également à jour le type.
let x: string | number = 'hello';
// x: string
x = 42;
// x: number

Vérification rapide

Dans `if (typeof val === 'string')`, quel est le type de `val`, en supposant qu’il était de type `string | number` ?

Récapitulatif

Les vérifications avec typeof et les conditions de véracité affinent les types d’union dans TypeScript. TypeScript utilise l’analyse du flux de contrôle pour suivre les types à chaque emplacement. Utilisez l’égalité stricte pour les vérifications concernant null et undefined.
Gratuit pour commencer

Apprends TypeScript avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
101
Leçons
352

Questions Fréquemment Posées

La leçon « Rétrécissement avec typeof et la véracité » est-elle gratuite ?

Oui — le texte complet de « Rétrécissement avec typeof et la véracité » 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 « Rétrécissement avec typeof et la véracité » ?

Utilisez des vérifications typeof pour affiner les types primitifs 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 « Rétrécissement avec typeof et la véracité » ?

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. Rétrécissement avec typeof et la véracité
  2. Rétrécissement avec instanceof et in
  3. Fonctions de garde de types définies par l’utilisateur
  4. Vérification de l’exhaustivité avec never
← Retour à TypeScript Academy