TypeScript 18 🔷 Unknown, any, and never - KandZ

TypeScript has three types that sit outside the normal type hierarchy: unknown, any, and never. They’re the top, middle, and bottom of the type system — the three extremes. unknown is the top type — everything is assignable to it, but you can’t use it without narrowing. any is the escape hatch — everything is assignable to it and it’s assignable to everything. never is the bottom type — nothing is assignable to it, and it’s assignable to everything. Each has a purpose. Mixing them up causes bugs.

Key point: unknown is safe and narrow. any is unsafe and wide. never is empty and perfect for exhaustiveness. The order of preference is unknown first, never for exhaustiveness, and any only when there’s no alternative. Almost every use of any in a codebase should be unknown instead.

The three extremes

The type system has a top, a bottom, and a trap door.

Type	Assignable to it	Assignable from it	Safe?
`unknown`	Everything	Nothing without narrowing	✅
`any`	Everything	Everything	❌
`never`	Nothing	Everything	✅

Reading the table:

unknown accepts any value, but you can’t use it until you narrow
any accepts any value and can be used as anything — no checks
never accepts no values, but can be used anywhere

Where each sits:

┌──────────────────────────────────────────────┐
│                                              │
│             unknown  (top)                   │
│                │                             │
│                │  every type is              │
│                │  assignable to it           │
│                ▼                             │
│           ┌──────────┐                       │
│           │  any     │  (both directions)    │
│           └──────────┘                       │
│                │                             │
│                ▼                             │
│             never  (bottom)                  │
│                every type                   │
│                is assignable                │
│                from it                       │
│                                              │
└──────────────────────────────────────────────┘

Why three: They serve different purposes. unknown is for values whose type you don’t know yet. any is for when TypeScript’s type system can’t help. never is for values that don’t exist — unreachable code, empty unions, impossible types.

Why they exist: A type system needs a top and a bottom to be complete. unknown is the top — the widest possible type. never is the bottom — the narrowest. any is a non-type, an escape from the system itself. Understanding where each fits makes you deliberate about using them.

`unknown` — the safe top

unknown is the top type. Any value is assignable to unknown, but you can’t use unknown as anything until you narrow it.

let value: unknown = 42;
value = 'hello';                  // ✅ any type is assignable
value = { id: 1 };                // ✅

value.toUpperCase();              // ❌ can't use unknown
if (typeof value === 'string') {
  value.toUpperCase();            // ✅ narrowed
}

The rules:

Everything is assignable to unknown
unknown is assignable only to unknown or any
You must narrow before using the value

Where unknown shines:

External data — JSON.parse, fetch().json(), user input, file contents
API boundaries — values from untyped or loosely typed libraries
Public function parameters — when the function accepts anything but must validate
Catch variables — catch (e) under useUnknownInCatchVariables

JSON.parse returns any by default — but you can treat it as unknown:

const data: unknown = JSON.parse(input);
// Now you must validate before use
if (isUser(data)) {
  console.log(data.name);         // ✅
}

Catch variables:

try {
  doThing();
} catch (err) {
  // err is unknown under strict
  if (err instanceof Error) {
    console.error(err.message);   // ✅
  } else {
    console.error('Unknown error');
  }
}

useUnknownInCatchVariables (part of strict) makes err unknown instead of any. This is a significant safety improvement — you’re forced to handle errors properly.

unknown in functions:

function handle(value: unknown): void {
  if (typeof value === 'number') {
    // value is number
  } else if (typeof value === 'string') {
    // value is string
  }
  // value is unknown here
}

The narrowing toolkit works on unknown — typeof, instanceof, in, predicates.

Why unknown is safe: You can’t accidentally use it. Every read requires narrowing. That’s the entire point — it forces the boundary between untyped data and typed code.

Why unknown is the “safe any”: It has the same acceptance range — anything can be assigned — but it can’t be used without narrowing. Where any silently lets you write code that crashes at runtime, unknown forces you to handle the types explicitly. It’s the type-safe version of a value you don’t know yet.

`any` — the escape hatch

any is a non-type. It’s assignable to and from everything, and TypeScript turns off checking for anything involving any.

let value: any = 42;
value = 'hello';                  // ✅
value = { id: 1 };                // ✅

value.toUpperCase();              // ✅ no check — crashes at runtime if not a string
value.foo.bar.baz();              // ✅ no check — probably crashes

Why any is dangerous:

It disables type checking
It propagates — anything touching any becomes any
It hides real bugs
It makes refactoring unsafe

any propagation:

const a: any = { id: 1 };
const b = a.id;                    // b is any
const c = b + 1;                   // c is any
const d = c.toUpperCase();         // d is any — no error, will crash

