Assertions doubles et leurs risques
Comprendre quand as unknown as T est nécessaire et pourquoi cette pratique est dangereuse.
Assertions doubles et leurs risques est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 4 leçons au total.
Qu’est-ce qu’une double assertion ?
Une double assertion enchaîne deux conversions as, généralement via unknown : value as unknown as T. Elle force une conversion que le compilateur refuserait autrement.
const s = 'hello';
const n = s as unknown as number; // forced
console.log(typeof n); // still 'string' at runtime!Pourquoi TS bloque les conversions directes
TypeScript bloque s as number lorsque string et number ne se recouvrent pas, car il s’agit presque certainement d’une erreur. Cette erreur vous protège contre les assertions absurdes.
const s = 'text';
// const n = s as number; // Error: types do not sufficiently overlap
console.log('Direct unrelated assertion is rejected');Comment le type inconnu permet la conversion
Tout type peut être affecté à unknown, et unknown peut faire l’objet d’une assertion vers n’importe quel type. Passer par ce type respecte la règle de recouvrement en deux étapes et contourne entièrement la vérification de sécurité.
const s = 'text';
const step1 = s as unknown; // always allowed
const step2 = step1 as number; // allowed from unknown
console.log(typeof step2);La double assertion trompe le compilateur
Le résultat est compilé, mais la valeur à l’exécution reste inchangée. Vous avez indiqué au système de types quelque chose de faux. Tout code ultérieur qui fait confiance au type indiqué peut tomber en panne de manière imprévisible.
const fake = 'oops' as unknown as number;
console.log(fake + 1); // 'oops1' — string concatenation at runtimeUn mauvais usage réaliste
Les développeurs utilisent parfois une double assertion pour faire taire les erreurs lorsque les structures ne correspondent pas. Cela dissimule de véritables bogues : la valeur n’a jamais réellement possédé les propriétés annoncées.
type User = { id: number; name: string };
const partial = { id: 1 };
const user = partial as unknown as User;
console.log(user.name); // undefined at runtimeQuand une double assertion est nécessaire
Elle peut parfois être légitime — par exemple pour relier des types de bibliothèques incompatibles dont vous savez qu’ils sont compatibles structurellement à l’exécution, ou dans du code de bas niveau lorsque vous connaissez réellement la disposition de la mémoire. Ces cas sont rares.
// Bridging a known-compatible external type:
type LibA = { value: number };
type LibB = { value: number };
const a: LibA = { value: 5 };
const b = a as unknown as LibB; // structurally identical
console.log(b.value);Pourquoi c’est une odeur de code
Une double assertion indique que vous passez outre le système de types au lieu de travailler avec lui. Chacune d’elles est un endroit où le compilateur ne peut plus vous protéger ; les personnes chargées de la revue doivent donc examiner attentivement chaque occurrence.
// Treat 'as unknown as' as a red flag in code review.
const data: unknown = JSON.parse('{}');
// Better: validate with a type guard instead of forcing.
console.log('Prefer validation over double assertion');Privilégiez la validation
Au lieu de forcer un type, validez les données et affinez leur type. Une garde de type prouve la structure à l’exécution et vous fournit le même résultat typé sans tromper le compilateur.
type User = { id: number; name: string };
function isUser(v: unknown): v is User {
return typeof v === 'object' && v !== null &&
'id' in v && 'name' in v;
}
const raw: unknown = { id: 1, name: 'Sam' };
if (isUser(raw)) console.log(raw.name);Privilégiez une conversion correcte
Si vous avez réellement besoin d’un autre type à l’exécution, convertissez la valeur au lieu de faire une assertion. La conversion modifie les données ; l’assertion ne modifie que l’étiquette.
const s = '42';
const n = Number(s); // real conversion
console.log(n + 1, typeof n);Documentez le cas valide rare
Lorsqu’une double assertion est réellement justifiée, ajoutez un commentaire expliquant pourquoi elle est sûre. Les personnes qui assureront la maintenance doivent connaître la garantie à l’exécution qui rend la conversion fiable.
type Raw = { ts: number };
type Event = { ts: number };
const raw: Raw = { ts: 100 };
// Safe: Raw and Event are structurally identical.
const ev = raw as unknown as Event;
console.log(ev.ts);Résumé des recommandations
Règle générale : si vous écrivez as unknown as, arrêtez-vous et demandez-vous si une validation ou une conversion serait plus sûre. Neuf fois sur dix, ce serait le cas.
// Decision: validate? convert? or genuinely bridge identical types?
const input = '7';
const parsed = Number.parseInt(input, 10); // convert, don't force
console.log(parsed);Vérification rapide
Vérifiez votre compréhension des doubles assertions.
Récapitulatif : doubles assertions
Vous avez appris que :
value as unknown as Tforce une conversion que TypeScript refuserait autrement.- Cela fonctionne parce que
unknownse recouvre avec tous les types — mais cela ne change rien à l’exécution. - C’est une odeur de code : vous passez outre le système de types et perdez sa protection.
- Privilégiez la validation (gardes de type) ou une véritable conversion.
Ensuite, comparaison directe des assertions et des gardes de type.
// Validate, don't force:
const raw: unknown = '99';
const n = typeof raw === 'string' ? Number(raw) : 0;
console.log(n);
Apprends TypeScript avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 101
- Leçons
- 352
Questions Fréquemment Posées
La leçon « Assertions doubles et leurs risques » est-elle gratuite ?
Oui — le texte complet de « Assertions doubles et leurs risques » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Assertions doubles et leurs risques » ?
Comprendre quand as unknown as T est nécessaire et pourquoi cette pratique est dangereuse. Tu pratiques TypeScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer TypeScript Academy ?
Aucune expérience préalable n'est requise. TypeScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Assertions doubles et leurs risques » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon TypeScript Academy ?
Oui. Chaque leçon TypeScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Le mot-clé as pour les assertions de type
- Opérateur d’assertion de non-nullité
- Assertions doubles et leurs risques
- Assertions et gardes de type