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
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
// 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
| { 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
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
// 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 est
null/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
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
// 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
// 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 as | value as Type | Conversion de any vers un type spécifique, opérations DOM | Faible (effectue une vérification de chevauchement) |
| Assertion non nulle | value! | Confirmation de l'absence de null/undefined | Moyen (ignore la vérification null) |
| Assertion const | value as const | Constantes littérales, valeurs d'énumération | Aucune |
| Double assertion | value as unknown as T | Conversion 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 la
assyntaxe, 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'utiliser
Number()、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