Once a value is any, its downstream uses are unchecked. That spread is why any is so damaging — a single any can disable type checking across a large section of code.

Where any is legitimately used:

Migrating JavaScript code
Interop with libraries that have no types
Quick prototypes
TypeScript’s own internal types

Where any is not needed:

Where unknown will work
Where a proper type exists
Where a generic parameter would do
To silence compiler errors

noImplicitAny (part of strict) prevents implicit any:

function f(x) { }                  // ❌ implicit any under strict
function g(x: number) { }          // ✅

Explicit any still works, but implicit any — where the compiler would have inferred any because it couldn’t infer anything else — is rejected.

Alternatives to any:

Need	Better option
Unknown external data	`unknown`
“Anything works here”	`unknown` + validation
Generic flexibility	Type parameter `<T>`
JSON output	`unknown` then validate
Arbitrary object	`Record<string, unknown>`
Library without types	`unknown` + custom `.d.ts`
Silencing errors	Fix the type

Why any is not banned: TypeScript’s design team kept any because some scenarios genuinely need it — during migrations, when bridging untyped code. But the guidance is clear: prefer unknown in almost every case. any is a last resort, not a tool.

`never` — the empty bottom

never is the bottom type. Nothing is assignable to it, and it’s assignable to everything.

let x: never;
x = 1;                            // ❌
x = 'a';                          // ❌
// Nothing can be assigned to never.

Where never appears:

Functions that never return — throw or infinite loop
Exhaustiveness checks — the remainder after handling all cases
Impossible intersections — string & number
Conditional type filters — mapping a case to never

Function returns:

function fail(msg: string): never {
  throw new Error(msg);
}

Exhaustiveness:

function assertNever(x: never): never {
  throw new Error(`Unhandled: ${JSON.stringify(x)}`);
}

function handle(status: 'a' | 'b' | 'c'): string {
  switch (status) {
    case 'a': return 'A';
    case 'b': return 'B';
    case 'c': return 'C';
    default: return assertNever(status);  // status is never here
  }
}

Impossible types:

type Empty = string & number;     // never

Filtering:

type NonNullish<T> = T extends null | undefined ? never : T;

Why never matters: It’s how TypeScript proves exhaustiveness, marks unreachable code, and filters unions. Without it, exhaustiveness checking wouldn’t exist, and conditional types couldn’t express “this case disappears.”

Why the bottom type is useful: Type theory needs a bottom — a type with no instances. In TypeScript, that’s never. It represents the impossible: a value that can’t exist, code that can’t run, a union with no members. That emptiness is what enables exhaustiveness checks and unreachable-code detection.

The three types compared

A side-by-side view.

Property	`unknown`	`any`	`never`
Top of hierarchy	✅	❌	❌
Bottom of hierarchy	❌	❌	✅
Assignable to it	Everything	Everything	Nothing
Assignable from it	Nothing without narrowing	Everything	Everything
Usable without narrowing	❌	✅	N/A (no values)
Type checking	Full (after narrowing)	Disabled	Full
Safe?	✅	❌	✅
Common use	External data	Escape hatch	Exhaustiveness

Examples:

// unknown — safe but requires narrowing
function f1(x: unknown): string {
  if (typeof x === 'string') return x;
  return String(x);
}

// any — unsafe but no restrictions
function f2(x: any): string {
  return x.toUpperCase();  // no check, may crash
}

// never — no values, only return position
function f3(): never {
  throw new Error();
}

How each behaves with assignment:

Expression	Result
`const x: unknown = 42`	✅
`const x: unknown = 'hi'`	✅
`const x: any = 42`	✅
`const x: any = 'hi'`	✅
`const x: never = 42`	❌
`const x: string = unknownValue`	❌
`const x: string = anyValue`	✅
`const x: string = neverValue`	✅

How each interacts with function parameters:

Signature	Accepts
`(x: unknown) => void`	Any value
`(x: any) => void`	Any value
`(x: never) => void`	Nothing — rarely called

A never parameter effectively makes a function uncallable from typical code — useful for exhaustiveness helpers.

Why the comparison matters: They look similar but behave oppositely. unknown forces you to check; any disables checking; never can’t hold anything. Knowing which to reach for is the difference between safe code and silent bugs. The rule: unknown by default, never for exhaustiveness, any never.

Choosing between them

The decision tree is simple.

Use unknown when:

Receiving external data (JSON, API, user input, files)
A function accepts anything but must validate
You’re unsure of the type and want safety
Catching errors (catch variable)
Typing library interop you don’t fully trust

