Discuss unknown type compare it with any type.

Question

Accepted Answer

In TypeScript, both `any` and `unknown` are top types, meaning they can hold any value. However, they serve fundamentally different purposes in terms of type safety. `any` is the escape hatch from the type system—it tells the compiler to completely opt out of type checking for that value, allowing any operation without restriction. `unknown` is the type-safe alternative: it also accepts any value, but it requires you to first prove the type through some form of narrowing (like `typeof`, `instanceof`, or a custom type guard) before you can perform operations on it. let anything: any = getDynamicValue();
let unknownValue: unknown = getDynamicValue();

// ✅ ANY: No restrictions, TypeScript trusts you
anything.foo.bar();        // No error, but could crash at runtime
anything();                 // No error
const result = anything + 10; // No error

// ❌ UNKNOWN: TypeScript prevents unsafe operations
unknownValue.foo.bar();    // Error: Object is of type 'unknown'
unknownValue();             // Error: Cannot invoke an expression whose type is 'unknown'
const result2 = unknownValue + 10; // Error: Object is of type 'unknown'

// ✅ UNKNOWN: Must narrow the type first
if (typeof unknownValue === 'string') {
  console.log(unknownValue.toUpperCase()); // OK: now it's a string
}

if (typeof unknownValue === 'function') {
  unknownValue(); // OK: now it's a function
}

if (unknownValue && typeof unknownValue === 'object' && 'foo' in unknownValue) {
  console.log(unknownValue.foo); // OK after narrowing
} **Type Safety**: `any` disables all type checking; `unknown` requires type narrowing before operations. **Property Access**: `any` allows access to any property; `unknown` disallows property access entirely until the type is narrowed. **Function Calls**: `any` allows being called as a function; `unknown` cannot be called without first proving it's a function. **Arithmetic**: `any` can be used in arithmetic operations; `unknown` cannot. **Assignability**: `any` can be assigned to any other type; `unknown` can only be assigned to `any` or `unknown` without a type assertion. **Spread in Objects**: `any` can be spread into an object; `unknown` cannot be spread without prior validation. let anything: any = 'hello';
let unknownVal: unknown = 'world';

let str: string;
let num: number;

// ✅ ANY can be assigned to any type
str = anything; // No error
num = anything; // No error

// ❌ UNKNOWN cannot be assigned to other types without narrowing
str = unknownVal; // Error: Type 'unknown' is not assignable to type 'string'
num = unknownVal; // Error: Type 'unknown' is not assignable to type 'number'

// ✅ UNKNOWN can be assigned to 'any' or 'unknown'
let anyAgain: any = unknownVal; // OK
let unknownAgain: unknown = unknownVal; // OK function parseJSON(input: string) {
  try {
    return JSON.parse(input);
  } catch (e) {
    return null;
  }
}

// BAD: Using 'any' loses type safety
const data: any = parseJSON('{"name":"John"}');
data.name.toLowerCase(); // No error, but crashes if 'data' is null or not an object

// GOOD: Using 'unknown' forces validation
const safeData: unknown = parseJSON('{"name":"John"}');

// Must validate before use
if (safeData && typeof safeData === 'object' && 'name' in safeData) {
  const name = (safeData as { name: string }).name;
  console.log(name.toLowerCase()); // Safe
}

// Better: Create a type guard
function isValidUser(data: unknown): data is { name: string } {
  return (
    data !== null &&
    typeof data === 'object' &&
    'name' in data &&
    typeof (data as { name: unknown }).name === 'string'
  );
}

if (isValidUser(safeData)) {
  console.log(safeData.name.toLowerCase()); // TypeScript knows safeData has a 'name' string
} **Use `unknown` when**: You receive values from truly dynamic sources (APIs, user input, `JSON.parse`) and need to validate them before use. This is the recommended practice for handling external data. **Use `any` when**: You are migrating a JavaScript project to TypeScript incrementally and need a quick escape hatch, or when working with third-party libraries that are genuinely impossible to type. However, even then, prefer `unknown` with type guards. **Never use `any` as a shortcut to silence type errors**. It defeats the purpose of using TypeScript. Prefer `unknown` or more specific types. **Use `unknown` in catch blocks**: The caught error in a `catch` block is typed as `unknown`, forcing you to check its type (e.g., `if (error instanceof Error)`) before accessing `error.message`. **Use `unknown` in generic constraints**: When you need to accept any type but still enforce type safety later, use `T extends unknown` (though this is rarely needed explicitly). try {
  riskyOperation();
} catch (error) {
  // 'error' is 'unknown' in TypeScript 4.0+ (not 'any')
  
  // ✅ Must narrow before using
  if (error instanceof Error) {
    console.error(error.message);
  } else if (typeof error === 'string') {
    console.error(error);
  } else {
    console.error('Unknown error

Discuss unknown type compare it with any type.

The `unknown` type is a type-safe counterpart to `any`. While `any` completely disables type checking, `unknown` represents a value that could be anything but forces you to perform type checking (like type guards, assertions, or instanceof) before you can operate on it.

Scenario Questions

Follow-up Questions

Discuss unknown type compare it with any type.

The unknown type is a type-safe counterpart to any. While any completely disables type checking, unknown represents a value that could be anything but forces you to perform type checking (like type guards, assertions, or instanceof) before you can operate on it.

Scenario Questions

Follow-up Questions

The `unknown` type is a type-safe counterpart to `any`. While `any` completely disables type checking, `unknown` represents a value that could be anything but forces you to perform type checking (like type guards, assertions, or instanceof) before you can operate on it.