TypeScript 5.0 Cheat Sheet

npm install TypeScript

npx tsc

npx tsc --project configs/my_tsconfig.json

/// <reference lib="es2016.array.include" />

/// <reference path="../my_types" />
/// <reference types="jquery" />

/// <amd-module name="Name" />
/// <amd-dependency path="app/foo" name="foo" />

// @ts-nocheck

// @ts-check

// @ts-ignore

// @ts-expect-error

function getValue(val?: number): number | 'nil' {
  // Will return 'nil' if `val` is falsey (including 0)
  // return val || 'nil';

  // Will only return 'nil' if `val` is null or undefined
  return val ?? 'nil';
}

function countCaps(value?: string) {
  // The `value` expression be undefined if `value` is null or
  // undefined, or if the `match` call doesn't find anything.
  return value?.match(/[A-Z]/g)?.length ?? 0;
}

let value: string | undefined;

// ... Code that we're sure will initialize `value` ...

// Assert that `value` is defined
console.log(`value is ${value!.length} characters long`);

let a;
let b = 1;
 
// assign a value only if current value is truthy
 
a &&= 'default'; // a is still undefined
b &&=  5; // b is now 5

let a;
let b = 1;
 
// assign a value only if current value is falsy
 
a ||= 'default'; // a is 'default' now
b ||=  5; // b is still 1

let a;
let b = 0;
 
// assign a value only if current value is null or undefined
 
a ??= 'default'; // a is now 'default'
b ??=  5; // b is still 0

any

string

${string}Suffix

number

boolean

object

undefined

null

void

never

unknown

{
    requiredStringVal: string;
    optionalNum?: number;
    readonly readOnlyBool: bool;
}

{ [key: string]: Type; }
{ [key: number]: Type; }
{ [key: symbol]: Type; }
{ [key: `data-${string}`]: Type; }

let direction: 'left' | 'right';

let roll: 1 | 2 | 3 | 4 | 5 | 6;

string[]

or

Array<string>

(() => string)[]

or

{ (): string; }[]

or

Array<() => string>

let myTuple: [ string, number, boolean? ];

myTuple = [ 'test', 42 ];

type Numbers = [number, number];
type Strings = [string, string];
 
type NumbersAndStrings = [...Numbers, ...Strings]; 
// [number, number, string, string]

type NumberAndRest = [number, ...string[]];
// [number, varying number of string] 

type RestAndBoolean = [...any[], boolean]; 
// [varying number of any, boolean]

type Vector2D = [x: number, y: number];
function createVector2d(...args: Vector2D) {} 
// function createVector2d(x: number, y: number): void

(arg1: Type, argN: Type) => Type;

or

{ (arg1: Type, argN: Type): Type; }

new () => ConstructedType;

or

{ new (): ConstructedType; }

(arg1: Type, optional?: Type) => ReturnType

(arg1: Type, ...allOtherArgs: Type[]) => ReturnType

{ (): Type; staticProp: Type; }

function fn(arg1 = 'default'): ReturnType {}

(arg1: Type): ReturnType => { ...; return value; }

or

(arg1: Type): ReturnType => value;

function fn(this: Foo, arg1: string) {}

function conv(a: string): number;
function conv(a: number): string;
function conv(a: string | number): string | number {
    ...
}

let myUnionVariable: number | string;

let myIntersectionType: Foo & Bar;

interface Child extends Parent, SomeClass {
    property: Type;
    optionalProp?: Type;
    optionalMethod?(arg1: Type): ReturnType;
}

class Child
extends Parent

implements Child, OtherChild {
    property: Type;
    defaultProperty = 'default value';
    private _privateProperty: Type;
    private readonly _privateReadonlyProperty: Type;
    static staticProperty: Type;

    static {
        try {
            Child.staticProperty = calcStaticProp();
        } catch {
            Child.staticProperty = defaultValue;
        }
    }

    constructor(arg1: Type) {
        super(arg1);
    }

    private _privateMethod(): Type {}

    methodProperty: (arg1: Type) => ReturnType;
    overloadedMethod(arg1: Type): ReturnType;
    overloadedMethod(arg1: OtherType): ReturnType;
    overloadedMethod(arg1: CommonT): CommonReturnT {}
    static staticMethod(): ReturnType {}
    subclassedMethod(arg1: Type): ReturnType {
        super.subclassedMethod(arg1);
    }
}