Use any when:

Migrating legacy code and need a temporary shortcut
Interfacing with untyped third-party code you can’t fix
Prototyping and will type later
Never as a permanent design choice

Use never when:

Exhaustiveness checking
Functions that never return
Filtering union members with conditional types
Signalling impossible branches
Bottom type operations

The rule of thumb:

Prefer unknown.
Use never for exhaustiveness.
Avoid any unless there's no alternative.

Common scenarios:

Scenario	Type
`JSON.parse` result	`unknown`
`fetch().json()` result	`unknown`
Catch variable	`unknown`
Event handler with unknown shape	`unknown`
Function returns from throw	`never`
Exhaustive switch default	`never`
Legacy library	Try `unknown` first

Migration path: When you find any in your code, ask:

Can this be unknown with validation? → Replace
Can this be a proper type? → Replace
Can this be generic? → Replace
Is any genuinely required? → Keep, with a comment

Most any uses become unknown with a guard or a proper type.

Why the preference is clear: unknown provides the same flexibility as any — accept anything — but requires explicit handling. That requirement is exactly what you want at boundaries. any lets you write code that type-checks but crashes. unknown forces the check that prevents the crash. There’s almost never a reason to pick any over unknown in new code.

Type narrowing from `unknown`

The narrowing toolkit works on unknown — it’s how you get from “unknown value” to “typed value.”

typeof:

function f(x: unknown): string {
  if (typeof x === 'string') return x.toUpperCase();
  if (typeof x === 'number') return x.toFixed(2);
  if (typeof x === 'boolean') return x ? 'yes' : 'no';
  return 'unknown';
}

instanceof:

function f(x: unknown): string {
  if (x instanceof Error) return x.message;
  if (x instanceof Date) return x.toISOString();
  return 'unknown';
}

in:

function f(x: unknown): string {
  if (typeof x === 'object' && x !== null && 'name' in x) {
    return String((x as { name: unknown }).name);
  }
  return 'unknown';
}

Type predicates:

function isUser(x: unknown): x is User {
  return (
    typeof x === 'object' &&
    x !== null &&
    'id' in x &&
    typeof (x as { id: unknown }).id === 'number' &&
    'name' in x &&
    typeof (x as { name: unknown }).name === 'string'
  );
}

function handle(x: unknown): void {
  if (isUser(x)) {
    console.log(x.name);          // ✅ x is User
  }
}

Array.isArray:

function f(x: unknown): string {
  if (Array.isArray(x)) {
    return `Array of ${x.length}`;
  }
  return 'not array';
}

Validation libraries: Use Zod, io-ts, Valibot, or similar for complex shapes.

import { z } from 'zod';

const UserSchema = z.object({
  id: z.number(),
  name: z.string()
});

const parsed = UserSchema.safeParse(data);
if (parsed.success) {
  parsed.data.name;               // ✅ typed
}

Why narrowing from unknown is the norm: External data starts as unknown. The way to typed data is narrowing — typeof, instanceof, in, predicates, or a validation library. Once narrowed, the rest of the code works on a specific type.

Why narrowing is required: unknown can hold anything — so TypeScript refuses to let you use it as anything specific. Narrowing is the process of proving the type at runtime. Once proven, TypeScript trusts the narrowed type and lets you use it. It’s the type-safe counterpart to JavaScript’s loose runtime checks.

The `any` trap

any doesn’t just disable checks for one value — it spreads.

any from a library:

import something from 'untyped-lib';  // something: any

const value = something.get();        // value: any
const result = value.foo.bar;         // result: any
result.nonexistent.method();          // ❌ no error — crashes at runtime

One any from an import taints everything downstream.

any in a generic:

function wrap<T>(value: T): T {
  return value;
}

const a = wrap(anything as any);      // a: any
const b = a.toUpperCase();            // b: any — no check

any in JSON:

const data = JSON.parse(input);       // any
data.user.name.toUpperCase();         // ✅ compiles — may crash

If data.user is undefined, the code crashes. With unknown, you’d need to narrow first.

any from callbacks:

const fn = (x: any) => x.toUpperCase();
[1, 2, 3].map(fn);                    // no error — crashes

How to detect any in your code:

Enable noImplicitAny (strict)
ESLint rule @typescript-eslint/no-explicit-any
Search for : any and as any
Use unknown in every location where any appeared

How to replace any:

// Before
function process(data: any) {
  return data.value;
}

// After
function process(data: unknown): string {
  if (typeof data === 'object' && data !== null && 'value' in data) {
    return String((data as { value: unknown }).value);
  }
  throw new Error('Invalid data');
}

