unknown, l'inconnu honnête, ou je ne sais pas, alors prouve-le unknown, the honest unknown, or I don't know, so prove it

Même aveu qu'any — « je ne connais pas ce type » — mais unknown refuse qu'on s'en serve.Same admission as any — "I don't know this type" — but unknown refuses to let you use it.

Le numéro précédent a montré le trou. Voici son jumeau honnête. unknown dit exactement la même chose qu'any : « le type de cette valeur m'échappe ». Mais là où any te laisse agir à l'aveugle — et le bug revient au runtime — unknown ferme la porte : tant que tu n'as pas prouvé ce que tu tiens, tu ne peux rien en faire. Le cas canonique, c'est le catch : une exception peut être n'importe quoi, et seul unknown t'oblige à le reconnaître.The previous issue showed the hole. Here's its honest twin. unknown says exactly what any says: 'I don't know this value's type'. But where any lets you act blindly — and the bug returns at runtime — unknown shuts the door: until you've proven what you hold, you can do nothing with it. The canonical case is catch: an exception can be anything, and only unknown forces you to admit it.

try {
  risky();
} catch (e: any) {                  // any : on fait ce qu'on veut de e
  console.log(e.message.toUpperCase());
  //          ^ et si le code a fait 'throw "panne"' ou 'throw 42' ?
}                                   // 💥 e.message est undefined — crash dans le catch

try {
  risky();
} catch (e: unknown) {              // unknown : on ne peut RIEN faire sans prouver
  if (e instanceof Error) {
    console.log(e.message.toUpperCase());   // ✓ ici e : Error — prouvé
  } else {
    console.log("erreur non-Error :", e);   // l'autre cas, géré honnêtement
  }
}

Sur un unknown nu, rien ne compile. Pas même .toString().On a bare unknown, nothing compiles. Not even .toString().

Premier contact, on le trouve hostile : impossible de lire une propriété, d'appeler, d'additionner, ni même d'assigner à un type. Le compilateur refuse tout. C'est exactement l'inverse d'any, et c'est voulu. any est assignable dans les deux sens — tout y monte, et il redescend partout. unknown n'est assignable que dans un sens : tout y monte, mais il ne redescend dans rien. Cette asymétrie est tout le mécanisme : elle force la preuve avant l'usage.First contact, you find it hostile: you can't read a property, call it, add to it, or even assign it to a type. The compiler refuses everything. It's the exact opposite of any, and it's deliberate. any is assignable both ways — everything flows up, and it flows back down everywhere. unknown is assignable one way only: everything flows up, but it flows back down into nothing. That asymmetry is the whole mechanism: it forces proof before use.

const x: unknown = getValue();

x.foo;          // ✗ 'x' is of type 'unknown'
x();            // ✗ 'x' is of type 'unknown'
x + 1;          // ✗ 'x' is of type 'unknown'
x.toString();   // ✗ même ça : RIEN n'est permis sans preuve
const s: string = x;   // ✗ unknown ne redescend dans aucun type

Le « mur » n'est pas une punition, c'est la garantie : tant que tu n'as rien prouvé, tu ne peux rien casser. Chaque ligne refusée est une question que le compilateur te pose — « es-tu sûr que c'est un objet ? une fonction ? un nombre ? » — et qu'il t'oblige à répondre avant d'agir.The "wall" isn't a punishment, it's the guarantee: as long as you've proven nothing, you can break nothing. Each refused line is a question the compiler asks you — "are you sure it's an object? a function? a number?" — and forces you to answer before acting.

On ouvre un unknown par narrowing — le Vol 2, réemployé comme clé.You open an unknown by narrowing — Vol 2, reused as the key.

Le mécanisme pour sortir du mur est exactement celui du Vol 2 : rétrécir. typeof pour les primitives, instanceof pour les classes, in et les type guards pour les objets. Chaque test fait passer x d'unknown à un type concret, et débloque ce qu'on peut faire avec dans la branche. unknown est le type top — le supertype de tout —, exactement le miroir de never, le type bottom du 3.2. L'un dit « ça peut être n'importe quoi », l'autre « ça ne peut rien être ».The mechanism for leaving the wall is exactly Vol 2's: narrowing. typeof for primitives, instanceof for classes, in and type guards for objects. Each test moves x from unknown to a concrete type, and unlocks what you can do with it in the branch. unknown is the top type — the supertype of everything — exactly the mirror of never, the bottom type from 3.2. One says 'it can be anything', the other 'it can be nothing'.

function len(x: unknown): number {
  if (typeof x === "string") return x.length;       // x : string
  if (Array.isArray(x))      return x.length;        // x : unknown[]
  if (x instanceof Set)      return x.size;          // x : Set<unknown>
  return 0;                                          // tous les autres cas
}

// unknown et never sont les deux pôles du système de types :
declare const top: unknown;    // TOUT est un unknown      (le supertype universel)
declare const bottom: never;   // RIEN n'est un never       (le sous-type universel)
const x: unknown = bottom;     // ✓ never → unknown
const y: never = top;          // ✗ unknown ne redescend nulle part, never encore moins

Rétrécir un unknown avec as, c'est rouvrir le trou — en plus cérémonieux.Narrowing an unknown with as reopens the hole — just more ceremoniously.

unknown ne vaut que par le mur qu'il dresse. Et il y a une façon de le contourner sans le franchir honnêtement : le caster. as User ne prouve rien — il affirme. La valeur n'a pas été vérifiée, le compilateur se tait parce qu'on le lui a ordonné, et le crash revient comme avec any. On a payé la cérémonie d'unknown sans en toucher la garantie : le pire des deux mondes.unknown is only worth the wall it raises. And there's a way around it without honestly crossing it: casting. as User proves nothing — it asserts. The value wasn't checked, the compiler goes quiet because you ordered it to, and the crash returns just like with any. You paid unknown's ceremony without getting its guarantee: the worst of both worlds.

const data: unknown = JSON.parse(raw);

const user = data as User;        // ✗ on n'a rien prouvé — juste affirmé
console.log(user.name.trim());    // 💥 si data n'a pas de .name : crash
// unknown rétréci par 'as' = any avec deux mots de plus. Le mur est contourné.

Le as User dit au compilateur « crois-moi », sans le moindre contrôle à l'exécution. C'est exactement le type guard menteur du 2.3, et le retour silencieux d'any du numéro précédent. Le contre-exemple obligatoire : unknown suivi d'un as non justifié n'apporte rien — autant assumer le trou.The as User tells the compiler "trust me", with zero runtime check. It's exactly the lying type guard of 2.3, and the silent return of any from the previous issue. The mandatory counter-example: unknown followed by an unjustified as brings nothing — you may as well own the hole.