TypeScript exposes the basic types, as well as a couple of extra types. Let's explore the type system with these examples.

• Boolean: The type is a primitive JavaScript boolean:

let success: boolean = true;

• Number: The type is a primitive JavaScript number:

let count: number = 20;

• String: The type is a primitive JavaScript string:

let message: string = "Hello world";

• Array: The type is an array of value. There are two equivalent notations:

let ages: number[] = [31, 20, 65];
let ages: Array<number> = [31, 20, 65];

• Tuple: The type represents a heterogeneous array of values. Tuple enables storing multiple fields of different types:

let x: [string, number];
x = ["age", 40];    // ok
x = [40, "age"] ;   // error

• Any: The type is anything. It is useful when you need to describe the type of variables that you do not know at the time of writing your application. You can assign a value of arbitrary type to a variable of type any. A value of type any in turn can be assigned to a variable of arbitrary type:

let some: any = "some";
some = 10000;
some = false;

let success: boolean = some;
let count: number = some;
let message: string = some;

• Void: The type represents the absence of having an any type. This type is normally used as the return type of functions:

function doSomething(): void {
  // do something
}

• Nullable: These types denote two specific types, null and undefined that are valid values of every type. That means, they can be assigned to any other type. It is not always desired. TypeScript offers a possibility to change this default behavior by setting the compiler options strictNullChecks to true. Now, you have to include the Nullable types explicitly using a union type (explained later on), otherwise, you will get an error:

let x: string = "foo";
x = null;    // error
let y: string | null = "foo";
y = null;    // ok

Sometimes, you would like to tell compiler that you know the type better than it does and it should trust you. For instance, imagine a situation where you receive data over HTTP and know exactly the structure of the received data. The compiler doesn't know such structure of course. In this case, you want to turn off the type checking when assigning the data to a variable. It is possible with so called type assertions. A type assertion is like a type cast in other languages, but without the checking of data. You can do that either with angle bracket or the as syntax.

let element = <HTMLCanvasElement> document.getElementById('canvas');
let element = document.getElementById('canvas') as HTMLCanvasElement;