null et undefined de TypeScript

En TypeScript, null et undefined ont un traitement spécial.

ActivationstrictNullChecksEnsuite, ces valeurs doivent être gérées explicitement, ce qui aide à écrire un code plus sûr.


Diagramme SVG : gestion de null et undefined Background Title null and undefined handling null Represents "empty value" Needs explicit declaration string | null vs undefined Represents "undefined" Optional properties automatically include name?: string Arrow Safe Handling approach Safe handling approach Optional chaining: obj?.prop Nullish coalescing: value ?? default Type guard: if (val !== null) Bottom section Handling scenarios Scenario 1 Union type declaration Scenario 2 Optional parameters and properties Scenario 3 Nullish coalescing operator Arrow marker

Pourquoi gérer null et undefined

En JavaScript, null et undefined sont des sources courantes d’erreurs, et de nombreuses erreurs d’exécution leur sont liées.

L’option strictNullChecks de TypeScript oblige les développeurs à gérer explicitement les valeurs susceptibles d’être null.

Bien que cela augmente l’effort de codage, cela peut grandement réduire les erreurs d’exécution causées par les valeurs null et améliorer la fiabilité du code.

Explication du concept :nullReprésente une « valeur vide », c’est-à-dire qu’il n’y a aucune valeur ici ;undefinedReprésente « undefined », c’est-à-dire qu’aucune valeur ne lui a encore été attribuée.


Notions de base sur null et undefined

null représente une « valeur vide », undefined représente « undefined ». Tous deux sont des types indépendants en TypeScript.

Exemple

// Déclarer une variable de type null
// Ne peut être affecté qu’à null
var empty: null = null;

// Déclarer une variable de type undefined
// Ne peut être assigné qu'à undefined
var notDefined: undefined = undefined;

console.log("null: " + empty);
console.log("undefined: " + notDefined);

Sortie :

null: null
undefined: undefined

Explication :Sans activer strictNullChecks, ces types peuvent être assignés l'un à l'autre. Après l'avoir activé, une déclaration explicite est requise.


Gestion de null par les types union

Après avoir activé strictNullChecks, vous devez utiliser des types union pour déclarer explicitement les valeurs qui peuvent être null.

Exemple

// Type union : peut être string ou null
// Déclarer explicitement que la valeur peut être null
var name: string | null = "Alice";
name = null;  // Correct : peut être assigné à null

// L'accès à une valeur qui peut être null nécessite une vérification préalable.
// Le paramètre de la fonction peut être de type string ou null
function getLength(str: string | null): number {
    // Utilisez une vérification conditionnelle pour voir si la valeur est null
    if (str === null) {
        return 0;  // Retourner 0 lorsque null
    }
    // TypeScript déduira que str n'est pas null
    return str.length;
}

console.log("Longueur : " + getLength("hello"));
console.log("Longueur : " + getLength(null));

Sortie :

长度: 5
长度: 0

Bonnes pratiques :Utilisez des gardes de type (vérifications if) pour restreindre les types et indiquer à TypeScript le type spécifique.


Paramètres et propriétés optionnels

Les paramètres optionnels et les propriétés optionnelles incluent automatiquement undefined ; il n'est pas nécessaire de déclarer explicitement null.

Exemple

// Paramètre optionnel : marqué avec ?
// Le paramètre peut être de type string ou undefined
function greet(name?: string): string {
    // Vérifier s'il est undefined
    if (name === undefined) {
        return "Bonjour, étranger !";
    }
    return "Bonjour, " + name;
}

console.log(greet("Alice"));
console.log(greet());

// Propriété optionnelle : marquée avec ?
// La propriété age est optionnelle et peut ne pas exister
interface User {
    name: string;
    age?: number;  // Propriété optionnelle
}

var user: User = { name: "Bob" };
console.log("Utilisateur : " + JSON.stringify(user));

Sortie :

Hello, Alice!
Hello, stranger!
User: {"name":"Bob"}

Explication :Paramètres optionnelsname?: stringéquivalent àstring | undefined。


Opérateur d'assertion non-null

