TypeScript Course

Add type safety to your JavaScript projects. Learn TypeScript fundamentals and how to build scalable applications with confidence.

Learn TypeScript step by step — types, interfaces, generics, classes and React with TypeScript — through practical interactive lessons.

Know JavaScript? TypeScript is your next step.

Start with Lesson 1 — Introduction to TypeScript. We recommend finishing the JavaScript course first, but it's not required.

Continue where you left off

Lessons in this course

• Introduction to TypeScript — What TypeScript adds to JavaScript and how to set up your first TS project
• Basic Types — string, number, boolean, arrays, tuples, and the any/unknown types
• Interfaces and Type Aliases — Define the shape of objects and create reusable custom types
• Functions and Generics — Type your function parameters and return values; write flexible generic functions
• Classes and Objects — Access modifiers, readonly, abstract classes, and OOP in TypeScript
• Advanced Types — Union, intersection, conditional types, mapped types, and utility types
• Union & Intersection Types — Combine types with A | B and A & B, and narrow them safely
• Literal Types & const Assertions — Exact string/number types and locking values with as const
• Enums — Numeric and string enums, const enums, and enum vs union-of-literals
• Type Narrowing & Type Guards — Narrow types with typeof, instanceof, in, and custom type guards
• Generics — Write reusable, type-safe functions, interfaces and classes
• Object Types: Optional, Readonly & Index Signatures — Model flexible objects with ?, readonly, and index signatures
• Function Overloads & this Types — Overload signatures, call signatures, and typing this
• Arrays, Tuples & Readonly Arrays — Typed arrays, fixed-shape tuples, named members, and readonly
• Checkpoint: The Type System — Combine unions, generics and tuples in a build — then a quiz
• Utility Types (Partial, Pick, Omit, Record) — Transform types with the built-in utility types
• Mapped Types — Build new types by transforming the keys of existing ones
• Conditional Types & infer — T extends U ? X : Y, distribution, and extracting types with infer
• Generic Constraints & Defaults — Restrict type parameters with extends and provide defaults
• keyof, typeof & Lookup Types — Type-safe property access with keyof, the typeof operator, and T[K]
• Discriminated Unions — Model states and results with a discriminant and exhaustive checks
• Modules & Declaration Files — import/export, type-only imports, and ambient .d.ts declarations
• tsconfig & Compiler Options — strict mode, target/module, and the options that matter most
• Checkpoint: Advanced Types — Combine mapped types, discriminated unions and generics — then a quiz
• Type Assertions & Non-null (as, !) — Tell the compiler a type with as and !, and when it's safe vs dangerous
• any vs unknown vs never — The three special types — escape hatch, safe unknown, and impossible never
• void, null & undefined — Model absence and no-return correctly under strictNullChecks
• Structural Typing (Duck Typing) — Why TypeScript matches types by shape, not by name
• type vs interface — When to use each — merging, extends, unions, and style guidance
• readonly, as const & Immutability — Lock values at compile time with readonly, ReadonlyArray, and as const
• Records & Index Signatures — Type dictionaries with index signatures and Record<K, V>
• Template Literal Types — Build string types from other types — event names, key prefixes, and more
• Recursive Types — Model JSON, trees, and deep-readonly with self-referential types
• The satisfies Operator — Check a value against a type without widening its literal inference
• Branded (Nominal) Types — Stop mixing ids and units by giving primitives a unique brand
• Checkpoint: Type-Level Patterns — Combine satisfies, branded and template-literal types — then a quiz
• Declaration Merging — Merge interfaces and augment modules and the global scope
• Namespaces — Group code with namespaces, and why ES modules are usually better
• Ambient Declarations & @types — Type untyped JavaScript with declare, .d.ts files, and DefinitelyTyped
• Typing Promises & async/await — Promise<T>, Awaited<T>, and typing a fetch wrapper
• DOM & Event Types — Type elements, queries, and events without casting everywhere
• Generic Defaults & Inference — Default type parameters, how inference works, and when to annotate
• Function Types, this, Parameters & ReturnType — Type functions precisely and extract their parameter and return types
• Variadic Tuple Types — Spread and label tuple elements to type curry, concat, and rest args
• Advanced Utility Types — Awaited, Parameters, ReturnType, NonNullable — and build your own with infer
• Decorators — Stage-3 class, method, and field decorators and how they work
• Migrating JavaScript to TypeScript — Adopt TS incrementally with allowJs, JSDoc, @ts-check, and gradual strict
• Checkpoint: Applied TypeScript — Build a small typed module combining several features — then a quiz
• TypeScript with React — Type your React components, props, hooks, and events correctly
• TypeScript Best Practices — Real-world patterns, strictness settings, and tips for clean TS codebases
• Runtime Validation with Zod — Validate data at runtime and infer static types from a single Zod schema
• Testing TypeScript — Write type-safe tests with Vitest/Jest, typed mocks, and async assertions
• TypeScript on Node.js — Configure tsconfig for Node, @types/node, ESM vs CommonJS, and ts-node/tsx
• Building APIs with Express and TypeScript — Type requests, responses, and middleware for a clean Express REST API
• Authoring and Publishing TypeScript Libraries — Emit .d.ts declarations, configure package.json exports, and publish to npm

Frequently asked questions

What is TypeScript and why use it?

TypeScript is JavaScript with static types added. It catches errors before you run your code, gives better autocomplete, and makes large codebases far easier to maintain. It compiles down to plain JavaScript that runs anywhere.

Should I learn JavaScript before TypeScript?

Yes — TypeScript is a superset of JavaScript, so you should be comfortable with JavaScript basics first. Once you know JavaScript, learning TypeScript mostly means learning its type system, which this course covers step by step.

Is TypeScript worth learning in 2026?

Definitely. Most modern front-end and Node.js jobs now expect TypeScript, and major frameworks (Angular, and increasingly React projects) are built around it. It is one of the most valuable skills for a web developer today.

More for this course

• TypeScript cheat sheet — Quick syntax reference you can scan while you code