typescript-3.7.5.tar.gz

TypeScript 3.7.5 Strict

TypeScript for Angular Developers

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, this module 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 module, you’ll feel more confident in your TypeScript skills. You will 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

## Overview

Now that you have a full understanding of union types, let’s look at one of their special categories. 

Creating **discriminated unions** is an extremely powerful way of composing types. Thanks to this mechanism you can write code that is type-safe beyond your imagination. Discriminated unions let you enforce some business logic rules **at compile-time**.

## Representing choice with optional properties

Let's start by looking at an example. Imagine implementing an e-commerce application. When the customer registers on the app, they need to provide some contact details. One of the acceptance criteria says:

> Customer needs to provide either email or phone number.

The most straightforward way of defining the `Customer` type that satisfies this requirement is by using two optional properties.

```typescript
interface Customer {
  name: string;
  email?: string;
  phone?: number;
}
```

This solution has one major drawback. It's possible to create a `Customer` with neither `email` nor `phone` provided. In other words, it's possible to create a `Customer` object that violates the business requirement.

You might argue that the type will be accompanied by a validation function that will throw an exception if the object doesn't have any of these two properties defined. This is slightly better, but still far from ideal because of the following:

* You will learn that the object is invalid at runtime
* When using `strictNullChecks`, you'll need to write `if` statements every time you want to access `email` or `phone`
* You might forget to call the validation function

## Discriminated unions to the rescue

Instead of having two optional properties in `Customer` type, let's create a new `Contact` type that is a union of two interfaces. One union member has a non-optional `email` property and the other has a non-optional `phone` property.

These two union members follow a special convention. They both have a string literal property called `kind`. The type of that property is different in both members. This property is called a **discriminator**. It encodes type information into the object so that it is available at runtime. Thanks to this, TypeScript can figure out which union member you're dealing with by looking at the `kind` property.

# Overview

Now that you have a full understanding of union types, let’s look at one of their special categories. 

Creating **discriminated unions** is an extremely powerful way of composing types. Thanks to this mechanism you can write code that is type-safe beyond your imagination. Discriminated unions let you enforce some business logic rules **at compile-time**.

# Representing choice with optional properties

Let's start by looking at an example. Imagine implementing an e-commerce application. When the customer registers on the app, they need to provide some contact details. One of the acceptance criteria says:

> Customer needs to provide either email or phone number.

The most straightforward way of defining the `Customer` type that satisfies this requirement is by using two optional properties.

```typescript
interface Customer {
  name: string;
  email?: string;
  phone?: number;
}
```

This solution has one major drawback. It's possible to create a `Customer` with neither `email` nor `phone` provided. In other words, it's possible to create a `Customer` object that violates the business requirement.

You might argue that the type will be accompanied by a validation function that will throw an exception if the object doesn't have any of these two properties defined. This is slightly better, but still far from ideal because of the following:

* You will learn that the object is invalid at runtime
* When using `strictNullChecks`, you'll need to write `if` statements every time you want to access `email` or `phone`
* You might forget to call the validation function

# Discriminated unions to the rescue

Instead of having two optional properties in `Customer` type, let's create a new `Contact` type that is a union of two interfaces. One union member has a non-optional `email` property and the other has a non-optional `phone` property.

These two union members follow a special convention. They both have a string literal property called `kind`. The type of that property is different in both members. This property is called a **discriminator**. It encodes type information into the object so that it is available at runtime. Thanks to this, TypeScript can figure out which union member you're dealing with by looking at the `kind` property.

This lesson introduces the concept of discriminated union types.

Before We Begin

Strict types

Generics

Composing types

Advanced types

TypeScript in practice

Conclusion

Discriminated Union Types

Overview

Representing choice with optional properties