Utilisation!Indique au compilateur qu'une valeur n'est ni null ni undefined. Cela doit être utilisé avec prudence.

Exemple

function getLength(str: string | null): number {
    // Assertion non-null : indique au compilateur que str n'est pas null
    // Cette approche est dangereuse ; si str est réellement null, cela provoquera une erreur
    return str!.length;
}

console.log("Longueur : " + getLength("hello"));

Avertissement :L'assertion non-null contourne la vérification de type de TypeScript. Si la valeur est réellement null, cela provoquera quand même une erreur d'exécution. Évitez de l'utiliser lorsque c'est possible.


Opérateur de coalescence nullish

Utilisation??Fournit une valeur par défaut ; la valeur par défaut n'est utilisée que lorsque la valeur est null ou undefined.

Exemple

// La valeur initiale est null
var name: string | null = null;

// Opérateur ?? : utilise la valeur du côté droit lorsque le côté gauche est null/undefined
// Si name est null, utiliser "Guest"
var displayName = name ?? "Invité";

console.log("Nom d'affichage : " + displayName);

// Comparaison avec l'opérateur || (qui considère 0 et la chaîne vide comme falsy)
var num: number | null = 0;
var result1 = num ?? 100;  // 0 (correct : 0 n'est pas null/undefined)
var result2 = num || 100;  // 100 (incorrect : 0 est traité comme falsy)

console.log("?? résultat : " + result1);
console.log("|| résultat : " + result2);

Sortie :

显示名称: Guest
?? 结果: 0
|| 结果: 100

Recommandation :Préférez utiliser??plutôt que||, car??Il ne gère que null et undefined et ne considère pas à tort 0 ou une chaîne vide comme falsy.


Chaînage optionnel

Utilisation?.Accéder en toute sécurité aux propriétés imbriquées qui peuvent ne pas exister, en évitant les vérifications de null sur plusieurs niveaux d'imbrication.

Exemple

// Définir un type de personne ; l'adresse est facultative
interface Person {
    name: string;
    address?: {
        city: string;
    };
}

// Créer un objet personne sans adresse
var person: Person = { name: "Alice" };

// Chaînage optionnel : accéder en toute sécurité aux propriétés qui peuvent ne pas exister
// Si l'adresse n'existe pas, renvoyer undefined au lieu de lever une erreur
var city = person.address?.city;

// Combiné avec l'opérateur de coalescence des nuls
console.log("Ville : " + city);
console.log("Ville : " + (person.address?.city ?? "Inconnue"));

Sortie :

City: undefined
City: 未知

Bonne pratique :chaînage optionnel?.est la meilleure façon de gérer les propriétés optionnelles imbriquées, combiné avec??il peut fournir une valeur par défaut de repli.


Notes

  • Mode strict :Il est recommandé d'activer strictNullChecks pour une meilleure sécurité de type
  • Éviter les assertions :Essayez d'éviter d'utiliser des assertions non nulles!
  • ?? vs || :Préférez utiliser??pour éviter de mal interpréter 0 et les chaînes vides
  • Chaînage optionnel :À utiliser lors de la gestion de propriétés optionnelles imbriquées?.

Bonne pratique :Utilisez des gardes de type, le chaînage optionnel et l'opérateur de coalescence des nuls pour gérer null et undefined, ce qui rend le code plus sûr et plus lisible.


Résumé

Une gestion correcte de null et undefined est essentielle pour écrire du code TypeScript sûr.

  • Mode strict :Après avoir activé strictNullChecks, une gestion explicite est requise
  • Types union :Utilisezstring | nullpour déclarer
  • Paramètres/propriétés optionnels :Incluent automatiquement undefined
  • Assertion de non-nullité :Utiliser!(À utiliser avec prudence)
  • Coalescence des nuls :Utiliser??Fournir une valeur par défaut
  • Chaînage optionnel :Utiliser?.Accès sécurisé

Recommandation :Prenez l'habitude de gérer les valeurs nulles, en utilisant le chaînage optionnel et l'opérateur de coalescence des nuls pour rendre le code plus robuste.

Autres extensions