TypeScript Handbook

TypeScript is JavaScript with a type checker bolted on at compile time. Every valid JavaScript program is (almost) valid TypeScript — the type checker just refuses to compile the ones it can prove are wrong before they run. Assign a string where a function expects a number, call a method that does not exist on an object, forget to handle the null case — TypeScript catches all three while you type, not when a user does.

It compiles down to plain JavaScript — the types are erased, not shipped. There is no "TypeScript runtime"; there is a compiler (tsc) that reads your .ts files, checks the types, strips them, and writes out .js. That is also why a type error is never something a user sees: it either stops the build, or your team ships it anyway and the type checker did its job for nothing. This handbook is about the first kind of team.

• Catches bugs before runtime — a typo in a property name, a function called with the wrong argument order, forgetting a case in a switch.
• Autocomplete that is actually correct — your editor knows the exact shape of every object, because the compiler does.
• Safe refactoring — rename a field and the compiler lists every call site that breaks, instead of you finding them in production.
• The de facto standard — React, Node, Angular, most serious open-source libraries ship TypeScript types; most job listings for "JavaScript" now mean this.

You do not need to install anything for this handbook — every example below has a Run button. But you will use the other two on day one of any real TypeScript project.

1. 1
   1. tsc — the compiler

   npm i -g typescript, then tsc app.ts reads app.ts, type-checks it, and writes app.js next to it. tsc --noEmit checks without writing anything — the command most CI pipelines run.

2. 2
   2. ts-node — compile and run in one step

   npm i -D ts-node, then npx ts-node app.ts compiles in memory and runs it immediately. Convenient for scripts; production servers still compile ahead of time with tsc.

3. 3
   3. Right here

   Every typescript block on these pages is an editor. Press Run, or ⌘/Ctrl + Enter. Your types are stripped and the result runs in your browser — nothing is sent to a server.

tsconfig.json at your project root tells tsc (and your editor) how to check your code. tsc --init generates one with every option commented; almost all of it is defaults you will never touch. Five options decide how strict and modern your project is.

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "ESNext",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  }
}

A function with typed parameters and a typed return value, called and printed. Every idea in it — annotations, inference, interfaces — gets its own lesson starting Module 01. First, run it. Then step through the trace to see what actually executes once the types are gone.

Type annotation

The : number part — you writing down what a value's type is.

Type inference

TypeScript figuring out a type without you writing it — const cost = total(12, 3) is inferred as number because total returns one.

Erasure

Types exist only while tsc is checking your code. The compiled .js has none of them — this is why you cannot check a type at runtime with typeof the way you check number vs string.

TypeScript infers a type from the value you assign whenever it can — you do not have to annotate everything, and over-annotating is a beginner tell. The rule of thumb: let TypeScript infer local variables; annotate function boundaries.

Seventeen modules, each its own page. The rail on the left lists them; the bar at the top and the pill at the bottom-left track how far you are. A lesson ticks itself when you reach its end or run its code, and the tick survives closing the tab — no account needed.

• Run blocks are editors — your types, stripped and executed, so you see real runtime behaviour.
• Error cards are real tsc compiler errors, copied from actually running the checker — because a run block on this page cannot show you a type error (Module 00, previous lesson explains why). Module 10 collects the fifteen most common.
• Traces show what survives after the compiler erases your types — the mental model that makes generics, narrowing and inference click.
• Interview questions appear where the topic is taught and are collected in Module 15, tiered junior / mid / senior.
• The handbook ends with a certification exam (Module 16 → exam), then the ATS resume checker and the job board.

An AI can write correctly-typed TypeScript in seconds. That is exactly why you should type the annotations yourself while learning: the goal is not the code, it is the model in your head of what the compiler can prove and what it cannot — the thing that lets you read someone else's generic type in an interview and explain what it does.

Ready? Module 01 starts with the type system itself — primitives, arrays, tuples, and the three types every beginner reaches for too early: any, unknown and never.