Gain insights into TypeScript's core concepts, from basics to advanced type checking and iterators. Learn about static typing and JS library support through practical, hands-on experience.

TypeScriptBasic.tar.gz

TypeScript Latest and Strict

check ts version

TypeScript-assert

TypeScript-assert-copy

If you’re looking to move beyond vanilla JavaScript and take your skills to the next level, then you’ve come to the right place. TypeScript is an in-demand language that sits on top of JavaScript. This means you can do everything you can in JavaScript with TypeScript, but also enjoy countless other perks including support for JS libraries, NPM, static typing, and much more.

In this course, you’ll start from the beginning and work your way up to more advanced concepts like type checking, iterators, and manipulating objects and arrays. You'll get a chance to get your hands dirty with plenty of real practice along the way.

For JavaScript developers, TypeScript is a must-know language, not only for today but also for years to come. Don't miss out.

Learn TypeScript: The Complete Course for Beginners

## Type system variances
TypeScript variances use the nomenclature of another language, which is confusing by nature. It’s not something you must master since the compiler will stop you from doing anything crazy. 

However, it’s good to understand before having the compiler manage the complexity for us. Before getting started, let’s create some interfaces to examine how TypeScript handles (or doesn’t handle) covariant, contravariant, bivariant, and invariant types.

We will create three interfaces which will be all inherited in the chain. So, `InterfaceA` inherits `InterfaceB` which inherits `InterfaceC`. 

```
interface InterfaceA {
  a1: number;
}

interface InterfaceB extends InterfaceA {
  b2: string;
}

interface InterfaceC extends InterfaceB {
  c3: boolean;
}
```

## Type 1: Invariance
The concept of invariance is the simplest of the type systems. This means the variable’s type is the only type accepted.


Invariance *accepts* supertypes; it also does *not* accept subtypes. 

# Type system variances
TypeScript variances use the nomenclature of another language, which is confusing by nature. It’s not something you must master since the compiler will stop you from doing anything crazy. 

However, it’s good to understand before having the compiler manage the complexity for us. Before getting started, let’s create some interfaces to examine how TypeScript handles (or doesn’t handle) covariant, contravariant, bivariant, and invariant types.

We will create three interfaces which will be all inherited in the chain. So, `InterfaceA` inherits `InterfaceB` which inherits `InterfaceC`. 

```
interface InterfaceA {
  a1: number;
}

interface InterfaceB extends InterfaceA {
  b2: string;
}

interface InterfaceC extends InterfaceB {
  c3: boolean;
}
```

# Type 1: Invariance
The concept of invariance is the simplest of the type systems. This means the variable’s type is the only type accepted.


Invariance *accepts* supertypes; it also does *not* accept subtypes. 

This lesson gives the theory of how TypeScript handles variance.


Introduction

The Basics of Variables

Comment

Enum

Generic Type

Functions

Mapped Type

Objects

Index Signature

Variables Advanced

Exception

Alias

Type Checking

Iterators

Manipulating Objects and Array

Sharing Code

Conclusion

On How TypeScript Handles Variance

Type system variances