In chapter 4, you typed EVERY variable explicitly (let title: string = ...) – in most cases that's NOT actually necessary. TypeScript often recognizes types on its own. This chapter shows WHEN you can rely on this "type inference", and WHEN explicit annotations are actually needed.

What is type inference?

"Inference" means: TypeScript LOOKS at the assigned value and AUTOMATICALLY DERIVES the type from it – you don't have to write it yourself:

let title = 'The Lord of the Rings'; // TypeScript infers: string
let pageCount = 1216;                // TypeScript infers: number
let isAvailable = true;              // TypeScript infers: boolean

title = 42; // error - despite the MISSING explicit annotation, title is still recognized as string

IMPORTANT: type checking works JUST AS strictly with INFERRED types as with explicit ones – TypeScript "remembers" the inferred type permanently, it is NOT the case that a missing annotation automatically means any (that would only happen without strict/noImplicitAny, see chapter 3).

When inference reaches its limits

let rating;               // No initial value - TypeScript can infer NOTHING, type becomes 'any'
rating = 4.5;
rating = 'very good';    // NO error - 'any' allows anything!

let genres = [];          // Empty array - type becomes implicitly 'any[]'
genres.push('Fantasy');   // works, but without real type safety

The rule of thumb: when to annotate explicitly?

• NOT needed for variables with an immediate initial value – let pageCount = 1216; is just as type-safe as with an explicit annotation, but shorter to read.
• MANDATORY for variables without an initial value that only get filled in LATER – let result: number;
• MANDATORY for function parameters – TypeScript can NEVER infer from the call context what type a parameter should have (covered in detail in chapter 6).
• RECOMMENDED for function return types – often technically inferable, but an explicit annotation serves as a "contract" that IMMEDIATELY shows an error if the function later accidentally behaves differently (also covered further in chapter 6).

Type inference with objects

const book = {
  title: 'The Lord of the Rings',
  pageCount: 1216,
  isAvailable: true,
};
// TypeScript infers: { title: string; pageCount: number; isAvailable: boolean }

book.pageCount = '1216'; // error - pageCount stays recognized as number
book.author = 'Tolkien'; // error - 'author' doesn't exist on the inferred type

TypeScript infers the ENTIRE shape for object literals – every property gets its own, precise type, and the inferred object type is "closed": adding a property NOT originally present is flagged as an error afterward. An important preview of chapter 7 (interfaces), where we'll EXPLICITLY name and reuse object shapes.

Bonus: const produces MORE PRECISE types than let

let a = 'Fantasy';   // type: string (could change later)
const b = 'Fantasy'; // type: 'Fantasy' (a "literal type" - can NEVER change, it's const!)

Because const variables can NEVER be reassigned, TypeScript infers the MOST PRECISE possible type – not "some string", but EXACTLY this one value. This concept ("literal types") is explored further in chapter 10, where it becomes important for enums and restricted sets of values.