The unknown version is longer but safe. It documents the shape and handles the failure case.

When any is truly unavoidable: Comment why. A code reviewer seeing any should immediately understand the reason — usually a library’s bad types.

// eslint-disable-next-line @typescript-eslint/no-explicit-any
const legacyResult: any = legacyLib.getResult();

Why any spreads: TypeScript’s type checker treats any as a wildcard. Any operation on an any produces another any. That cascading effect is why a single any can hide bugs across a whole module. unknown doesn’t spread — every operation on unknown requires narrowing, which produces a specific type.

A full example

A boundary handler that uses unknown to validate external data.

// ============================================
// TYPES
// ============================================

interface User {
  id: number;
  name: string;
  email: string;
}

// ============================================
// PREDICATE
// ============================================

function isUser(x: unknown): x is User {
  return (
    typeof x === 'object' &&
    x !== null &&
    'id' in x &&
    typeof (x as { id: unknown }).id === 'number' &&
    'name' in x &&
    typeof (x as { name: unknown }).name === 'string' &&
    'email' in x &&
    typeof (x as { email: unknown }).email === 'string'
  );
}

// ============================================
// BOUNDARY
// ============================================

async function fetchUser(id: number): Promise<User> {
  const res = await fetch(`/users/${id}`);
  const data: unknown = await res.json();  // unknown, not any

  if (!isUser(data)) {
    throw new Error('Invalid user payload');
  }

  return data;                              // ✅ narrowed to User
}

// ============================================
// ERROR HANDLING
// ============================================

function describeError(err: unknown): string {
  if (err instanceof Error) return err.message;
  if (typeof err === 'string') return err;
  return 'Unknown error';
}

// ============================================
// NEVER — EXHAUSTIVE
// ============================================

function assertNever(x: never): never {
  throw new Error(`Unhandled: ${JSON.stringify(x)}`);
}

type Status = 'idle' | 'loading' | 'ready' | 'error';

function label(s: Status): string {
  switch (s) {
    case 'idle': return 'Waiting';
    case 'loading': return 'Loading';
    case 'ready': return 'Ready';
    case 'error': return 'Failed';
    default: return assertNever(s);
  }
}

// ============================================
// USAGE
// ============================================

async function main(): Promise<void> {
  try {
    const user = await fetchUser(1);
    console.log(user.name);
  } catch (err) {
    console.error(describeError(err));
  }
}

console.log(label('idle'), label('ready'));

Every type at the boundary is unknown. Every function that throws or exhaustively checks returns never. No any anywhere.

What this demonstrates:

unknown for the JSON response
A predicate narrows to User
unknown for the catch variable
never for the throwing helper
assertNever for exhaustiveness

Why this shape: It’s how real boundary code should look. External data is unknown until validated. Errors are unknown until narrowed. Nothing is any. The type system protects the entire pipeline from a crash caused by incorrect assumptions about external data.

Complete Example Session

# ============================================
# PART 1: UNKNOWN BASICS
# ============================================

cat > unknown.ts << 'EOF'
let value: unknown = 42;
value = 'hello';
value = { id: 1 };

// value.toUpperCase();  // ❌ not allowed

if (typeof value === 'object' && value !== null) {
  console.log(Object.keys(value));
}

function handle(x: unknown): string {
  if (typeof x === 'string') return x.toUpperCase();
  if (typeof x === 'number') return x.toFixed(2);
  if (x instanceof Date) return x.toISOString();
  return 'unknown';
}

console.log(handle('hi'), handle(42), handle(new Date()), handle(null));
EOF

npx tsc --noEmit unknown.ts
# (no errors)

# ============================================
# PART 2: ANY PROPAGATION
# ============================================

cat > any.ts << 'EOF'
const data: any = { user: { name: 'Alice' } };

// No errors — but crashes at runtime if shape is wrong
console.log(data.user.name.toUpperCase());
console.log(data.missing.deep.value);  // ✅ compiles, ❌ crashes

// any propagates
const a = data.foo.bar.baz;  // a: any
console.log(a.whatever());   // ✅ compiles, crashes
EOF

npx tsc --noEmit any.ts
# (no errors — that's the problem)

# ============================================
# PART 3: NEVER AND EXHAUSTIVENESS
# ============================================

cat > never.ts << 'EOF'
function assertNever(x: never): never {
  throw new Error(`Unhandled: ${JSON.stringify(x)}`);
}

type Status = 'idle' | 'loading' | 'ready';

function message(s: Status): string {
  switch (s) {
    case 'idle': return 'Waiting';
    case 'loading': return 'Loading';
    case 'ready': return 'Ready';
    default: return assertNever(s);
  }
}

