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

# Overview

The TypeScript compiler is very configurable. There are [tens of options](https://www.typescriptlang.org/docs/handbook/compiler-options.html) that regulate different aspects of type checking and compilation. In this chapter, we're going to look at some of the compiler flags that let you decide how strict the compiler should be when enforcing type safety.

We use TypeScript because it helps us detect errors at compile time before they hit production. The stricter the checks TypeScript performs, the more errors it will be able to catch. Therefore, we should aim to make the checks as strict as possible. This can be achieved by setting the `strict` compiler flag to `true`. The `strict` flag is responsible for enabling a group of several flags. We're going to focus on the most important flags that will have the biggest impact on how you write code.

# Enabling compiler flags

Enabling TypeScript compiler flags is very straightforward. Your project should contain a file called `tsconfig.json` on the top level. Inside the file, there should be a section called `compilerOptions`. Inside this section, you can add Boolean properties for every flag that we discuss in this course.

For example: to enable `strictNullChecks`, you should modify `tsconfig.json` to look like this:

```
{
  // some other settings
  "compilerOptions": {
    // some other options
    "strictNullChecks": true,
  }
}
```

If you're using an IDE such as Visual Studio Code or WebStorm, it should automatically pick up the changes you made in the file.

In the next lesson, we'll talk about how enabling the `noImplicitAny` flag increases strictness of type checking.

In this lesson, we will talk about strictness of typing and see how to enable strict flags.

Strict types

Generics

Composing types

Advanced types

TypeScript in practice

Conclusion

Introduction