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 Background Title Comparison of Four Special Types any Arbitrary type Bypasses type checking No safety unknown Safe arbitrary type Requires checking before use Has safety void No return value Used for functions Can return undefined never Never returns Throws exception / loops Subtype of all types Arrow marker Lower section: type safety levels Type safety levels Level 1 any (lowest) Completely bypasses type checking Level 2 unknown Requires type checking before use Level 3 void Function has no return value Level 4 never (highest) Strictest and safest

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

// Fonction qui lève une exception
// 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

// Fonction sans valeur de retour
// 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

// unknown accepte n'importe quel type
// 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

// any peut être n'importe quel type
// 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

// Définir un type union de formes
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.

Recommandations :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.

Autres extensions