function fail(msg: string): never {
  throw new Error(msg);
}

console.log(message('idle'));
EOF

npx tsc --noEmit never.ts
# (no errors)

# ============================================
# PART 4: NEVER FAILS ON MISSING CASE
# ============================================

cat > missing.ts << 'EOF'
function assertNever(x: never): never { throw x; }

type Status = 'a' | 'b' | 'c';

function f(s: Status): string {
  switch (s) {
    case 'a': return 'A';
    case 'b': return 'B';
    // ❌ 'c' missing
    default: return assertNever(s);
  }
}
EOF

npx tsc --noEmit missing.ts
# [ missing.ts:9:32 - Argument of type '"c"' is not assignable to parameter of type 'never'. ]

rm missing.ts

# ============================================
# PART 5: UNKNOWN AT BOUNDARIES
# ============================================

cat > boundary.ts << 'EOF'
interface User {
  id: number;
  name: string;
}

function isUser(x: unknown): x is User {
  return (
    typeof x === 'object' &&
    x !== null &&
    'id' in x && typeof (x as { id: unknown }).id === 'number' &&
    'name' in x && typeof (x as { name: unknown }).name === 'string'
  );
}

const raw: unknown = JSON.parse('{"id":1,"name":"Alice"}');

if (isUser(raw)) {
  console.log(raw.name);  // ✅ narrowed
} else {
  console.log('not a user');
}

// Catch
try {
  throw 'oops';
} catch (err) {
  if (err instanceof Error) console.log(err.message);
  else if (typeof err === 'string') console.log(err);
}
EOF

npx tsc --noEmit boundary.ts
# (no errors)

# ============================================
# PART 6: NEVER IN TYPES
# ============================================

cat > never-types.ts << 'EOF'
type Empty = string & number;  // never

type NonNullish<T> = T extends null | undefined ? never : T;
type A = NonNullish<string | null>;      // string
type B = NonNullish<number | undefined>; // number

type Union = string | never;             // string

// @ts-expect-error - empty intersection can't hold a value
const x: Empty = 42;

console.log({} as A extends string ? 'string' : 'other');
EOF

npx tsc --noEmit never-types.ts
# (no errors)

# ============================================
# PART 7: COMPILE AND RUN
# ============================================

npx tsc unknown.ts never.ts boundary.ts never-types.ts
node unknown.js
# [ HI 42 2024-... unknown ]

node never.js
# [ Waiting ]

node boundary.js
# [ Alice ]
# [ oops ]

node never-types.js
# [ string ]

Quick Reference

The Three Types

Property	`unknown`	`any`	`never`
Position	Top	Escape	Bottom
Assignable to it	Anything	Anything	Nothing
Assignable from it	Nothing (without narrowing)	Anything	Anything
Safe	✅	❌	✅
Purpose	External data	Escape hatch	Exhaustiveness

Assignability

From → To	`unknown`	`any`	`never`
`unknown → string`	❌	—	—
`any → string`	—	✅	—
`never → string`	—	—	✅
`string → unknown`	✅	—	—
`string → any`	—	✅	—
`string → never`	—	—	❌

When to Use Each

Use case	Type
External JSON	`unknown`
Catch variable	`unknown`
API response	`unknown`
User input	`unknown`
Untyped library	`unknown` first
Function that throws	`never`
Exhaustive switch default	`never`
Impossible intersection	`never`
Legacy migration	`any` (temporarily)
Absolutely no alternative	`any` (with comment)

Narrowing from `unknown`

Tool	Example
`typeof`	`typeof x === 'string'`
`instanceof`	`x instanceof Error`
`in`	`'name' in x`
`Array.isArray`	`Array.isArray(x)`
Predicate	`isUser(x): x is User`
Library	`Schema.safeParse(x)`

`unknown` in Function Signatures

Signature	Accepts
`(x: unknown) => void`	Anything
`(x: any) => void`	Anything
`(x: never) => void`	Nothing

`any` Propagation

Operation	Result type
`const x: any`	`any`
`x.foo`	`any`
`x.foo.bar`	`any`
`x()`	`any`
`x + 1`	`any`
`[x]`	`any[]`
`{ a: x }`	`{ a: any }`

`never` Appearances

Context	Example
Function return	`function f(): never { throw }`
Exhaustiveness	After all cases
Impossible type	`string & number`
Conditional filter	`T extends X ? never : T`
Union identity	`A \| never = A`
Intersection absorbing	`A & never = never`
Unreachable code	After `return`/`throw`

Common Patterns

