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

# Non-string discriminators

In the example from the previous lesson, we used a string literal property called `type` as a discriminator. First, the discriminator doesn't have to be called `"type"`. Any property name will be fine.

Second, the discriminator doesn't have to be a string. You can also use number literals, Boolean literals, or even enums!

The built-in `IteratorResult` type in TypeScript (starting from version 3.6) uses the Boolean property `done` as a discriminator.

```typescript
type IteratorResult<T, TReturn = any> = IteratorYieldResult<T> | IteratorReturnResult<TReturn>;

interface IteratorYieldResult<TYield> {
    done?: false;
    value: TYield;
}

interface IteratorReturnResult<TReturn> {
    done: true;
    value: TReturn;
}
```

Using enums can help you avoid *magic strings* if that's an issue for you. One advantage of this approach is that renaming discriminating values becomes much easier.

```typescript
const enum ContactType { Phone, Email };

type Contact =
    | { type: ContactType.Email, email: string }
    | { type: ContactType.Phone, phone: number };
```

# Multiple discriminating properties

Interestingly, a discriminator does not have to be a single property. A group of literal properties can also act as a discriminator! In such a case, every combination of values marks a different member of the union type.

This lesson contains some facts about discriminated unions that may come in handy when using them in the wild.

Strict types

Generics

Composing types

Advanced types

TypeScript in practice

Conclusion

Discriminated Unions in Practice

Non-string discriminators