TypeScript

TypeScript is just like ES2015 with type-checking. All ES2015 (classes, etc) should work.

Logging JSON

console.log(JSON.stringify(result, null, 2));

Index Signature

const map: { [index: string]: boolean } = {};

Basic types

any
void

boolean
number
string

null
undefined

string[]          /* or Array<string> */
[string, number]  /* tuple */

string | null | undefined   /* union */

never  /* unreachable */

enum Color {
  Red,
  Green,
  Blue = 4,
}
let c: Color = Color.Green;

Declarations

let isDone: boolean;
let isDone: boolean = false;

function add (a: number, b: number): number {
  return a + b
}

// Return type is optional
function add (a: number, b: number) { ... }

Type assertions

let len: number = (input as string).length;
let len: number = (<string>input).length; /* not allowed in JSX */

Interfaces

Inline

function printLabel(options: { label: string }) {
  console.log(options.label);
}

// Note the semicolon
function getUser(): { name: string; age?: number } {}

Explicit

interface LabelOptions {
  label: string
}

function printLabel(options: LabelOptions) { ... }

Optional properties

interface User {
  name: string;
  age?: number;
}

Read only

interface User {
  readonly name: string;
}

Dynamic keys

{
  [key: string]: Object[]
}

Type aliases

type Name = string | string[];

Function types

interface User { ... }

function getUser(callback: (user: User) => any) { callback({...}) }

getUser(function (user: User) { ... })

Classes

class Point {
  x: number;
  y: number;
  static instances = 0;
  constructor(x: number, y: number) {
    this.x = x;
    this.y = y;
  }
}

Generics

class Greeter<T> {
  greeting: T;
  constructor(message: T) {
    this.greeting = message;
  }
}

let greeter = new Greeter<string>("Hello, world");

Modules

export interface User { ... }