TypeScript Cheat Sheet
Last updated
Basic types
The primitive types and how to annotate variables.
| Operation | Syntax |
|---|---|
| String | let name: string = "Ada"; |
| Number | let age: number = 25; |
| Boolean | let ok: boolean = true; |
| Array of T | let xs: number[] = [1, 2, 3]; |
| Generic array | let xs: Array<string> = []; |
| Tuple | let pair: [string, number] = ["a", 1]; |
| Any (opt out of typing) | let x: any = 1; |
| Unknown (safer any) | let x: unknown = JSON.parse(s); |
| Void (no return) | function log(): void { … } |
| Never (never returns) | function fail(): never { throw … } |
| Null / undefined | let n: null = null; |
Type inference & annotations
When to let TS infer and when to annotate.
| Operation | Syntax |
|---|---|
| Inferred from value | let count = 0; // number |
| Explicit annotation | let count: number = 0; |
| Function parameter | function add(a: number, b: number) { … } |
| Return type | function add(a: number, b: number): number { … } |
| Arrow function | const sq = (x: number): number => x * x; |
| Type assertion | const el = input as HTMLInputElement; |
| Const assertion (literal) | const dirs = ["up", "down"] as const; |
| Non-null assertion | el!.focus(); |
Interfaces
Describe the shape of an object.
| Operation | Syntax |
|---|---|
| Declare | interface User { id: number; name: string; } |
| Optional property | interface User { age?: number; } |
| Readonly property | interface User { readonly id: number; } |
| Method signature | interface Logger { log(msg: string): void; } |
| Extend another interface | interface Admin extends User { role: string; } |
| Index signature | interface Map { [key: string]: number; } |
| Implement in a class | class Db implements Logger { … } |
Type aliases & unions
Name a type and combine types with | and &.
| Operation | Syntax |
|---|---|
| Type alias | type ID = string | number; |
| Object type alias | type User = { id: number; name: string }; |
| Union type | type Status = "idle" | "loading" | "done"; |
| Intersection type | type Admin = User & { role: string }; |
| Literal type | type Yes = "yes"; |
| Nullable | type Maybe<T> = T | null | undefined; |
| Function type alias | type Handler = (e: Event) => void; |
Functions
Typed parameters, returns, and overloads.
| Operation | Syntax |
|---|---|
| Optional parameter | function greet(name?: string) { … } |
| Default parameter | function greet(name = "friend") { … } |
| Rest parameters | function sum(...ns: number[]): number { … } |
| Function type | let fn: (a: number) => number; |
| Callable interface | interface Fn { (x: number): number; } |
| Overload signatures | function f(x: string): string; function f(x: number): number; function f(x: any) { return x; } |
| Void return ignored | const cb: () => void = () => 42; // ok |
Classes
Classes with access modifiers and parameter properties.
| Operation | Syntax |
|---|---|
| Declare a class | class User { name: string; } |
| Constructor | constructor(name: string) { this.name = name; } |
| Parameter property | constructor(public name: string) {} |
| Public / private / protected | private id: number; |
| Readonly field | readonly id: number; |
| Static member | static count = 0; |
| Getter / setter | get name() { return this._name; } |
| Inheritance | class Admin extends User { … } |
| Abstract class | abstract class Shape { abstract area(): number; } |
Generics
Reusable types parameterized by other types.
| Operation | Syntax |
|---|---|
| Generic function | function id<T>(x: T): T { return x; } |
| Call with explicit type | id<string>("hi"); |
| Generic interface | interface Box<T> { value: T; } |
| Generic type alias | type Pair<A, B> = [A, B]; |
| Generic class | class Stack<T> { items: T[] = []; } |
| Constraint with extends | function len<T extends { length: number }>(x: T) { return x.length; } |
| Default type parameter | interface Box<T = string> { value: T; } |
| keyof operator | type K = keyof User; // "id" | "name" |
| Index access type | type Name = User["name"]; |
Narrowing
Refine a union to a single type at runtime.
| Operation | Syntax |
|---|---|
| typeof check | if (typeof x === "string") { … } |
| instanceof check | if (e instanceof Error) { … } |
| in operator | if ("name" in obj) { … } |
| Equality narrowing | if (status === "done") { … } |
| Truthiness | if (value) { … } |
| Custom type guard | function isUser(x: any): x is User { return "id" in x; } |
| Discriminated union | type Shape = { kind: "sq"; size: number } | { kind: "ci"; r: number }; |
| Exhaustiveness with never | const _: never = shape; |
Enums
Named sets of constants.
| Operation | Syntax |
|---|---|
| Numeric enum | enum Direction { Up, Down, Left, Right } |
| String enum | enum Status { Idle = "IDLE", Done = "DONE" } |
| Use a value | let d: Direction = Direction.Up; |
| Const enum (inlined) | const enum Color { Red, Green, Blue } |
| Union of literals (modern) | type Status = "idle" | "done"; |
Utility types
Built-in helpers that transform existing types.
| Operation | Syntax |
|---|---|
| Make all props optional | Partial<User> |
| Make all props required | Required<User> |
| Make all props readonly | Readonly<User> |
| Pick a subset of keys | Pick<User, "id" | "name"> |
| Omit one or more keys | Omit<User, "password"> |
| Object with given keys | Record<string, number> |
| Exclude from a union | Exclude<"a" | "b" | "c", "a"> |
| Keep only from a union | Extract<"a" | "b", "a" | "c"> |
| Remove null / undefined | NonNullable<string | null> |
| Function return type | ReturnType<typeof fn> |
| Function parameter tuple | Parameters<typeof fn> |
| Awaited promise type | Awaited<Promise<string>> |
Modules
Import and export across files.
| Operation | Syntax |
|---|---|
| Named export | export function add(a: number, b: number) { … } |
| Default export | export default class User { … } |
| Re-export | export { User } from "./user"; |
| Named import | import { add } from "./math"; |
| Default import | import User from "./user"; |
| Import a type only | import type { User } from "./user"; |
| Import everything | import * as math from "./math"; |
| Triple-slash reference | /// <reference types="node" /> |
tsconfig essentials
The compiler flags worth knowing.
| Option | Effect |
|---|---|
"strict": true | Enables all strict-mode checks (recommended). |
"target": "ES2022" | JavaScript version tsc emits. |
"module": "ESNext" | Module system in emitted output. |
"moduleResolution": "bundler" | Resolve modules the way modern bundlers do. |
"jsx": "react-jsx" | Enable JSX for React 17+. |
"esModuleInterop": true | Cleaner default imports from CommonJS modules. |
"skipLibCheck": true | Skip type-checking node_modules (faster builds). |
"noEmit": true | Type-check only - leave emit to your bundler. |
The TypeScript syntax you reach for most, on one page. This TypeScript cheat sheet is a quick reference for everyday TS - basic types, interfaces, type aliases, generics, unions, narrowing, and the built-in utility types.
Everything here is standard TypeScript that compiles with tsc and runs anywhere modern JavaScript does. Copy what you need, or try any snippet live in the TypeScript playground - nothing to install.
TypeScript cheat sheet FAQ
Is this TypeScript cheat sheet free?
Yes. This TypeScript cheat sheet is completely free, with no sign-up required. Bookmark it and come back whenever you need to look up a type, an interface, or a utility type.
What is the difference between an interface and a type alias?
Both can describe the shape of an object, and in most everyday cases they are interchangeable. Interfaces can be re-opened and extended across files (declaration merging), which is useful for library types. Type aliases can name unions, intersections, tuples, and mapped types - shapes you cannot express with
interface. A common rule: use interface for public object shapes, and type for unions, tuples, and computed types.What is the difference between any and unknown?
any opts out of type checking entirely - the compiler will let you do anything to it. unknown is type-safe: you must narrow it (with typeof, instanceof, or a type guard) before you can use it. Prefer unknown for values from external sources like JSON.parse or fetch - it forces you to validate before using.Do I need to learn JavaScript before TypeScript?
Yes - TypeScript is JavaScript with a type system layered on top, so every JavaScript skill carries over. If you are still building JS fundamentals (arrays, objects, async/await), the JavaScript cheat sheet is a good starting point and Coddy's free JavaScript course covers the same ground interactively.
Can I practice TypeScript online?
Yes. Open the TypeScript playground to run any snippet from this cheat sheet in your browser - nothing to install. When you want structure, learn from the JavaScript landing and apply the types from this page on top.
Related resources
More cheat sheets
