Discover advanced TypeScript concepts: Gain insights into compiler flags, generic types, and discriminated unions. Delve into writing error-free code and mastering complex error messages with confidence.

typescript-3.7.5.tar.gz

TypeScript 3.7.5 Strict

TypeScript 3.7.5

Are you using TypeScript, but feel like you’re not making the most out of it? Do you find some advanced TypeScript concepts confusing? Do you get lost looking at complex type errors?

If you answered “yes” to any of these questions, then this course is for you! It introduces you to the world of advanced TypeScript concepts including: compiler flags for catching more errors, generic types, and how to compose types with discriminated unions. 

After finishing this course, you’ll feel more confident in your TypeScript skills. You will be able to write types that detect whole classes of possible runtime errors at compile time. Typing even the most untypeable JavaScript code will be a no brainer for you, and you’ll be fluent in TypeScript error messages.

Advanced TypeScript Masterclass

# `Parameters`

The `Parameters` type takes a function type and returns a tuple type representing types of all parameters of the function. Sounds magical, doesn't it?

type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;

const sayHello = (name: string, age: number) => `Hello ${name}, your age is ${age}`;
type SayHelloParams = Parameters<typeof sayHello>; // [string, number]

Let's break down this definition. First, the `Parameters` type has a type argument constraint that says that `T` must be a function type (`(...args: any) => any`). Next, inside the conditional expression we say that `T extends (...args: infer P) => any`. `P` is not a type argument, it's like a **type variable** which will hold the actual type of function parameters (as a tuple). The `infer` keyword lets us _unwrap_ a type argument and pick a consistent part. 

Another way to think about this is that `T` is matched against the `(...args: infer P) => any` _pattern_. If it matches the pattern, then `P` becomes the type that is at the same place in `T` as `infer P` in the pattern. For example, let's assume that `T` is `(name: string, age: number) => string`. It gets matched against `(...args: infer P) => any`. Since it can also be represented as `(...args: [string, number]) => string`, it matches the pattern. The equivalent of `infer P` in `T` is `[string, number]`, so `P` gets resolved to `[string, number]` inside the positive branch of the conditional expression.

The lesson goes through some of the remaining built-in conditional types and introduces the `infer` keyword.

Strict types

Generics

Composing types

Advanced types

TypeScript in practice

Conclusion

The `infer` Keyword

`Parameters`