// --- BOOLEAN
let b: boolean = true;
console.log('boolean ' + b + ' typeof ' + typeof b);
// --- STRING
let s: string = 'stringValue';
console.log('string ' + s + ' typeof ' + typeof s);
// --- NUMBER
let num: number = 12.24;
console.log('number ' + num + ' typeof ' + typeof num);
// --- ARRAY
let a: Array<number> = [1, 2, 3];
console.log('array ' + s + ' typeof ' + typeof a);
let a1: number[] = [1, 2, 3];
console.log('array ' + s + ' typeof ' + typeof a1);
// --- TUPLE
let t: [string, number];
t = ["hello", 20];
console.log('tuple ' + t + ' typeof ' + typeof t);
// --- ENUM
enum Color {
Green,
Red,
Blue
}
let e: Color;
e = Color.Red;
console.log('enum ' + e.toString() + ' typeof ' + typeof e);
//Object.values<string>(Color).includes(Red) // check on includes
VOID, UNKKNOWN, NULL, UNDEFINED, ANY, NEVER TYPES
// --- UNKNOWN
// -- difference of unknown and any https://stackoverflow.com/questions/51439843/unknown-vs-any
let notSure: unknown = 4;
notSure = "maybe a string instead";
// OK, definitely a boolean
notSure = false;
/*declare const maybe: unknown;
// 'maybe' could be a string, object, boolean, undefined, or other types
const aNumber: number = maybe;
Type 'unknown' is not assignable to type 'number'.
if (maybe === true) {
// TypeScript knows that maybe is a boolean now
const aBoolean: boolean = maybe;
// So, it cannot be a string
const aString: string = maybe;
Type 'boolean' is not assignable to type 'string'.
}
if (typeof maybe === "string") {
// TypeScript knows that maybe is a string
const aString: string = maybe;
// So, it cannot be a boolean
const aBoolean: boolean = maybe;
Type 'string' is not assignable to type 'boolean'.
}*/
// --- ANY
let looselyTyped: any = 4;
console.log('any ' + looselyTyped + ' typeof ' + typeof looselyTyped);
// OK, ifItExists might exist at runtime
// looselyTyped.ifItExists();
// OK, toFixed exists (but the compiler doesn't check)
// looselyTyped.toFixed();
/*
let strictlyTyped: unknown = 4;
strictlyTyped.toFixed();
Object is of type 'unknown'.
*/
// --- VOID
let v: void = undefined;
console.log('void ' + v + ' typeof ' + typeof v);
/*let unusable: void = undefined;
// OK if `--strictNullChecks` is not given
unusable = null;*/
// NULL and UNDEFINED
let u: undefined = undefined;
let n: null = null;
/*By default null and undefined are subtypes of all other types. That means you can assign null and undefined to something like number.
However, when using the --strictNullChecks flag, null and undefined are only assignable to unknown, any and their respective types (the one exception being that undefined is also assignable to void). This helps avoid many common errors. In cases where you want to pass in either a string or null or undefined, you can use the union type string | null | undefined.*/
// --- NEVER
// for functions which will never end
function fNever(): never {
while (true) {}
};
// Function returning never must not have a reachable end point
function error(message: string): never {
throw new Error(message);
}
// Inferred return type is never
function fail() {
return error("Something failed");
}
COMPLEX TYPES
// TYPE UNIONS
let unionExample : string | null = "123";
function printId(id: number | string) {
console.log("Your ID is: " + id);
}
// OK
printId(101);
// OK
printId("202");
// OBJECT
/*Object
object is a type that represents the non-primitive type, i.e. anything that is not number, string, boolean, bigint, symbol, null, or undefined.*/
// The parameter's type annotation is an object type
function printCoord(pt: { x: number; y: number }) {
console.log("The coordinate's x value is " + pt.x);
console.log("The coordinate's y value is " + pt.y);
}
printCoord({ x: 3, y: 7 });
// --- TYPE ALIASES
type Point = {
x: number;
y: number;
};
// Exactly the same as the earlier example
function printCoord(pt: Point) {
console.log("The coordinate's x value is " + pt.x);
console.log("The coordinate's y value is " + pt.y);
}
printCoord({ x: 100, y: 100 });
// --- INTERFACES
// --- differences from type aliases is that interfaces are extendible
interface Point {
x: number;
y: number;
}
function printCoord(pt: Point) {
console.log("The coordinate's x value is " + pt.x);
console.log("The coordinate's y value is " + pt.y);
}
printCoord({ x: 100, y: 100 });

// Type assertions
const myCanvas = document.getElementById("main_canvas") as HTMLCanvasElement;
// or
const myCanvas = <HTMLCanvasElement>document.getElementById("main_canvas");
// --- LITERAL TYPES
let x: "hello" = "hello";
// OK
x = "hello";
// ...
x = "howdy";
Type '"howdy"' is not assignable to type '"hello"'.
// --- ANOTHER EXAMPLE
function printText(s: string, alignment: "left" | "right" | "center") {
// ...
}
printText("Hello, world", "left");
printText("G'day, mate", "centre");
Argument of type '"centre"' is not assignable to parameter of type '"left" | "right" | "center"'.
// --- NUMERIC LITERAL TYPES
function compare(a: string, b: string): -1 | 0 | 1 {
return a === b ? 0 : a > b ? 1 : -1;
}
// --- COMBINATION OF LITERALTYPES WITH NON LITERAL TYPES
interface Options {
width: number;
}
function configure(x: Options | "auto") {
// ...
}
configure({ width: 100 });
configure("auto");
configure("automatic");
Argument of type '"automatic"' is not assignable to parameter of type 'Options | "auto"'.