any, le trou, ou éteindre la lumière any, the hole, or turning off the lights

any ne corrige rien. Il éteint la lumière — et le bug revient à l'exécution.any fixes nothing. It turns off the lights — and the bug returns at runtime.

C'est le réflexe qui ouvre le volume : un type récalcitrant, on met any, l'erreur disparaît, on passe à autre chose. Mais any n'est pas un type — c'est l'interrupteur qui débranche le vérificateur. La faute de frappe, le champ absent, la méthode inventée : tout passe. On n'a pas réglé le problème, on a juste éteint l'avertissement. Le bug, lui, attend tranquillement le runtime. C'est l'unsafe de TypeScript.It's the reflex that opens the volume: a stubborn type, you slap any on it, the error vanishes, you move on. But any isn't a type — it's the switch that unplugs the checker. The typo, the missing field, the invented method: all pass. You didn't solve the problem, you just turned off the warning. The bug, meanwhile, quietly waits for runtime. It's TypeScript's unsafe.

function totalPrice(cart: any): number {
  return cart.items.reduce((s, it) => s + it.prce, 0);
  //          ^ items peut être absent       ^ 'prce' : faute de frappe
}                          // aucune erreur : any a éteint TOUTE vérification
// 💥 au runtime : cart.items undefined → crash, ou un NaN qui se propage

type Cart = { items: { price: number }[] };

function totalPrice(cart: Cart): number {
  return cart.items.reduce((s, it) => s + it.prce, 0);
  //                                          ^ ✗ 'prce' n'existe pas — attrapé
}                          // le bug n'atteint jamais l'exécution

any ne reste pas où on l'a mis. Il déteint sur tout ce qu'il touche.any doesn't stay where you put it. It bleeds onto everything it touches.

On croit le any local — confiné à la variable qu'on a annotée. Faux. Tout ce qu'on dérive d'un any est, à son tour, any : un accès à une propriété, un retour de fonction, un élément de tableau. Une seule valeur any plantée au fond d'une chaîne recontamine, en silence, du code pourtant correct en aval. Le trou ne reste pas un trou : il s'étend.You think any is local — confined to the variable you annotated. Wrong. Anything derived from an any is, in turn, any: a property access, a function return, an array element. A single any value planted deep in a chain silently re-contaminates downstream code that was otherwise correct. The hole doesn't stay a hole: it spreads.

const data: any = fetchUntyped();   // une SEULE source d'any

const user = data.user;   // user : any   ← déteint
const name = user.name;   // name : any   ← déteint
const out  = name.toUpperCase().tooFixed();   // ✗ méthode inventée
//                              ^ aucune erreur : any a contaminé toute la chaîne
// 💥 au runtime : name.toUpperCase() est un string, .tooFixed n'existe pas

Le any de data coule dans user, puis name, puis l'appel final. Chaque maillon hérite du trou sans le moindre signal. Le code en aval avait l'air typé — il ne l'est plus, et personne ne l'a décidé. C'est ça, la vraie nuisance d'any : pas l'erreur qu'il masque, mais celles qu'il laissera passer ailleurs.The any on data flows into user, then name, then the final call. Each link inherits the hole without a single signal. The downstream code looked typed — it isn't anymore, and no one decided that. That's any's real harm: not the error it hides, but the ones it will let through elsewhere.

Le seul type à double sens — et celui qui s'invite sans qu'on l'écrive.The only two-way type — and the one that lets itself in unwritten.

Pourquoi any déteint ? Parce qu'il est assignable dans les deux sens : tout type monte dans any, et any redescend dans tout type. Un vrai type est à sens unique — il n'accepte que ce qui est compatible. any abolit la barrière dans les deux directions, et c'est exactement ce qui le fait couler partout. Pire : il n'a pas toujours besoin qu'on l'écrive. Sans annotation, certains endroits prennent un any implicite — d'où le drapeau noImplicitAny, le plus important du volume.Why does any bleed? Because it's assignable both ways: every type flows up into any, and any flows back down into every type. A real type is one-way — it only accepts what's compatible. any abolishes the barrier in both directions, and that's exactly what lets it flow everywhere. Worse: it doesn't always need to be written. Without an annotation, some spots take an implicit any — hence the noImplicitAny flag, the volume's most important.

let a: any = 5;
const s: string = a;   // ✓ any → string : descend dans N'IMPORTE QUEL slot typé
const n: number = a;   // ✓ any → number : aussi
let b: any;
b = "texte"; b = 42; b = {};   // ✓ tout → any : tout y monte aussi

function parse(input) {     // ✗ noImplicitAny : 'input' a un type any implicite
  return input.trim();      // …et on est déjà dans le trou
}

const xs = [];              // any[] implicite tant qu'on ne pousse rien de typé
xs.push(fnQuiRendAny());    // le trou entre sans qu'on ait jamais écrit 'any'

Le any qui « règle » l'erreur qu'on n'a pas pris le temps de lire.The any that "fixes" the error you didn't take the time to read.

Le piège n'est pas technique, il est de réflexe. Le compilateur souligne quelque chose qu'on ne comprend pas ; un as any, et le rouge disparaît. Mais cette erreur était un théorème : « cette valeur peut être absente », « ce champ n'existe pas ». La faire taire ne la rend pas fausse — on a juste supprimé l'énoncé, pas le bug. Et comme any déteint, on a rouvert le trou pour tout le code en aval.The trap isn't technical, it's reflexive. The compiler underlines something you don't understand; an as any, and the red disappears. But that error was a theorem: 'this value may be absent', 'this field doesn't exist'. Silencing it doesn't make it false — you only deleted the statement, not the bug. And since any bleeds, you reopened the hole for all the downstream code.

// L'erreur : "'response' is possibly 'undefined'." — on ne la lit pas, on l'écrase.
const value = (response as any).data.items[0].name;
//             ^ rouge éteint instantanément — et trois bugs avec lui :
//   response peut être null, data absent, items vide. Tout passe. 💥 au runtime

Le as any n'a pas répondu à la question du compilateur — il l'a censurée. Les trois risques qu'il signalait sont intacts, et la chaîne entière qui suit est désormais non vérifiée. On a échangé un avertissement précis contre un crash futur diffus.The as any didn't answer the compiler's question — it censored it. The three risks it flagged are intact, and the whole chain that follows is now unchecked. You traded a precise warning for a diffuse future crash.