0Pricing
TypeScript Academy · Leçon

null, undefined et vérifications strictes de nullité

Gérez null et undefined en toute sécurité avec le mode strict.

null, undefined et vérifications strictes de nullité 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.

Bienvenue

En JavaScript, les valeurs nulles et indéfinies sont des sources fréquentes d'erreurs à l'exécution. Les vérifications strictes des valeurs nulles de TypeScript vous obligent à les gérer explicitement.

Valeur nulle ou indéfinie

`undefined` signifie qu'une variable a été déclarée, mais qu'aucune valeur ne lui a été affectée. `null` indique une absence intentionnelle de valeur. Ces deux valeurs sont des types distincts dans TypeScript.
let a: undefined = undefined;
let b: null = null;

Sans vérifications strictes des valeurs nulles

Sans `strictNullChecks`, les valeurs nulles et indéfinies sont des sous-types de tous les types. C'est le comportement par défaut des anciennes versions de TypeScript et il est généralement dangereux.
// strictNullChecks: false (unsafe default)
let name: string = null; // allowed — dangerous!

Activer les vérifications strictes des valeurs nulles

Avec `strictNullChecks: true` (inclus dans `strict`), les valeurs nulles et indéfinies ne sont assignables qu'à leurs propres types ou à des types union explicites.
// strictNullChecks: true
let name: string = null; // Error!
let maybeName: string | null = null; // OK

Propriétés facultatives

Les propriétés d'objet marquées avec `?` sont implicitement de type `T | undefined`. Vous devez gérer le cas où elles sont absentes.
interface Config {
  host: string;
  port?: number; // number | undefined
}

const c: Config = { host: 'localhost' };
console.log(c.port?.toString()); // optional chaining

Réduire les types pouvant être nuls

Utilisez une vérification if pour réduire une union contenant une valeur nulle ou indéfinie avant d'accéder aux propriétés.
function greet(name: string | null): string {
  if (name === null) return 'Guest';
  return 'Hello, ' + name;
}

Chaînage facultatif (?.)

L'opérateur `?.` renvoie immédiatement `undefined` si le membre de gauche est nul ou indéfini, ce qui évite un plantage à l'exécution.
const user = getUser();
const city = user?.address?.city; // undefined if any step is null

Coalescence des valeurs nulles (??)

L'opérateur `??` renvoie le membre de droite uniquement lorsque celui de gauche est nul ou indéfini, contrairement à `||`, qui se déclenche pour toute valeur fausse.
const port = config.port ?? 3000; // 3000 if port is null/undefined
const label = name ?? 'Anonymous';

Opérateur d'assertion de valeur non nulle (!)

L'opérateur postfixe `!` indique à TypeScript que vous êtes certain qu'une valeur n'est ni nulle ni indéfinie. Utilisez-le uniquement lorsque vous en êtes absolument sûr.
const el = document.getElementById('root')!;
el.textContent = 'Loaded'; // no null check needed

Renvoyer une valeur nulle ou indéfinie

Préférez renvoyer `null` pour indiquer un résultat vide intentionnel et `undefined` pour les valeurs absentes ou facultatives. Soyez cohérent dans toute votre base de code.
function findUser(id: number): User | null {
  return db.find(u => u.id === id) ?? null;
}

strictNullChecks évite l'erreur à un milliard de dollars

Tony Hoare a qualifié la valeur nulle d'« erreur à un milliard de dollars ». strictNullChecks de TypeScript évite les plantages dus aux valeurs nulles ou indéfinies en vous obligeant à les gérer explicitement.

Vérification rapide

Que renvoie l'opérateur `??` (coalescence des valeurs nulles) situé à sa droite ?

Récapitulatif

Activez strictNullChecks pour éviter les erreurs liées aux valeurs nulles ou indéfinies. Utilisez des types union pour autoriser les valeurs pouvant être nulles, le chaînage facultatif (?.) pour parcourir les propriétés en toute sécurité et la coalescence des valeurs nulles (??) pour fournir des valeurs par défaut.

Questions Fréquemment Posées

La leçon « null, undefined et vérifications strictes de nullité » est-elle gratuite ?

Oui — le texte complet de « null, undefined et vérifications strictes de nullité » 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 « null, undefined et vérifications strictes de nullité » ?

Gérez null et undefined en toute sécurité avec le mode strict. 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 « null, undefined et vérifications strictes de nullité » ?

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. Types primitifs : string, number, boolean
  2. Le type any et pourquoi l’éviter
  3. unknown contre any : le choix le plus sûr
  4. null, undefined et vérifications strictes de nullité
← Retour à TypeScript Academy