Types spéciaux de TypeScript : never, void, unknown, any
TypeScript possède quatre types spéciaux : never, void, unknown et any.
Ils jouent un rôle important dans le système de types. Comprendre leurs différences est crucial pour écrire du code typé de manière sûre.
Diagramme SVG : Comparaison des types spéciaux
Pourquoi les types spéciaux sont nécessaires
Le système de types de TypeScript est très puissant. En plus des types ordinaires, il fournit quatre types spéciaux pour gérer des scénarios spécifiques.
Comprendre les différences entre ces quatre types spéciaux nous aide à écrire du code typé plus sûr et plus précis.
Explication du concept :never, void, unknown et any sont des types spéciaux de TypeScript, chacun ayant des significations et des cas d'utilisation différents.
Le type never
never représente un type qui ne retourne jamais. Il est généralement utilisé pour les fonctions qui lèvent des exceptions ou bouclent à l'infini.
Exemple
// La fonction ne retourne jamais normalement ; elle lève toujours une erreur
function throwError(message: string): never {
throw new Error(message);
}
// Fonction avec une boucle infinie
// La fonction ne retourne jamais ; le programme continue de s'exécuter
function infiniteLoop(): never {
while (true) {
console.log("Running...");
}
}
// never est un sous-type de tous les types
// Cela signifie que never peut être assigné à n'importe quel type
var neverValue: never;
var num: number = neverValue; // Correct : never est un sous-type de number
console.log("never affecté à number : " + num);
Sortie :
never 赋值给 number: undefined
Important :never est un sous-type de tous les types, ce qui signifie que never peut être affecté à n'importe quel type, mais aucun type ne peut être affecté à never (sauf never lui-même).
Le type void
void signifie qu'il n'y a pas de valeur de retour, et il est généralement utilisé pour déclarer des fonctions qui n'ont pas d'instruction return.
Exemple
// La fonction n'a pas de valeur de retour après exécution
function logMessage(message: string): void {
console.log("Journal : " + message);
// Pas d'instruction return, ou return undefined
}
logMessage("Bonjour");
// variable void (rarement utilisée)
// Ne peut être assigné qu'à undefined
var empty: void = undefined;
console.log("variable void : " + empty);
Sortie :
日志: Hello void 变量: undefined
Explication :void est en fait très similaire à undefined et est principalement utilisé pour les déclarations de type de retour de fonction, indiquant que la fonction n'a pas de valeur de retour.
Le type unknown
unknown est un any sûr au niveau des types. Lorsque vous utilisez unknown, vous devez effectuer une vérification de type avant de l'utiliser.
Exemple
// C'est un any "sûr"
var value: unknown = "hello";
value = 42;
value = true;
// Un type unknown ne peut pas être directement assigné à d'autres types
// Si vous décommentez la ligne suivante, le compilateur signalera une erreur
// var str: string = value;
// Il ne peut être assigné qu'après la vérification de type
if (typeof value === "string") {
// TypeScript sait que value est de type string
var str: string = value;
console.log("String length: " + str.length);
}
Sortie :
字符串长度: 5
Sécurité :unknown impose la vérification de type avant utilisation, ce qui protège la sûreté de type. Lorsque vous traitez des données provenant de sources inconnues, vous devriez utiliser unknown au lieu de any.
Le type any
any contourne complètement la vérification de type et peut se voir attribuer n'importe quel type. C'est le type le moins sûr de TypeScript.
Exemple
// Contourne complètement la vérification de type
var anything: any = "hello";
anything = 42;
anything = true;
// any peut être assigné à n'importe quel type
// Cela casse la sécurité des types
var str: string = anything;
var num: number = anything;
console.log("Chaîne : " + str);
console.log("Nombre : " + num);
// Un objet de type any peut appeler n'importe quelle méthode
// Le compilateur ne signalera pas d'erreur, mais cela peut échouer à l'exécution
var obj: any = {};
obj.foo(); // Aucune erreur n'est signalée, mais la méthode foo n'existe pas réellement
obj.bar = "value";
Avertissement :Le type any contourne complètement la vérification des types de TypeScript et doit être évité autant que possible. S'il doit être utilisé, assurez-vous que le type de la valeur est correct.
Comparaison de any vs unknown
any et unknown peuvent tous deux accepter n'importe quel type, mais leur sûreté est complètement différente.
| Fonctionnalité | any | unknown |
|---|---|---|
| Accepte n'importe quel type | ✓ Oui | ✓ Oui |
| Directement assignable à d'autres types | ✓ Oui | ✗ Non (nécessite une vérification) |
| Appel direct de méthodes | ✓ Oui | ✗ Non (nécessite une vérification) |
| Sûreté de typage | ✗ Aucun | ✓ Oui |
Recommandation :Lors du traitement de données de types inconnus, préférez utiliser unknown plutôt que any, car cela force la vérification de type.
never vs void
never et void sont tous deux utilisés pour les types de retour de fonction, mais leurs significations sont complètement différentes.
| Fonctionnalité | never | void |
|---|---|---|
| Signification | Ne retourne jamais | Aucune valeur de retour |
| Utilisé pour les fonctions | Lever des exceptions / boucles infinies | Fonctions ordinaires sans valeur de retour |
| Assignable à d'autres types | ✓ Oui (sous-type) | Assignable uniquement à void/any |
Différence clé :never signifie que la fonction ne retourne jamais normalement (soit elle lève une exception, soit elle entre dans une boucle infinie) ; void signifie que la fonction s'exécute normalement mais n'a pas de valeur de retour.
Application pratique : vérification exhaustive
Une utilisation importante du type never est d'effectuer des vérifications exhaustives, en s'assurant que tous les cas possibles ont été traités.
Exemple
type Shape = { kind: "circle", radius: number }
| { kind: "square", side: number };
// Calculer l'aire d'une forme
function area(shape: Shape): number {
switch (shape.kind) {
case "circle":
return Math.PI * shape.radius ** 2;
case "square":
return shape.side ** 2;
default:
// La branche par défaut doit gérer tous les cas inattendus
// Si vous ajoutez un nouveau type Shape mais oubliez de le gérer, le compilateur signalera une erreur
var _exhaustive: never = shape;
return _exhaustive;
}
}
var circle = { kind: "circle" as const, radius: 5 };
var square = { kind: "square" as const, side: 4 };
console.log("Aire du cercle : " + area(circle).toFixed(2));
console.log("Aire du carré : " + area(square));
Sortie :
圆形面积: 78.54 正方形面积: 16
Vérification exhaustive:Ce modèle garantit que lorsqu'une nouvelle branche de type est ajoutée, si vous oubliez de la gérer dans le switch, le compilateur signalera une erreur car le nouveau type ne peut pas être assigné à never.
Notes
- never est un sous-type :never peut être assigné à n'importe quel type, mais aucun type ne peut être assigné à never
- void vs undefined:En JavaScript, void et undefined sont essentiellement équivalents
- unknown nécessite une vérification :Avant d'utiliser une valeur de type unknown, vous devez effectuer une vérification de type.
- Évitez any :Essayez de ne pas utiliser any ; préférez unknown.
Bonnes pratiques :Sécurité de type de la plus élevée à la plus faible : never > void > unknown > any. Utilisez des types plus sûrs chaque fois que possible.
Résumé
Comprendre ces quatre types spéciaux est très important pour écrire du code TypeScript de haute qualité.
- never:Ne renvoie jamais ; utilisé pour les vérifications exhaustives ; est un sous-type de tous les types.
- void:Aucune valeur de retour ; utilisé pour les fonctions ordinaires qui n'ont pas de valeur de retour.
- unknown:Type arbitraire sûr ; doit effectuer une vérification de type avant utilisation.
- any :Contourne toutes les vérifications de type ; à éviter autant que possible.
Autres extensionsRecommandations :Lors de l'écriture de code, privilégiez des types plus stricts. Utilisez unknown pour les données inconnues, void pour les fonctions sans valeur de retour, et never lorsque des vérifications exhaustives sont nécessaires.