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
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
// 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
// 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
// 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 optionnels
name?: 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
// 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
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
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 :Utilisez
string | 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é
Autres extensionsRecommandation :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.