TypeScript

1
let name: string = 'Ada';
2
let count: number = 42;
3
let active: boolean = true;
4

5
// union: one of several types
6
let id: string | number = 'abc';
7
id = 123;
8

9
// literal union: one of a fixed set of values
10
type Status = 'idle' | 'loading' | 'done';
11
let s: Status = 'idle';

1
const nums: number[] = [1, 2, 3];
2
const pair: [string, number] = ['age', 30]; // tuple

1
let a: any = 5;      // opts out of checking (avoid)
2
let u: unknown = 5;  // must narrow before use
3
if (typeof u === 'number') u.toFixed(2);

1
interface User {
2
  id: string;
3
  name: string;
4
  email?: string; // optional
5
}
6

7
type Point = {x: number; y: number};
8
type Id = string | number; // only a type alias can do this

1
interface Admin extends User {
2
  role: 'admin';
3
}
4

5
type Timestamped = Point & {createdAt: number}; // intersection

1
interface Config {
2
  readonly apiUrl: string;       // can't be reassigned
3
  [key: string]: string;         // any string key -> string
4
}

1
function first<T>(arr: T[]): T | undefined {
2
  return arr[0];
3
}
4
const n = first([1, 2, 3]); // n: number | undefined

1
function longest<T extends {length: number}>(a: T, b: T): T {
2
  return a.length >= b.length ? a : b;
3
}

1
interface ApiResponse<T = unknown> {
2
  data: T;
3
  status: number;
4
}
5
const r: ApiResponse<User> = {data: user, status: 200};

1
type Draft = Partial<User>;    // all fields optional
2
type Full = Required<User>;    // all fields required
3
type Frozen = Readonly<User>;  // all fields readonly

1
type Credentials = Pick<User, 'id' | 'email'>;   // keep some keys
2
type PublicUser = Omit<User, 'email'>;           // drop some keys
3
type UsersById = Record<string, User>;           // map of key -> User

1
function makeUser() { return {id: '1', name: 'Ada'}; }
2
type NewUser = ReturnType<typeof makeUser>;
3
type Args = Parameters<typeof makeUser>;
4
type Resolved = Awaited<Promise<number>>; // number

1
function area(shape: {r: number} | {w: number; h: number}) {
2
  if ('r' in shape) return Math.PI * shape.r ** 2;
3
  return shape.w * shape.h;
4
}

1
function isUser(x: unknown): x is User {
2
  return typeof x === 'object' && x !== null && 'id' in x;
3
}

1
type Route = Record<string, {method: 'GET' | 'POST'}>;
2

3
// annotation widens: method is 'GET' | 'POST'
4
const a: Route = {home: {method: 'GET'}};
5

6
// satisfies checks AND keeps the literal type
7
const routes = {home: {method: 'GET'}} satisfies Route;
8
routes.home.method; // narrowed to 'GET'

1
function tuple<const T extends readonly unknown[]>(...args: T): T {
2
  return args;
3
}
4
const t = tuple('a', 1); // readonly ['a', 1], not (string | number)[]

1
type Event = 'click' | 'focus';
2
type Handler = `on${Capitalize<Event>}`; // 'onClick' | 'onFocus'

1
type Getters<T> = {
2
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
3
};
4
type G = Getters<{name: string}>; // {getName: () => string}

1
type ElementOf<T> = T extends (infer U)[] ? U : never;
2
type N = ElementOf<number[]>; // number

1
type Prepend<T, Arr extends readonly unknown[]> = [T, ...Arr];
2
type R = Prepend<0, [1, 2]>; // [0, 1, 2]

1
function paint<C extends string>(colors: C[], fallback: NoInfer<C>): void {}
2
paint(['red', 'blue'], 'red'); // fallback constrained to 'red' | 'blue'

1
function openFile(path: string): Disposable & {read(): string} {
2
  return {read: () => '...', [Symbol.dispose]() {/* close */}};
3
}
4

5
function run() {
6
  using file = openFile('a.txt');
7
  file.read();
8
} // Symbol.dispose() runs automatically at scope exit

1
import type {User} from './models';
2
export type {User};

1
interface Window {
2
  analytics?: {track(event: string): void};
3
}