unknown, any and never

Three special types, and the one-line definition of each:

• unknown — any value at all, and you may do nothing with it until you narrow it. The safe type for "I do not know yet".
• any — any value at all, and you may do anything with it. Not a type so much as the checker switched off.
• never — no value at all. The type of a function that never returns (it throws, or loops forever), and what is left of a union once every member has been ruled out.

unknown at the boundary

Everything that enters a program from outside — a request body, a file, a message from a queue — is unknown until checked. The trap is that several standard APIs hand it to you as any: JSON.parse, response.json() in the browser's typings, and anything typed loosely. An any can be assigned to any type without a check, so the "validation" is just an annotation:

1interface Order {2  id: string;3  quantity: number;4}5 6function isOrder(x: unknown): x is Order {7  return (8    typeof x === "object" &&9    x !== null &&10    typeof (x as Record<string, unknown>).id === "string" &&11    typeof (x as Record<string, unknown>).quantity === "number"12  );13}14 15export function run(): unknown[] {16  const body = '{"id":"A-1","quantity":"3"}';17 18  // any: accepted as an Order without a single check.19  const trusted: Order = JSON.parse(body);20  const doubled = trusted.quantity * 2;     // "3" * 2 happens to work...21  const plusOne = trusted.quantity + 1;     // ...and "3" + 1 does not22 23  // unknown: nothing is usable until the guard has proved it.24  const raw: unknown = JSON.parse(body);25  const verdict = isOrder(raw) ? "valid order" : "rejected at the boundary";26 27  return [doubled, plusOne, verdict];28}

Declare the parsed value as unknown instead, and the compiler refuses to let you touch it until a guard (or a schema library such as Zod) has proved its shape.

Caught errors are unknown

JavaScript lets you throw anything: an Error, a string, an object, a number. Under strict (the useUnknownInCatchVariables flag) the variable in catch (err) is therefore unknown, not Error. Casting it back is the usual mistake:

1function fail(kind: number): never {2  if (kind === 0) throw new Error("disk full");3  if (kind === 1) throw "timeout";4  throw { code: 503 };5}6 7export function run(): string[] {8  const out: string[] = [];9  for (const kind of [0, 1, 2]) {10    try {11      fail(kind);12    } catch (err) {13      // err is unknown under strict: anything at all can be thrown.14      const careless = (err as Error).message;15      const careful = err instanceof Error ? err.message : JSON.stringify(err);16      out.push(`${careless} | ${careful}`);17    }18  }19  return out;20}

Narrow with instanceof Error and decide what to do with everything else.

never, the exhaustiveness check

The never trick from the unions lesson has a runtime half. Data from outside can contain a member your union never listed — the server shipped a new status before your client did. An assertNever helper fails at compile time when you forget a case you know about, and throws a clear error at runtime for a case you did not:

1type Payment =2  | { status: "paid"; amount: number }3  | { status: "failed"; reason: string };4 5function assertNever(value: never): never {6  throw new Error(`Unexpected value: ${JSON.stringify(value)}`);7}8 9function summary(p: Payment): string {10  switch (p.status) {11    case "paid":12      return `paid ${p.amount}`;13    case "failed":14      return `failed: ${p.reason}`;15    default:16      return assertNever(p);17  }18}19 20export function run(): string[] {21  // The server started sending a status this code was never told about.22  const fromServer: Payment[] = JSON.parse(23    '[{"status":"paid","amount":20},{"status":"refunded","amount":20}]',24  );25  return fromServer.map((p) => {26    try {27      return summary(p);28    } catch (e) {29      return String(e);30    }31  });32}

Common mistakes

• Trusting JSON.parse. Its any flows into whatever type you write. In the example, "3" * 2 happened to work and "3" + 1 gave "31": the same bad value is right in one place and wrong in the next.
• (err as Error).message in a catch. For a thrown string or object that is undefined, and the log line says nothing.
• any "just for this one value". Everything derived from it is any too, so the hole grows silently through the code that uses it.
• Swallowing the impossible case. A default: return "" hides the new status; throwing via assertNever makes it loud.

What interviewers ask

• unknown or any for an API response? unknown, then a runtime check (a guard or a schema) that produces a typed value. any skips both the check and the type.
• What is the type of the variable in a clause? with (part of ), because any value can be thrown; narrow with .