Learn TypeScript

TypeScript is JavaScript plus a static type layer that is checked at build time and erased before the code runs.

Install the compiler, run it on a project, and configure it with tsconfig.json.

The everyday types: string, number, boolean, bigint, symbol, null, undefined, and the object and array forms built from them.

Where you write types and where TypeScript works them out for you, including literal widening with let vs const.

Type lists with T[], fixed-length positional data with tuples, and prevent mutation with readonly arrays.

Annotate parameters and return types, use optional, default and rest parameters, and write function types for callbacks.

Describe object shapes inline or with interfaces, including optional properties, methods and extending.

Combine types with | and restrict values to exact strings or numbers with literal types.

Model missing values explicitly with T | undefined, and handle them with checks, ?. and ??.

How TypeScript refines a union to a specific member using typeof, equality, in, instanceof and control flow.

The top and bottom types: why any switches checking off, why unknown is the safe alternative, and where never appears.

Compare TypeScript enums with union types and as const objects, and know why many teams avoid enums.

Write your own narrowing functions with value is T and asserts value is T.

Model states and variants as a union of objects sharing a literal tag, and handle them exhaustively.

When to use type and when to use interface, and how extends compares with intersections (&).

Use readonly to prevent reassignment, understand what optional really means, and know the limits of both.

Type class fields, use access modifiers, parameter properties, implements and abstract classes.

Check a value against a type without losing its precise inferred type, and keep literal types with as const.

Write functions and types that work over many types while keeping the link between input and output types.

Restrict type parameters with extends, use keyof in constraints, and give type parameters defaults.

Derive new types from existing ones with Partial, Required, Readonly, Pick, Omit, Record, ReturnType and friends.

Type promises and async functions, handle errors from catch, and type fetched data honestly.

Give one function several call signatures, and know when unions, generics or conditional types are better.

When is Box<Dog> assignable to Box<Animal>? Covariance, contravariance, method bivariance and in/out annotations.

How TypeScript resolves imports, how to import types, and where types for JavaScript packages come from.

What strict turns on, and the extra checks worth enabling: noUncheckedIndexedAccess, exactOptionalPropertyTypes and more.

How interfaces, namespaces and functions merge, and how to add types to third-party modules and globals.

Split a large codebase into composite projects, build them incrementally with tsc -b, and keep editors fast.

Use the compiler API to analyse code, and diagnose slow type-checking with extendedDiagnostics and traces.

Publish accurate types for a library: package.json exports, ESM/CJS declarations, API design rules and type tests.

Turn values into types with typeof, get property-name unions with keyof, and look up member types with T[K].

Build object types by iterating over keys with { [K in Keys]: ... }, adding or removing modifiers and remapping keys.

Choose types with T extends U ? X : Y, understand distribution over unions, and extract parts of types with infer.

Build and parse string types with backtick syntax, combine them with unions, mapped types and infer.

The precise rules behind 'is A assignable to B': freshness, weak types, {} vs object vs unknown, comparability and branded types.

Recursive types, tuple manipulation, accumulators and tail recursion, plus how to test types and when to stop.