any, unknown, never and void in TypeScript

Analogy categoryAnalogies

1. Introduction

Beyond the standard primitives, TypeScript defines four special-purpose types that describe unusual situations: any opts a value out of type checking entirely, unknown is a type-safe counterpart to any, never represents values that can logically never occur, and void describes the absence of a meaningful return value.

🏏

Cricket analogy: Think of any as an unregistered player who can play any role, unknown as a trialist who must prove their position before batting, never as a match abandoned with no result, and void as an over bowled with no wicket taken.

Understanding when to reach for each of these is a strong signal of TypeScript maturity — misusing any in particular is one of the most common ways type safety silently erodes in a codebase.

🏏

Cricket analogy: A captain who overuses risky slogs (like any) instead of trusting a calculated technique erodes the team's disciplined batting approach over a whole series, just as overusing any quietly erodes a codebase's type safety.

2. Syntax

typescript

let a: any = 5;
let u: unknown = 5;

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

function log(message: string): void {
  console.log(message);
}

3. Explanation

3.1 any

any tells the compiler to skip type checking for that value entirely. You can call any method, access any property, or reassign it to any type without error — it is essentially opting back into plain JavaScript behavior for that variable.

🏏

Cricket analogy: Declaring a player 'any' role means they could bat, bowl, keep wicket, or even umpire with no restriction — the scorer accepts any action from them without question, just as any accepts any method call without checking.

3.2 unknown

unknown also accepts any value, but unlike any, you cannot perform operations on an unknown value until you narrow it to a more specific type (via typeof, instanceof, or a type guard). This makes unknown the type-safe way to represent values whose type isn't known in advance, such as API responses or catch block errors.

🏏

Cricket analogy: An unidentified trialist (unknown) can join the squad, but the selectors must verify their role via a trial match (a type guard) before letting them bat or bowl — unlike a registered player (any) who plays immediately.

any disables type checking completely and is considered an unsafe escape hatch — it can silently propagate errors deep into a codebase because the compiler stops verifying anything about that value, including its properties and method calls. unknown is the safe alternative: it forces you to narrow the type with a runtime check (e.g. if (typeof value === "string")) before you're allowed to use it, giving you the same flexibility as any without sacrificing safety.

3.3 never

never represents a value that can never occur — typically the return type of a function that always throws an exception or contains an infinite loop, since such a function never actually returns a value. never is also the automatically inferred type for an unreachable branch after exhaustive checks in a switch statement.

🏏

Cricket analogy: A match format that always ends in an abandonment due to permanent rain (never actually producing a result) is like a function typed never — and a switch statement covering every possible dismissal type leaves no unreachable case.

3.4 void

void describes a function that does not return a meaningful value — it may still implicitly return undefined, but the void return type communicates that the caller should not rely on any returned value. It differs from never in that a void function completes normally; a never function does not complete at all.

🏏

Cricket analogy: A commentator's mid-over update call completes normally but returns no scoreboard value worth tracking (void), unlike a rain-abandoned match that never even finishes (never) — the over still gets bowled either way.

A quick way to remember the distinction: void means 'this function returns, but the returned value carries no meaning'; never means 'this function never returns control to the caller at all,' e.g. because it always throws or loops forever.

4. Example

typescript

function parseValue(value: unknown): number {
  if (typeof value === "string") {
    return Number(value);
  }
  if (typeof value === "number") {
    return value;
  }
  throw new Error("Unsupported type");
}

function assertNever(message: string): never {
  throw new Error(message);
}

function logResult(value: number): void {
  console.log(`Parsed: ${value}`);
}

logResult(parseValue("42"));
logResult(parseValue(10));
try {
  parseValue(true as unknown);
} catch (e) {
  console.log((e as Error).message);
}

5. Output

text

Parsed: 42
Parsed: 10
Unsupported type

6. Key Takeaways

any disables type checking entirely — an unsafe escape hatch that can hide bugs.
unknown also accepts any value but requires narrowing before you can use it — a safe alternative to any.
never represents values that logically never occur, such as the return of a function that always throws.
void means a function returns no meaningful value, but still completes normally.
Prefer unknown over any for values of uncertain type, like API responses or catch-block errors.
A function returning never never yields control back to its caller; a void function does.

Practice what you learned

1. Why is `any` considered an unsafe escape hatch in TypeScript?

2. What must you do before using an `unknown` value as a specific type, such as calling a string method on it?

3. Which return type would you give a function that always throws an error and never returns normally?

4. What best describes the difference between void and never as return types?

5. Why is `unknown` preferred over `any` for representing an API response of uncertain shape?

Was this page helpful?

Enums in TypeScript

Related Study Notes in Programming

Browse all study notes

Programming

Apache Spark Study Notes

Programming · 30 topics

Programming

Apache Flink Study Notes

Programming · 30 topics

Programming

Hadoop Study Notes

Programming · 30 topics

Programming

Snowflake Study Notes

Programming · 30 topics

Programming

Apache Airflow Study Notes

Programming · 30 topics

Programming

dbt (Data Build Tool) Study Notes

Programming · 30 topics

Topics covered

#TypeScript#TypeScriptProgrammingStudyNotes#Programming#AnyUnknownNeverAndVoidInTypeScript#Any#Unknown#Never#Void#StudyNotes#SkillVeris

1. Introduction

2. Syntax

3. Explanation

3.1 any

3.2 unknown

3.3 never

3.4 void

4. Example

5. Output

6. Key Takeaways

Practice what you learned

You May Also Like

Related Reading

Related Study Notes in Programming

Topics covered