any, unknown, never, Literal Types and Enums

A few special types do a lot of work in real code. unknown safely represents "I don't know yet" (unlike the dangerous any), never marks impossible cases, and literal types let a variable hold only specific values like "pending" | "shipped". Knowing when to use each – and when to avoid enums – is a mark of an experienced TypeScript developer.

any vs unknown

const fromApi: any = JSON.parse('{"name":"Asha"}');
console.log(fromApi.name.toUpperCase());        // compiles: any switches checking off
// fromApi.age.toFixed(2) would also compile – and crash at run time

const safe: unknown = JSON.parse('{"name":"Ravi","age":21}');
// safe.name;                                  // error: 'safe' is of type 'unknown'
if (typeof safe === "object" && safe !== null && "name" in safe && typeof safe.name === "string") {
  console.log(safe.name.toUpperCase());         // allowed after checking
}

ASHA
RAVI

void and never

function logVisit(page: string): void {        // returns nothing useful
  console.log(`visited ${page}`);
}

function fail(message: string): never {        // never returns normally
  throw new Error(message);
}

function parsePercent(text: string): number {
  const n = Number(text);
  if (Number.isNaN(n) || n < 0 || n > 100) fail(`invalid percent: ${text}`);
  return n;                                    // TypeScript knows fail() didn't return
}

logVisit("/learning/typescript");
console.log(parsePercent("87"));
try {
  parsePercent("120");
} catch (e) {
  console.log(e instanceof Error ? e.message : e);
}

visited /learning/typescript
87
invalid percent: 120

void means "returns nothing you should use". never means "this can never happen" – a function that always throws or loops forever, or a variable in a branch that's impossible. Chapter 5 uses never for exhaustiveness checks.

Literal types and as const

type Status = "pending" | "shipped" | "delivered";   // only these three strings
type Rating = 1 | 2 | 3 | 4 | 5;

let status: Status = "pending";
status = "shipped";
// status = "lost";                                 // error: not assignable to type 'Status'

function rate(stars: Rating): string { return "★".repeat(stars); }
console.log(status, rate(4));

const config = { env: "production", retries: 3 } as const;   // deeply readonly, literal types
// config.retries = 5;                             // error: retries is read-only
const roles = ["admin", "editor", "viewer"] as const;
type Role = (typeof roles)[number];                 // "admin" | "editor" | "viewer"
const r: Role = "editor";
console.log(config.env, roles.length, r);

shipped ★★★★
production 3 editor

as const freezes the types of a literal: strings stay literal ("production", not string) and everything becomes readonly. Deriving Role from the roles array keeps the list and the type in sync automatically.

Enums vs union types

enum Direction { Up, Down, Left, Right }                 // numeric enum: 0, 1, 2, 3
enum LogLevel { Info = "INFO", Warn = "WARN", Error = "ERROR" }   // string enum

console.log(Direction.Left, Direction[2], LogLevel.Warn);

type Level = "INFO" | "WARN" | "ERROR";                  // the union-type alternative
function log(level: Level, msg: string): void { console.log(`[${level}] ${msg}`); }
log("WARN", "disk 90% full");
log(LogLevel.Error, "service down");                     // a string enum value is assignable

2 Left WARN
[WARN] disk 90% full
[ERROR] service down

Practice

Summary