Pattern	Type
Boundary validation	`unknown` + predicate
Exhaustiveness	`never` + `assertNever`
Throwing helper	`never` return
Error narrowing	`unknown` in catch
Filter nullish	`T extends null ? never : T`

Anti-Patterns

Pattern	Problem
`: any` as default	Disables checks
`as any` to silence errors	Hides bugs
`JSON.parse() as Foo`	No validation
`catch (e: any)`	Unchecked errors
Returning `any` from functions	Spreads to callers
`never` as function parameter	Uncallable

`strict` Flags Related

Flag	Effect
`noImplicitAny`	Reject implicit `any`
`useUnknownInCatchVariables`	Catch is `unknown`
`strictNullChecks`	Related null safety

Migration Cheatsheet

Before	After
`any`	`unknown` + predicate
`any`	Type parameter
`any`	Proper interface
`catch (e: any)`	`catch (e)` — `unknown`
`JSON.parse(x) as T`	`unknown` + validate
`any[]`	`unknown[]` + filter

Best Practices

✅ Do This:

// Use unknown for external data
const data: unknown = JSON.parse(input);                    // ✅

// Narrow before use
if (isUser(data)) console.log(data.name);                   // ✅

// Use unknown in catch
try { ... } catch (err) {
  if (err instanceof Error) log(err.message);               // ✅
}

// Use never for exhaustiveness
default: return assertNever(x);                             // ✅

// Use never for throwing functions
function fail(msg: string): never { throw new Error(msg); } // ✅

// Use unknown in function signatures when accepting anything
function handle(x: unknown): void { /* narrow */ }          // ✅

// Validate at boundaries with predicates or libraries
const parsed = Schema.safeParse(x);                         // ✅

// Comment deliberate any usage
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const legacy: any = oldLib.get();                           // ✅

❌ Don’t Do This:

// Don't use any as a shortcut
function f(x: any) { return x.toUpperCase(); }              // ❌

// Don't use `as any` to silence errors
const x = thing as any;                                     // ❌

// Don't cast JSON.parse results without validation
const user = JSON.parse(raw) as User;                       // ⚠️  unvalidated

// Don't catch with any
try { } catch (e: any) { }                                  // ❌

// Don't use never as a parameter type
function f(x: never): void { }                              // ⚠️  uncallable

// Don't return any from public functions
function get(): any { return this.data; }                   // ❌

// Don't use `any` in generics
function wrap<T = any>(x: T) { }                            // ⚠️  use unknown

// Don't forget to narrow unknown
const x: unknown = ...;
x.foo;                                                      // ❌ not allowed

// Don't mistake never for unreachable
function f(): never { return; }                             // ❌ error

Common Pitfalls

Pitfall	Problem	Solution
`any` as default type	Disables checks	Use `unknown`
`as any` to silence	Hides bugs	Fix the type
No `strict`	Many implicit anys	Enable `strict`
`JSON.parse() as T`	No validation	Validate with predicate
Returning `any`	Spreads to callers	Return specific type
`never` as parameter	Uncallable	Use only for exhaustiveness helpers
Confusing `unknown` and `any`	Different safety	`unknown` requires narrowing
Not narrowing `unknown`	Compile error	Use `typeof`/`instanceof`
Empty `catch` block	Swallows errors	Handle the error
`any` in generics	Defeats generic	Use `unknown`

Real-World Examples

1. JSON parse result

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

2. Fetch response

const json: unknown = await res.json();

3. Catch variable

try { } catch (err) {
  if (err instanceof Error) log(err.message);
}

4. Predicate narrowing

function isUser(x: unknown): x is User { /* ... */ }

5. Exhaustive check

default: return assertNever(x);

6. Throwing helper

function fail(msg: string): never { throw new Error(msg); }

7. Filter with never

type NonNullish<T> = T extends null ? never : T;

8. Impossible type

type Empty = string & number;  // never

9. Zod validation

const parsed = Schema.safeParse(raw);
if (parsed.success) parsed.data.name;

10. Array narrowing

if (Array.isArray(x)) x.map(...);

11. Object narrowing

if (typeof x === 'object' && x !== null) Object.keys(x);

12. Function accepting anything

function log(x: unknown): void { console.log(x); }

13. Reducer exhaustiveness

switch (action.type) {
  case 'ADD': return add(...);
  default: return assertNever(action);
}

14. Error describe

function describe(err: unknown): string {
  if (err instanceof Error) return err.message;
  if (typeof err === 'string') return err;
  return 'Unknown';
}

15. URLSearchParams value

const value: string | null = params.get('q');

16. Promise resolve value

