as & les assertions, ou tais-toi, je sais mieux as & assertions, or be quiet, I know better

as n'est pas une conversion. C'est une signature : « tais-toi, je sais mieux. »as isn't a conversion. It's a signature: "be quiet, I know better."

Venant de Java ou C#, on lit as comme un cast : une opération qui vérifie ou convertit à l'exécution. En TypeScript, rien de tel. as ne touche pas la valeur et n'exécute aucun code — il change seulement ce que le compilateur croit. C'est un contrat qu'on signe à sa place : « cette valeur est un User, je m'en porte garant ». Si on a tort, le compilateur s'est tu pour rien, et le bug revient intact au runtime.Coming from Java or C#, you read as as a cast: an operation that checks or converts at runtime. In TypeScript, nothing of the sort. as doesn't touch the value and runs no code — it only changes what the compiler believes. It's a contract you sign in its place: 'this value is a User, I vouch for it'. If you're wrong, the compiler went quiet for nothing, and the bug returns intact at runtime.

const user = JSON.parse(raw) as User;   // ✗ ressemble à une conversion — n'en est pas
user.name.trim();                       // le compilateur est muet…
// 💥 si le JSON n'a pas de .name : crash. 'as' n'a RIEN vérifié, RIEN converti.

// Le DOM renvoie le type large HTMLElement | null. MOI, je sais que c'est un input :
const input = document.getElementById("email") as HTMLInputElement;
input.value;   // ✓ justifiable — je l'ai écrit dans le HTML, le compilateur ne le voit pas
// L'invariant que j'affirme, je peux l'énoncer. C'est ça, un 'as' légitime.
// (Il efface aussi le '| null' : si l'id quitte le HTML, c'est un crash — à assumer.)

as renomme le type, jamais la valeur. À l'exécution, il n'a jamais existé.as renames the type, never the value. At runtime, it never existed.

La preuve que as ne convertit rien : forçons un string en number par une double assertion. Le compilateur nous croit et raisonne sur un number. Mais à l'exécution, la valeur est restée le string "3" — alors n + 1 fait une concaténation et produit "31", sans la moindre erreur. as s'est effacé, comme tout type (Vol 2). Une vraie conversion, elle, est du code qui s'exécute et change réellement la valeur.The proof that as converts nothing: let's force a string into a number with a double assertion. The compiler believes us and reasons about a number. But at runtime, the value stayed the string "3" — so n + 1 does a concatenation and yields "31", without a single error. as erased itself, like every type (Vol 2). A real conversion, by contrast, is code that runs and actually changes the value.

const n = "3" as unknown as number;   // le compilateur croit : number
const r = n + 1;                       // il croit : 4
console.log(r);                        // 💥 "31" — JS a fait une concaténation
console.log(typeof n);                 // "string" — la valeur n'a JAMAIS changé

Le as unknown as number a convaincu le compilateur, pas le moteur JavaScript. La valeur est restée un string ; seul son type a menti, le temps de la compilation. À l'exécution il ne reste que la valeur nue — et un + qui concatène. L'assertion n'a rien produit qu'un faux espoir.The as unknown as number convinced the compiler, not the JavaScript engine. The value stayed a string; only its type lied, for the duration of compilation. At runtime only the bare value remains — and a + that concatenates. The assertion produced nothing but false hope.

Une famille d'assertions — dont une seule ne ment jamais.A family of assertions — only one of which never lies.

as T affirme un type. x! est le as du null : « pas null, pas undefined ». as unknown as T force deux types sans recouvrement — l'aveu le plus bruyant. Et puis il y a as const, le seul honnête : il ne ment pas, il demande au compilateur d'inférer plus précisément (littéraux, readonly). TypeScript pose d'ailleurs un garde-fou : il refuse un as entre deux types qui ne se recouvrent pas — c'est pourquoi il faut passer par unknown pour mentir tout à fait.as T asserts a type. x! is the as of null: 'not null, not undefined'. as unknown as T forces two non-overlapping types — the loudest admission. And then there's as const, the only honest one: it doesn't lie, it asks the compiler to infer more precisely (literals, readonly). TypeScript even sets a guardrail: it refuses an as between two non-overlapping types — which is why you must go through unknown to lie outright.

const el = ref.current as HTMLInputElement;   // as T : « c'est un input »
const x  = maybe!;                            // x! : « ce n'est pas null/undefined »
const cfg = { mode: "dark" } as const;        // as const : fige en littéral readonly
const n  = "3" as unknown as number;          // as unknown as : forcer l'incompatible

const n = "3" as number;   // ✗ Conversion of type 'string' to 'number' may be
                           //   a mistake... — TS refuse le saut direct
// Pour passer outre, il FAUT élargir d'abord : "3" as unknown as number.
// Cette obligation est un signal : tu sors des types qui se recouvrent.

Le as sur une donnée du dehors : un any qu'on a juste rebaptisé.The as on outside data: an any you merely renamed.

C'est le contre-exemple obligatoire du volume. fetch().json() renvoie any ; on pose as ApiResponse pour faire passer les types, et le code compile, vert, rassurant. Mais on n'a rien vérifié : on a pris le trou d'any et on lui a collé une étiquette de type. Le premier champ manquant rétablit le crash, à des écrans de distance de la cause. Ce qu'il fallait faire, c'est valider la donnée là où elle entre.This is the volume's mandatory counter-example. fetch().json() returns any; you slap on as ApiResponse to make the types pass, and the code compiles, green, reassuring. But you checked nothing: you took any's hole and stuck a type label on it. The first missing field restores the crash, screens away from the cause. What you needed to do was validate the data where it enters.

interface ApiResponse { items: Item[] }

const res = await fetch("/api/items");
const data = await res.json() as ApiResponse;   // ✗ zéro vérification

data.items.map(renderItem);   // 💥 si la réponse n'a pas 'items' : crash
// Le 'as' a rebaptisé un any (le retour de .json()) en mensonge typé.

L'interface décrit un espoir ; le as ordonne au compilateur d'y croire. Aucune ligne ne regarde la donnée reçue. On a transformé un any honnêtement dangereux en un type faussement sûr — le pire des deux, parce qu'il inspire confiance.The interface describes a hope; the as orders the compiler to believe it. No line looks at the received data. You turned an honestly dangerous any into a falsely safe type — the worst of both, because it inspires confidence.