Assertion de type TypeScript

L'assertion de type est un mécanisme qui indique au compilateur : « Je connais mieux que vous le type de cette valeur. » Elle permet aux développeurs de remplacer manuellement les résultats de l'inférence de type de TypeScript, comme la conversion de type dans d'autres langages, maiselle ne prend effet que pendant la phase de compilation et ne génère aucun code à l'exécution.。


Deux formes syntaxiques

Il existe deux façons d'écrire des assertions de type ; il est recommandé d'utiliser systématiquement laassyntaxe ; la syntaxe avec chevrons entre en conflit avec la syntaxe des balises dans les fichiers JSX.

Exemple

// ① Syntaxe avec chevrons (non recommandée, ne peut pas être utilisée dans les fichiers .tsx)
const str1: any = "hello";
const len1: number = (<string>str1).length;

// ② syntaxe as (recommandée)
const str2: any = "world";
const len2: number = (str2 as string).length;

console.log(len1);  // 5
console.log(len2);  // 5

Sortie :

5
5

Remarque :Dans les.tsxfichiers de React, la syntaxe à chevrons entre en conflit avec les balises JSX, donc laassyntaxe doit être utilisée.


Cas d'utilisation courants

1. Gestion des types any / unknown

Les données obtenues à partir d'interfaces externes, d'analyse JSON et d'autres scénarios sont généralementany; les assertions peuvent restaurer les indications de type.

Exemple

const response: any = { name: "Alice", age: 25 };

// Affirmer en tant que type spécifique pour obtenir des indications de type
const user = response as { name: string; age: nombre };

console.log(user.name);  // Alice
console.log(user.age);   // 25

Sortie :

Alice
25

2. Rétrécissement des types union

Lorsque vous connaissez la branche spécifique d'un type union mais que le compilateur ne peut pas la déterminer automatiquement, vous pouvez utiliser une assertion pour spécifier clairement le type.

Exemple

type Shape =
    | { kind: "circle"; radius: number }
    | { kind: "rect"; width: number; height: number };

function getArea(shape: Shape): number {
    if (shape.kind === "circle") {
        return Math.PI * (shape as { kind: "circle"; radius: number }).radius ** 2;
    }
    const rect = shape as { kind: "rect"; width: number; height: number };
    return rect.width * rect.height;
}

console.log(getArea({ kind: "circle", radius: 5 }).toFixed(2));  // 78.54
console.log(getArea({ kind: "rect", width: 4, height: 6 }));     // 24

Sortie :

78.54
24

Astuce :Préférez utiliser des gardes de type (typeof / instanceof/ propriétés discriminantes) pour affiner les types ; n'utilisez des assertions que dans les scénarios que les gardes ne peuvent pas couvrir.

3. Manipulation des éléments DOM

document.querySelectorLe type de retour estElement | null; ce n'est qu'après avoir effectué une assertion sur son type d'élément spécifique que vous pouvez accéder à ses propriétés exclusives.

Exemple

// querySelector renvoie Element | null
const input = document.querySelector("#username") as HTMLInputElement;

// Après l'assertion, vous pouvez accéder aux propriétés exclusives de HTMLInputElement
// console.log(input.value);

// Approche plus sûre : vérifier d'abord la valeur null, puis affirmer
const btn = document.querySelector("#submit");
if (btn) {
    (btn as HTMLButtonElement).disabled = true;
}

Assertion de non-nullité !

Add!après la valeur pour indiquer au compilateur que la valeur n'est pasnullouundefined; convient aux scénarios où vous êtes sûr qu'elle n'est pas nulle, mais que le compilateur ne peut pas l'inférer.

Exemple

function printLength(str?: string) {
    // Utilisez ! pour affirmer que str a bien une valeur
    console.log(str!.length);
}

// S'exécute normalement
printLength("hello");  // 5

// Erreur d'exécution : Impossible de lire les propriétés de undefined
// printLength();

Sortie :

5

Avertissement :L'assertion de non-nullité contourne le contrôle de nullité du compilateur ; si la valeur réelle estnull / undefined, elle lèvera quand même une erreur à l'exécution. Lorsque les conditions le permettent, préférez utiliser le chaînage optionnel?.à la place.