const v: unknown = await promise;

17. Discriminated result

type Result = { ok: true; value: T } | { ok: false; error: string };

18. Never in default

default: {
  const _: never = x;
  throw new Error('unreachable');
}

19. Unknown array

function isStringArray(x: unknown): x is string[] {
  return Array.isArray(x) && x.every(v => typeof v === 'string');
}

20. Deliberate any

// Legacy interop — typed badly upstream
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const legacy: any = oldLib.getValue();

Visual: The Type Hierarchy

┌──────────────────────────────────────────────┐
│                                              │
│              unknown                         │
│             ╱       ╲                        │
│     string  number  boolean  ...             │
│             ╲       ╱                        │
│              never                           │
│                                              │
│   every type is assignable to unknown        │
│   never is assignable to every type          │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  any — outside the hierarchy                 │
│                                              │
│  ─ assignable to everything                  │
│  ─ everything assignable to it               │
│  ─ type checking disabled                    │
│                                              │
└──────────────────────────────────────────────┘

Visual: unknown vs any

┌──────────────────────────────────────────────┐
│  unknown                                     │
│                                              │
│  const x: unknown = 'hello';                 │
│                                              │
│  x.toUpperCase();       ❌ must narrow       │
│                                              │
│  if (typeof x === 'string') {                │
│    x.toUpperCase();     ✅                   │
│  }                                           │
│                                              │
│  Safe but requires work                      │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  any                                         │
│                                              │
│  const x: any = 'hello';                     │
│                                              │
│  x.toUpperCase();       ✅ no check          │
│  x.foo.bar();           ✅ no check          │
│                                              │
│  Fast to write — crashes at runtime          │
│                                              │
└──────────────────────────────────────────────┘

Visual: never in Exhaustiveness

┌──────────────────────────────────────────────┐
│  type Status = 'a' | 'b' | 'c'               │
│                                              │
│  switch (s) {                                │
│    case 'a': ...                             │
│    case 'b': ...                             │
│    case 'c': ...                             │
│    default:                                  │
│      // s: never                             │
│      assertNever(s);   ✅                    │
│  }                                           │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  Missing one case:                           │
│                                              │
│  switch (s) {                                │
│    case 'a': ...                             │
│    case 'b': ...                             │
│    default:                                  │
│      // s: 'c'                               │
│      assertNever(s);   ❌ compile error      │
│  }                                           │
│                                              │
└──────────────────────────────────────────────┘

Visual: any Propagation

┌──────────────────────────────────────────────┐
│  const x: any = getData();                   │
│       │                                      │
│       ▼                                      │
│  x.user      → any                           │
│       │                                      │
│       ▼                                      │
│  x.user.name → any                           │
│       │                                      │
│       ▼                                      │
│  x.user.name.toUpperCase() → any             │
│                                              │
│  Every step unchecked                        │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  const x: unknown = getData();               │
│       │                                      │
│       ▼                                      │
│  typeof check required before use            │
│       │                                      │
│       ▼                                      │
│  Narrowed to specific type                   │
│                                              │
│  Every step checked                          │
│                                              │
└──────────────────────────────────────────────┘

Visual: When to Use Each

┌──────────────────────────────────────────────┐
│  External data?           → unknown          │
│  Catch variable?          → unknown          │
│  Truly anything accepted? → unknown          │
│  Exhaustive check?        → never            │
│  Function throws?         → never            │
│  Impossible type?         → never            │
│  Legacy migration?        → any (temp)       │
│  Untyped library?         → unknown first    │
│                                              │
└──────────────────────────────────────────────┘

Visual: Type Flow at a Boundary

┌──────────────────────────────────────────────┐
│  External (untyped)                          │
│                                              │
│  JSON / API / user input                     │
│                                              │
└──────────────────────────────────────────────┘
                  │
                  │  treat as unknown
                  ▼
┌──────────────────────────────────────────────┐
│  unknown                                     │
│                                              │
│  Narrow with typeof, predicates, libraries   │
│                                              │
└──────────────────────────────────────────────┘
                  │
                  │  validated
                  ▼
┌──────────────────────────────────────────────┐
│  Specific type                               │
│                                              │
│  User, Product, Config, etc.                 │
│                                              │
└──────────────────────────────────────────────┘
                  │
                  │  work with typed value
                  ▼
┌──────────────────────────────────────────────┐
│  Application code                            │
│                                              │
│  Compiler-checked, autocompleted             │
│                                              │
└──────────────────────────────────────────────┘

Visual: unknown vs any — the Trade-off

┌──────────────────────────────────────────────┐
│  unknown                                     │
│                                              │
│  • Write time: more (narrow first)           │
│  • Runtime safety: high                      │
│  • Bugs caught: many                         │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  any                                         │
│                                              │
│  • Write time: fast                          │
│  • Runtime safety: none                      │
│  • Bugs caught: none                         │
│                                              │
│  The time saved writing is paid in debugging │
│                                              │
└──────────────────────────────────────────────┘

Visual: never as Bottom

┌──────────────────────────────────────────────┐
│  Assignable to:                              │
│                                              │
│  never → string        ✅                    │
│  never → number        ✅                    │
│  never → User          ✅                    │
│  never → anything      ✅                    │
│                                              │
│  Assignable from:                            │
│                                              │
│  string → never        ❌                    │
│  number → never        ❌                    │
│  anything → never      ❌                    │
│                                              │
└──────────────────────────────────────────────┘

Visual: Error Handling

┌──────────────────────────────────────────────┐
│  ❌ Implicit any                             │
│                                              │
│  try { } catch (e) {                         │
│    e.message;  // no error, may crash        │
│  }                                           │
│                                              │
│  (when useUnknownInCatchVariables: false)    │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  ✅ unknown                                  │
│                                              │
│  try { } catch (e) {                         │
│    if (e instanceof Error) e.message;        │
│    else if (typeof e === 'string') e;        │
│  }                                           │
│                                              │
│  (with useUnknownInCatchVariables: true)     │
│                                              │
└──────────────────────────────────────────────┘

Visual: Validation Flow

┌──────────────────────────────────────────────┐
│  raw: unknown                                │
│       │                                      │
│       ▼                                      │
│  isUser(raw)?                                │
│       │                                      │
│       ├── true  → raw is User (narrowed)     │
│       │                                      │
│       └── false → throw or handle            │
│                                              │
└──────────────────────────────────────────────┘

Visual: Decision Tree

┌──────────────────────────────────────────────┐
│  Do you know the type?                       │
│       │                                      │
│       ├── Yes ──► Use the type               │
│       │                                      │
│       └── No                                  │
│            │                                 │
│            ├── Will you narrow it?           │
│            │      │                          │
│            │      ├── Yes ──► unknown        │
│            │      │                          │
│            │      └── No  ──► never? or any? │
│            │                                 │
│            └── Does it throw or exhaust?     │
│                   │                          │
│                   ├── Yes ──► never          │
│                   │                          │
│                   └── No  ──► any (last      │
│                                 resort)      │
│                                              │
└──────────────────────────────────────────────┘

Summary

Type	Position	Assignable to it	Assignable from it	Safe
`unknown`	Top	Everything	Nothing (without narrowing)	✅
`any`	Escape	Everything	Everything	❌
`never`	Bottom	Nothing	Everything	✅

Key takeaways:

unknown is the top type — accept anything, use nothing without narrowing
any is the escape hatch — accept and assign everything, disables type checking
never is the bottom type — no values, assignable to everything, used for exhaustiveness
Use unknown for external data — JSON, API, user input, catch variables
Use never for exhaustiveness checks and throwing functions
Avoid any unless absolutely necessary — prefer unknown with validation
unknown requires narrowing — typeof, instanceof, in, predicates, validation libraries
any propagates — every operation on it produces another any
strict enables noImplicitAny and useUnknownInCatchVariables
JSON.parse returns any — assign to unknown and validate
never in conditional types filters union members — T extends X ? never : T
never is assignable to everything — perfect for functions that never return
Migrate any to unknown first, then narrow with predicates or validation libraries
Mark deliberate any with a comment or ESLint disable — it’s an exception, not a default

Remember: unknown, any, and never are the three extremes of TypeScript’s type system. unknown is safe but demanding — it forces you to narrow. any is convenient but dangerous — it disables the checks that catch bugs. never is empty but powerful — it proves exhaustiveness and marks unreachable code. Reach for unknown at every boundary, never for exhaustiveness, and any only when there’s no alternative. That discipline keeps the type system doing its job.

Stop using slow, ad-bloated tool sites! 🤮

🔎 Search “KandZ Tools” on Google to use many professional utilities for free.

KandZ.me is the ultimate minimalist hub for:
✅ Finance (Mortgage, Interest, Inflation)
✅ Tech (Base64, JSON, Dev Suite, IP)
✅ Health (BMI, BMR, TDEE)
✅ Productivity (Timer, Workspace, QR)

⚡️ Fast & Private
🔒 No data leaves your device
💎 100% Free

🔗 Use it now: https://tools.kandz.me
🔖 Bookmark it—you’ll need it later!