Difference Between Unknown and Any in Typescript

1. Introduction

In TypeScript, any and unknown are two types that can represent any value, but they have significant differences in terms of type safety. The any type is the most permissive, allowing for any kind of operation on any value. The unknown type, introduced in TypeScript 3.0, is a type-safe counterpart to any, requiring more strict type checking and ensuring that the type of the variable is verified before performing any operations on it.

2. Key Points

1. Type Safety: unknown enforces type checking, whereas any bypasses it.

2. Operations: With any, all operations are allowed; with unknown, operations are not allowed until the type is verified.

3. Use Case: any is used for legacy code and dynamic content, unknown for new code where type safety is a concern.

4. Intended Use: unknown is for situations where the type is genuinely not known and ensures safety, any should be avoided if possible for better type safety.

3. Differences

Characteristic Any Unknown
Type Safety Bypasses type checking Enforces type checking
Operations Allows all operations Restricts operations until the type is known
Use Case Legacy code, dynamic content New code where type safety matters
Intended Use Should be avoided for better type safety When type is genuinely unknown

4. Example

// Example of Any
let anyValue: any;
anyValue = 'Hello';
anyValue = 42;

// Example of Unknown
let unknownValue: unknown;
unknownValue = 'Hello';
unknownValue = 42;
// Using an unknown type requires type checking
if (typeof unknownValue === 'string') {


Any Output:
No restrictions, can be anything.
Unknown Output:
Error if no type checking, works fine with type checking.


1. anyValue can be assigned and used without any restrictions or type checks.

2. unknownValue requires type checks before it can be used, which enforces safer coding practices.

5. When to use?

- Use any in situations where you have to deal with dynamic content from third-party libraries or legacy codebase, but be aware of the lack of safety.

- Prefer unknown for new code where type safety is important, and you need to ensure that the type of the variable is checked before performing operations on it.