Assertion const avec as const

as constInfère les littéraux comme les types littéraux readonly les plus étroits, couramment utilisés pour définir des valeurs d'énumération, des constantes de configuration et des tuples.

Exemple

// Déclaration normale : inférée comme string[], les éléments sont modifiables
const colors1 = ["red", "green", "blue"];
colors1.push("yellow");  // Autorisé

// as const : inféré comme readonly ["red", "green", "blue"] ; les éléments et la longueur sont immuables
const colors2 = ["red", "green", "blue"] as const;
// colors2.push("yellow"); // Erreur : impossible d'ajouter à un tableau en lecture seule

// Idem pour les objets : toutes les propriétés deviennent des types littéraux en lecture seule
const config = {
    host: "localhost",
    port: 3000
} as const;
// config.port = 8080; // Erreur : la propriété en lecture seule ne peut pas être modifiée

console.log(colors2);         // ['red', 'green', 'blue']
console.log(config.host);     // localhost
console.log(config.port);     // 3000

Sortie :

['red', 'green', 'blue']
localhost
3000

L'assertion n'est pas une conversion de type

L'assertion de type n'affecte que la vérification de type du compilateur et ne génère aucun code de conversion après compilation. Lorsqu'on affirme"42"asnumber, à l'exécution, il s'agit toujours d'une chaîne.

Exemple

const strNum: any = "42";

// Affirmé comme un nombre, mais à l'exécution, c'est toujours une chaîne
const wrongNum = strNum as number;
console.log(typeof wrongNum);    // string (pas number !)
console.log(wrongNum + 1);       // 421 (concaténation de chaînes, pas une addition numérique)

// La véritable conversion de type nécessite des fonctions de conversion
const realNum = Number(strNum);
console.log(typeof realNum);     // number
console.log(realNum + 1);        // 43

Sortie :

string
421
number
43

Double assertion

Lorsqu'il n'y a pas de chevauchement entre deux types, TypeScript refusera une assertion directe. Dans ce cas, vous pouvez utiliserunknowncomme intermédiaire, mais c'est une opération dangereuse et à éviter autant que possible.

Exemple

const num = 42;

// Assertion directe : number et string n'ont pas de chevauchement, le compilateur signale une erreur
// const str = num as string;

// Double assertion : d'abord une assertion en unknown, puis une assertion vers le type cible
const str = num as unknown as string;

console.log(str);          // 42
console.log(typeof str);   // number (type à l'exécution inchangé ; l'assertion ne prend effet qu'à la compilation)

Sortie :

42
number

Avertissement :La double assertion contourne complètement le système de types de TypeScript et peut facilement provoquer des erreurs d'exécution. Ne l'utilisez que dans des cas particuliers, comme des types inexacts dans des bibliothèques tierces, et indiquez la raison dans le code.


Comparaison des méthodes d'assertion

Méthode d'assertion Syntaxe Scénario typique Risque
Assertion avec asvalue as TypeConversion de any vers un type spécifique, opérations DOMFaible (effectue une vérification de chevauchement)
Assertion non nullevalue!Confirmation de l'absence de null/undefinedMoyen (ignore la vérification null)
Assertion constvalue as constConstantes littérales, valeurs d'énumérationAucune
Double assertionvalue as unknown as TConversion forcée lorsque les types n'ont aucun chevauchementÉlevé (contourne complètement les vérifications)

Résumé

  • Sélection de syntaxe :Utilisez systématiquement laassyntaxe, et évitez la syntaxe à chevrons dans JSX
  • Assertion vs. conversion :L'assertion n'affecte que les types à la compilation et ne produit aucun code à l'exécution ; une véritable conversion de valeur nécessite d'utiliserNumber()、String()et d'autres fonctions similaires
  • Assertion non-null :Avant d'utiliser!, assurez-vous que la valeur est réellement non-null ; sinon, une erreur se produira à l'exécution. Lorsque les conditions le permettent, préférez utiliser?.
  • Assertion const :as constest une assertion sûre et pratique, recommandée pour les objets de configuration et les tableaux constants
  • Double assertion :est le dernier recours ; vous devez commenter la raison lors de son utilisation

Autres contenus associés