Learn TypeScript

27 reviews

last updated 19 months ago

Start learning TypeScript

This course is up to date, guaranteed

The Numbers

  • 58 Topics
  • 316 Minutes of Video
  • 52,304 Words of Text
  • 30 Quizzes
  • 9 Exercises
  • 3 Projects

The Outline

  • Introduction

    • Introduction, Philosophy, and Tips
    • Projects (What you'll build)

    We'll start the course off with some housekeeping items. You'll learn about the best strategy for getting the most out of the course as well as what you'll build during the course.

  • Getting TypeScript Configured

    • Basic TypeScript Configuration

    TypeScript is both a type checker and a compiler, so you'll need to install it to use it with your projects. You'll also learn about the most important configuration settings for TypeScript.

  • Project: Tic Tac Toe

    • (Project) Base Project
    • (Project) Adding Base Types
    • (Project) Button Event Handler
    • (Project) Win Condition

    At this point, you've learned enough to actually build a program in TypeScript! We'll make Tic Tac Toe using TypeScript so you can get a feel for how to write type definitions that match the data structures you use in your code.

  • Type Narrowing

    • Common Type Guards
    • (Quiz) Common Type Guards
    • Handling null and undefined
    • (Quiz) Handling null and undefined
    • (Practice) Narrowing Types
    • (Solution) Narrowing Types
    • (Bonus) Structural vs Nominal Typing
    • Discriminating Unions
    • (Quiz) Discriminating Unions
    • (Practice) Discriminating Unions
    • (Solution) Discriminating Unions
    • Assertion Signatures
    • (Quiz) Assertion Signatures
    • User Defined Type Guards
    • (Quiz) User Defined Type Guards
    • (Practice) User Defined Type Guards
    • (Solution) User Defined Type Guards

    Often, you'll find that you have a value that could be several different types. How can you tell what type it actually is? Once you learn about Type Narrowing, you can add runtime checks to determine the type of any value.

  • Modules

    • (Bonus) From IIFEs to CommonJS to ES6 Modules
    • (Bonus) ES Modules In Depth
    • Modules in TypeScript
    • (Quiz) Modules in TypeScript
    • (Bonus) TypeScript Namespaces

    Modules are all about getting code from one file into another file. TypeScript has a nuanced approach to modules, so you'll learn what things to watch out for as you use modules in your TypeScript code.

  • Advanced Transformation Types

    • Recursive Conditional Types
    • Template Literal Types
    • Mapped Types Key Remapping

    TypeScript 4.1 may have come out a week before this course launched, but that doesn't mean you won't learn about the new goodies that came with it! You'll learn about several new transformation types that come with the latest version of TypeScript.

  • TypeScript Overview

    • (Pre-req) Glossary
    • Why TypeScript?
    • (Quiz) Why TypeScript?
    • (Bonus) ECMAScript, TC39, and the Standardization process

    Whenever you learn a new tool, you should first ask yourself why it's necessary. If you can't answer that question, you may not need it. In this section, we'll answer that question in regards to TypeScript as well as cover some other programming fundamentals that TypeScript utilizes. We'll also do a quick refresher on how JavaScript (and thus TypeScript) features are standardized.

  • Basic Type Checking

    • Implicit Type Checking
    • (Quiz) Implicit Type Checking
    • Adding Type Annotations
    • (Quiz) Adding Type Annotations
    • Typing Function Declarations
    • (Quiz) Typing Function Declarations
    • (Practice) Type Annotations
    • (Solution) Type Annotations

    Now that you're all set up, you can start writing TypeScript code! You'll learn about the TypeScript type checker and how to write type annotations when the type checker can't automatically infer them.

  • Classes

    • Class Definition
    • (Quiz) Class Definition
    • Class Modifiers
    • (Quiz) Class Modifiers
    • (Practice) Classes
    • (Solution) Classes

    In this section you'll learn about how to define classes and some special features that TypeScript provides to give your classes a bit of extra type safety.

  • Generics

    • Generics
    • (Quiz) Generics
    • (Bonus) Zustand Implementation
    • (Practice) Generics
    • (Solution) Generics

    Just like you can write functions to reuse code, you can write generic types to reuse type definitions throughout your codebase. We'll even look at a real-world library to see how it uses generics.

  • Declaration Files

    • Built-In Type Definitions
    • (Quiz) Built-In Type Definitions
    • (Bonus) Outputting TypeScript Definitions
    • Definitely Typed and @types/ packages
    • (Quiz) Definitely Typed and @types/ packages
    • (Bonus) Typing an NPM module that has no types

    What happens when you want to use JavaScript code in TypeScript? Can you even do that without sacrificing type safety? Yes, you can, with declaration files. You'll learn about the type definitions that ship with TypeScript, third-party type definitions, and how to write your own type definitions for third-party modules.

  • Extra Topics

    • Unexpected TypeScript Behavior
    • (Quiz) Unexpected TypeScript Behavior
    • (Bonus) Experimental Decorators

    In this section you'll learn about all the things that don't really fit with the normal flow of the course.

  • Typing in JavaScript

    • JavaScript Types
    • (Quiz) JavaScript Types

    Types are fundamental to TypeScript, so naturally you'll need to be familiar with the base types that exist in JavaScript.

  • Special TypeScript Types

    • `any` and `unknown` types
    • (Quiz) `any` and `unknown` types
    • Interfaces
    • (Quiz) Interfaces
    • (Practice) Interfaces
    • (Solution) Interfaces
    • Enum and Tuple Types
    • (Quiz) Enum and Tuple Types
    • Void and Never Types
    • (Quiz) Void and Never Types
    • `type` aliases
    • (Quiz) `type` aliases
    • Union Types
    • (Quiz) Union Types
    • Intersection Types
    • (Quiz) Intersection Types
    • Literal Types
    • (Quiz) Literal Types
    • (Practice) Union & Literal Types
    • (Solution) Union & Literal Types

    TypeScript includes a few special types which it uses to augment the types that come with JavaScript. You'll learn how you can use these to add better type safety to your programs.

  • Advanced TypeScript Types

    • TypeScript Operators
    • (Quiz) TypeScript Operators
    • (Bonus) Advanced Function Typing

    TypeScript comes with its own set of operators which you can use to transform your types. You'll also learn about some special ways to add type annotations to functions.

  • Transformation Types

    • (Bonus) Thinking In Types
    • Mapped Types
    • (Quiz) Mapped Types
    • Conditional Types
    • (Quiz) Conditional Types
    • (Practice) Utility Types
    • (Solution) Utility Types

    Once you understand generics, a whole world of possibility opens up. You can use TypeScript operators with generic types to transform your types in really powerful ways. You'll apply what you learn by recreating the utility types that ship with TypeScript!

  • Advanced TypeScript Configuration

    • Additional TSConfig.json options
    • (Quiz) Additional TSConfig.json options
    • (Bonus) How the `target` field works
    • Module Resolution
    • (Quiz) Module Resolution
    • (Bonus) Configuring for Webpack Development
    • (Bonus) Configuring for Babel Development
    • (Bonus) Configuring for Modern Web Development
    • (Bonus) Configuring for Node Development
    • (Bonus) Configuring for Library Development with TSDX

    There are a lot more configuration options for TypeScript, so you'll learn about a few more. You'll also learn how to configure TypeScript for several different development environments.

  • Project: Web Server

    • (Project) Initial Node.js Setup
    • (Project) Static Web Server
    • (Project) Multiple Routes
    • (Project) Dynamic API Route

    Now that we know a bit more about configuring TypeScript, we'll use this knowledge to write a Node.js server using TypeScript. We'll handle the request and response object, create a few routes, and even grab some dynamic data.

  • The Love

    This is the part where we're supposed to tell you how great the course is. Even better if we get other "famous" developers to give their "reviews". Instead, we'll let those who have actually taken the course do that.


    27 Reviews

    • Q
      59 days ago

      Alex you were excellent right throughout the course with your explanation on TS. The course was well balanced when it comes to each section. Thanks

    • JW
      James Wade
      3 months ago

      The content of the course was good, but it focuses too deeply on intricate nuances of TypeScript and less on how to build with TypeScript. I watched all the videos, completed all the quizzes, did all the practice exercises, and built the projects. But I still don't feel comfortable building with TypeScript. I recommend creating an "Advanced TypeScript" course that teaches the more complicated types. In its place, create many more projects that walk developers through building things. The practices were okay, but they focused more on knowledge checks rather than applying knowledge. I worry that I will quickly forget much of what I have learned because I haven't really applied it to anything. Particularly for complex types, it's hard to even think of a scenario (other than the toy ones mentioned in the course) where I could use them. I need to be shown through projects.

    • TR
      3 months ago

      The course is awesome!

    • TR
      4 months ago

      Like the other courses, this one is wonderful. Continue at the same pace. You are one of the best!

    • VT
      Vinayak Tyagi
      7 months ago

      Great course, very crystal clear content and at a very comfortable pace. It is a long course perhaps 2 projects would have been better, one before Generics and other towards the end where we could play more with mapped types, conditional types etc. There was quite a bit of content on configurations towards the end, I think it would have been better if we could see some of those in action in the project-work.

    • Avatar for Baiaman Kasymbaev
      Baiaman Kasymbaev
      10 months ago

      As I developer who has been using TypeScript for 2 years a learnt a lot! It's not too fetched while managing to cover every topic. It's also great that I have an option to choose between text and video materials.

    • MH
      Marco Howard
      11 months ago

      Very through and explains concepts clearly. Some of the bonuses were hard to grasp by just listening/watching but the text descriptions helped

    • DP
      Dhruval Patel
      11 months ago

      Awesome. Thanks

    • LC
      Luis C
      13 months ago

      I really enjoyed this course. Alex Anderson is an excellent instructor. The course is very well structured and encompasses a lot of content. I learned a lot.

    • M
      13 months ago

      Very in-depth, covered a lot of great content which i'm sure to apply in my work.

    Join Us

    Join thousands of ambitious developers who use our courses and events catalog to scale their JavaScript careers.

    Full access to


    • Event Catalog


    • TypeScript
    • reactReact
    • reactReact Hooks
    • React with TypeScript
    • reduxRedux
    • react-routerReact Router
    • javascriptAdvanced JavaScript
    • javascriptModern JavaScript
    Yearly Subscription
    (or pay monthly for $40)
    Join ui.dev