enum Options {
    FIRST,
    EXPLICIT = 1,
    BOOLEAN = Options.FIRST | Options.EXPLICIT,
    COMPUTED = getValue()
}

enum Colors {
    Red = "#FF0000",
    Green = "#00FF00",
    Blue = "#0000FF"
}

    type Name = string;

    type Direction = 'left' | 'right';

    type ElementCreator = (type: string) => Element;

    type Point = { x: number, y: number };

    type Point3D = Point & { z: number };

    type PointProp = keyof Point; // 'x' | 'y'

    const point: Point = { x: 1, y: 2 };

    type PtValProp = keyof typeof point; // 'x' | 'y'

<T>(items: T[], callback: (item: T) => T): T[]

interface Pair<T1, T2> {
    first: T1;
    second: T2;
}

<T extends ConstrainedType>(): T

<T = DefaultType>(): T

<T extends ConstrainedType = DefaultType>(): T

type Arr = readonly any[];
 
function concat<U extends Arr, V extends Arr>(a: U, b: V): 
[...U, ...V] { return [...a, ...b] }
 
const strictResult = concat([1, 2] as const, ['3', '4'] as const);
const relaxedResult = concat([1, 2], ['3', '4']);
 
// strictResult is of type [1, 2, '3', '4']
// relaxedResult is of type (string | number)[]

type Point = { x: number, y: number };
let pointProp: keyof Point = 'x';

function getProp<T, K extends keyof T>(
    val: T,
    propName: K

): T[K] { ... }

type Stringify<T> = { [P in keyof T]: string; }
type Partial<T> = { [P in keyof T]?: T[P]; }

type Swapper = <T extends number | string>
    (value: T) => T extends number ? string : number;

is equivalent to

(value: number) => string

if T is number, or

(value: string) => number

if T is string

interface Person {
    firstName: string;
    lastName: string;
    age: number;
}

type StringProps<T> = {
    [K in keyof T]: T[K] extends string ? K : never;
};

type PersonStrings = StringProps<Person>;

// PersonStrings is "firstName" | "lastName"

// A = string
type A = Awaited<Promise<string>>;

// B = number
type B = Awaited<Promise<Promise<number>>>;

// C = boolean | number
type C = Awaited<boolean | Promise<number>>;

Partial<{ x: number; y: number; z: number; }>

is equivalent to

{ x?: number; y?: number; z?: number; }

Readonly<{ x: number; y: number; z: number; }>

is equivalent to

{
    readonly x: number;

    readonly y: number;

    readonly z: number;

}

Pick<{ x: number; y: number; z: number; }, 'x' | 'y'>

is equivalent to

{ x: number; y: number; }

Record<'x' | 'y' | 'z', number>

is equivalent to

{ x: number; y: number; z: number; }

type Excluded = Exclude<string | number, string>;

is equivalent to

number

type Extracted = Extract<string | number, string>;

is equivalent to

string

type NonNull = NonNullable<string | number | void>;

is equivalent to

string | number

type ReturnValue = ReturnType<() => string>;

is equivalent to

string

class Renderer() {}
type Instance = InstanceType<typeof Renderer>;

is equivalent to

Renderer

function isThing(val: unknown): val is Thing {
    // return true if val is a Thing
}

if (isThing(value)) {
    // value is of type Thing
}

declare value: string | number | boolean;
const isBoolean = typeof value === “boolean”;

if (typeof value === "number") {
    // value is of type Number
} else if (isBoolean) {
    // value is of type Boolean 
} else {
    // value is a string
}

declare value: Date | Error | MyClass;

const isMyClass = value instanceof MyClass;

if (value instanceof Date) {
    // value is a Date
} else if (isMyClass) {
    // value is an instance of MyClass
} else {
    // value is an Error
}

interface Dog { woof(): void; }
interface Cat { meow(): void; }

function speak(pet: Dog | Cat) {
    if ('woof' in pet) {
        pet.woof()
    } else {
        pet.meow()
    }
}

let val = someValue as string;

or

let val = <string>someValue;

let point = { x: 20, y: 30 } as const;

or

let point = <const>{ x: 20, y: 30 };

declare const $: JQueryStatic;

declare module "foo" {
    export class Bar { ... }
}

declare module "text!*" {
    const value: string;
    export default value;
}