Evolution of Implicit any Types
What you'll learn: How TypeScript tracks and evolves the type of variables initialized with null or undefined, and when this evolution breaks down.
When you initialize a variable with null or undefined without an explicit type annotation, TypeScript gives it an implicit any type — but this type is special. Unlike a regular any, it can evolve as you assign values to it.
How Type Evolution Works
Think of it like a chameleon variable: it starts colorless but takes on the color of whatever you assign to it first.
let value = null; // Implicit any
value = "hello"; // Now TypeScript sees it as string
value.toUpperCase(); // ✓ Works, treated as string
value = 42; // Now evolves to number
value.toFixed(2); // ✓ Works, treated as number
TypeScript observes each assignment and updates the variable's inferred type along the way.
When Evolution Fails
Evolution only works within the same scope. Once you try to use the variable before assigning a non-null value, or in a different context where TypeScript can't track the assignments, evolution stops working:
let data = undefined; // Implicit any
if (Math.random() > 0.5) {
data = "text";
}
data.toUpperCase(); // ✗ Error: Object is possibly undefined
Here, TypeScript can't guarantee data was assigned, so it won't evolve to string. You've lost the safety net.
Key Takeaway: Variables initialized with null or undefined get an implicit any that evolves with assignments in linear code, but this evolution fails in conditional branches or when the variable is used before assignment — prefer explicit type annotations for clarity and safety.