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
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
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
Parsed: 42
Parsed: 10
Unsupported type6. Key Takeaways
anydisables type checking entirely — an unsafe escape hatch that can hide bugs.unknownalso accepts any value but requires narrowing before you can use it — a safe alternative to any.neverrepresents values that logically never occur, such as the return of a function that always throws.voidmeans a function returns no meaningful value, but still completes normally.- Prefer
unknownoveranyfor values of uncertain type, like API responses or catch-block errors. - A function returning
nevernever yields control back to its caller; avoidfunction 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?
You May Also Like
Primitive Types in TypeScript
A guided tour of TypeScript's built-in primitive types: string, number, boolean, null, undefined, bigint, and symbol.
Type Guards in TypeScript
Narrow union types safely within conditional blocks using `typeof`, `instanceof`, and custom user-defined type predicates with `is`.
Union and Intersection Types in TypeScript
Combine types with `|` (union) and `&` (intersection) to model values that can be one of several shapes or must satisfy all of them.
Functions in TypeScript
Learn how TypeScript adds parameter and return type annotations to JavaScript functions for compile-time safety.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics