The unknown Type vs. any (Type Safety First)

Type Inference & Literal Types (const vs. let)

Discover how TypeScript infers types automatically and how let versus const declarations shape wide types versus narrow literal types.

1. Unsafe vs. Safe Dynamic Types

When dealing with dynamic data from external APIs or user input, you need a way to represent values of unknown shape. TypeScript provides two types for this: any and unknown.

2. The Danger of any (Type Infection)

Using any completely turns off type checking for that variable. Worse, any infects any variable it touches, turning off type safety down the chain!

let data: any = JSON.parse('{"score": 100}');

// DANGER: No compile error, but crashes at runtime if 'name' is missing!
data.nonExistentMethod();
const length: number = data.whatever.foo.bar; // Infects entire pipeline!

3. The Safe Alternative: unknown

The unknown type represents any value, but TypeScript forces you to perform type checking or narrowing before you can access properties or invoke methods on it:

let safeData: unknown = JSON.parse('{"score": 100}');

// safeData.nonExistentMethod(); // Error: Object is of type 'unknown'!

// Must narrow type first!
if (typeof safeData === "object" && safeData !== null && "score" in safeData) {
  console.log("Score is valid!");
}

4. Top Type vs Bottom Type Comparison

[ Top Type: any ]     ──> Bypasses all type checks (Unsafe)
[ Top Type: unknown ] ──> Holds any value, requires narrowing (Safe)

5. Common Mistakes

• Defaulting to any: Using any defeats the primary purpose of using TypeScript. Configure noImplicitAny: true in tsconfig.json to block unannotated any variables!

6. Next Steps

Always prefer unknown over any when handling external dynamic inputs. Next, let's explore the never type and Exhaustiveness Checking!