Aide-mémoire TypeScript

Tous les outils
Gratuit

Une référence TypeScript consultable et imprimable — types, interfaces, génériques, types utilitaires, restriction de type, fichiers de déclaration et tsconfig. Gratuit.

Basic types

14
let name: string = "Ada";
String type annotation
let age: number = 30;
Number (int and float)
let ok: boolean = true;
Boolean
let ids: number[] = [1, 2];
Array of numbers
let pair: [string, number] = ["a", 1];
Tuple: fixed-length typed array
let anything: unknown;
Safe any: must narrow before use
let loose: any;
Opts out of checking (avoid)
function log(): void {}
No return value
function fail(): never { throw new Error(); }
Never returns
let big: bigint = 9007199254740993n;
Arbitrary-precision integer
let id: string | null = null;
Nullable via union
const point = { x: 1 } as const;
Deep readonly literal types
enum Status { Active, Inactive }
Numeric enum
type Dir = "up" | "down";
String literal union (enum-lite)

Interfaces & type aliases

12
interface User { id: number; name: string; }
Object shape contract
type User = { id: number; name: string };
Type alias for a shape
interface User { nickname?: string; }
Optional property
interface User { readonly id: number; }
Property cannot be reassigned
interface Admin extends User { role: string; }
Interface inheritance
type Admin = User & { role: string };
Extend an alias via intersection
interface Dict { [key: string]: number; }
Index signature
interface Fn { (x: number): string; }
Callable interface
interface User { greet(): void; }
Method signature
interface Box<T> { value: T; }
Generic interface
interface Window { myGlobal: string; }
Declaration merging (augment)
type Point = Readonly<{ x: number }>;
Readonly wrapper on an alias

Unions, intersections & narrowing

12
type Id = string | number;
Union: one of several types
type Full = A & B;
Intersection: all members of both
if (typeof id === "string") { ... }
typeof narrowing
if (el instanceof HTMLElement) { ... }
instanceof narrowing
if ("radius" in shape) { ... }
in-operator narrowing
if (value != null) { ... }
Strip null AND undefined
switch (shape.kind) { case "circle": ... }
Discriminated union switch
type Shape = Circle | Square;
Discriminated union (kind field)
const x = cond ? a : b;
Result type is a union of both
user?.address?.city
Optional chaining
const name = input ?? "default";
Nullish coalescing
function assertNever(x: never): never { throw x; }
Exhaustiveness check helper

Generics

11
function first<T>(arr: T[]): T { return arr[0]; }
Generic function
first<string>(["a", "b"])
Explicit type argument
interface Box<T> { value: T; }
Generic interface
class Stack<T> { items: T[] = []; }
Generic class
type Pair<K, V> = { key: K; value: V };
Generic type alias
<T extends { id: number }>
Constrain the type parameter
<T, K extends keyof T>(obj: T, key: K): T[K]
Typed property access
<T = string>
Default type parameter
function wrap<const T>(v: T): T[]
const modifier keeps literals
type Flatten<T> = T extends Array<infer U> ? U : T;
Extract inner type with infer
const map = new Map<string, User>();
Generic built-in collections

Utility types

14
Partial<User>
All properties optional
Required<User>
All properties required
Readonly<User>
All properties readonly
Pick<User, "id" | "name">
Keep only the listed keys
Omit<User, "password">
Drop the listed keys
Record<string, number>
Object map of key to value type
Exclude<T, U>
Remove U members from union T
Extract<T, U>
Keep only U members of union T
NonNullable<T>
Strip null and undefined
ReturnType<typeof fn>
Type a function returns
Parameters<typeof fn>
Tuple of a function's params
Awaited<Promise<string>>
Unwrap promise type → string
InstanceType<typeof MyClass>
Instance type from a class
Uppercase<"id"> / Capitalize<"id">
String-literal case transforms

Functions & overloads

11
function add(a: number, b: number): number
Typed parameters and return
const add = (a: number, b: number) => a + b;
Arrow function (return inferred)
function log(msg: string, level?: string)
Optional parameter
function log(msg: string, level = "info")
Default parameter value
function sum(...nums: number[]): number
Rest parameters
type Handler = (e: Event) => void;
Function type alias
function get(id: number): User; function get(ids: number[]): User[]; function get(x: any): any { ... }
Overload signatures + one impl
function fn(this: HTMLElement, e: Event)
Typed this parameter
async function load(): Promise<User>
Async returns a Promise
function isUser(x: unknown): x is User
Type predicate return
const fn: typeof otherFn = ...;
Reuse another function's type

Classes

12
class User { constructor(public name: string) {} }
Parameter property shorthand
private secret: string;
Compile-time private member
#secret: string;
Runtime private field (ES)
protected id: number;
Visible to subclasses only
readonly createdAt = new Date();
Assign once, in ctor only
static create(): User { return new User(); }
Static factory method
class Admin extends User { ... }
Inheritance (use super())
class Api implements Fetcher { ... }
Implement an interface
abstract class Shape { abstract area(): number; }
Abstract base class
get fullName(): string { return ...; }
Getter accessor
override toString(): string { ... }
Explicit override (safer)
declare id: number;
Declare without initializing

Type guards & assertions

11
function isUser(x: unknown): x is User
Custom type guard
function assertUser(x: unknown): asserts x is User
Assertion function
function assertOk(x: unknown): asserts x
Assert truthy (non-null after)
const el = input as HTMLInputElement;
Type assertion (cast)
value!
Non-null assertion (careful!)
x as unknown as Y
Double assertion (last resort)
const roles = ["admin", "user"] as const;
Literal tuple via const assert
if (Array.isArray(value)) { ... }
Built-in array guard
satisfies Record<string, string>
Check shape, keep inference
typeof x === "object" && x !== null
Safe object check (null trap)
catch (e) { if (e instanceof Error) ... }
Narrow the unknown catch var

Mapped & conditional types

12
type Flags<T> = { [K in keyof T]: boolean };
Mapped type over keys
{ [K in keyof T]?: T[K] }
Add ? modifier (Partial)
{ [K in keyof T]-?: T[K] }
Remove ? modifier (Required)
{ readonly [K in keyof T]: T[K] }
Add readonly to all keys
{ -readonly [K in keyof T]: T[K] }
Strip readonly (Mutable)
{ [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K] }
Key remapping with as
type IsString<T> = T extends string ? true : false;
Conditional type
T extends (infer U)[] ? U : never
infer inside a conditional
type Keys = keyof User;
Union of property names
type Value = User["name"];
Indexed access type
type Route = `/users/${number}`;
Template literal type
T extends any ? T[] : never
Distribute over union members

Modules & declaration files

12
export interface User { ... }
Named export
export default class Api { ... }
Default export
import { User } from "./user";
Named import
import type { User } from "./user";
Type-only import (erased)
export type { User };
Type-only re-export
import * as path from "node:path";
Namespace import
declare module "my-lib" { ... }
Type an untyped package
declare global { interface Window { ... } }
Augment global scope
declare const VERSION: string;
Ambient declaration (.d.ts)
export {};
Force a file to be a module
/// <reference types="node" />
Triple-slash type reference
npm i -D @types/lodash
Install community typings

tsconfig essentials

13
"strict": true
Enable all strict checks (do it)
"target": "ES2022"
Output JavaScript version
"module": "ESNext"
Emitted module system
"moduleResolution": "bundler"
Resolution for Vite/esbuild
"noEmit": true
Type-check only, no output
"esModuleInterop": true
Smooth CommonJS default imports
"skipLibCheck": true
Skip checking .d.ts files
"noUncheckedIndexedAccess": true
arr[i] becomes T | undefined
"paths": { "@/*": ["./src/*"] }
Import path aliases
"outDir": "./dist", "rootDir": "./src"
Output / source directories
"sourceMap": true, "declaration": true
Emit .map and .d.ts files
npx tsc --noEmit
CI type-check command
npx tsc --init
Generate a tsconfig.json

Aucune entrée ne correspond à « :q ».

À propos de Aide-mémoire TypeScript

Cet aide-mémoire TypeScript transforme le système de types en une seule page consultable : types de base, interfaces et alias de types, unions, intersections et restriction de type, génériques, types utilitaires intégrés, fonctions et surcharges, classes, gardes de type et assertions, types mappés et conditionnels, modules et fichiers de déclaration, et les options tsconfig qui comptent vraiment.

Il est écrit pour le travail quotidien — la forme exacte d'une contrainte générique, ce que font Pick, Omit, Record et ReturnType, comment une union discriminée se restreint, quand recourir à `satisfies` plutôt qu'à un cast — pour que vous puissiez vérifier un détail sans quitter votre éditeur pour le manuel.

Comme chaque aide-mémoire de ce groupe, il est gratuit et côté client : filtrez les lignes en direct avec la barre de recherche, sautez entre les sections avec le sommaire épinglé, copiez n'importe quel extrait d'un clic et imprimez la page comme référence sur votre bureau.

Comment utiliser Aide-mémoire TypeScript

  1. Ouvrez la fiche et parcourez les sections, des Types de base et Génériques jusqu'aux essentiels de tsconfig.
  2. Recherchez un mot-clé comme Partial, restriction ou satisfies pour filtrer chaque ligne en direct.
  3. Sautez aux Types utilitaires ou aux Types mappés et conditionnels quand vous avez besoin de la syntaxe avancée au niveau des types.
  4. Cliquez sur un extrait ou son icône de copie pour copier le TypeScript dans votre presse-papiers.
  5. Utilisez Imprimer pour une copie papier de la référence TypeScript complète.

Questions fréquentes

Onze sections : types de base, interfaces et alias de types, unions et restriction de type, génériques, types utilitaires, fonctions et surcharges, classes, gardes de type et assertions, types mappés et conditionnels, modules et fichiers de déclaration, et les essentiels de tsconfig.

Oui. Une section dédiée couvre Partial, Required, Readonly, Pick, Omit, Record, Exclude, Extract, ReturnType, Awaited et le reste, chacun avec une explication en une ligne.

Très. Des sections distinctes montrent la restriction avec typeof et instanceof, les unions discriminées, les prédicats de type définis par l'utilisateur, les fonctions d'assertion et la différence entre un cast et `satisfies`.

Oui. Cliquez sur le code de n'importe quelle ligne ou son icône de copie et il est copié immédiatement dans votre presse-papiers.

Oui, elle est entièrement gratuite et s'exécute dans votre navigateur sans connexion.
Partager
Outils similaires
Antisèche JavaScript Une référence du JavaScript moderne, consultable et imprimable — syntaxe, tableaux, chaînes, objets, async/await, DOM et fonctionnalités ES2022+. Gratuit. Gratuit
Aide-mémoire React Une référence React 19 imprimable et consultable — composants, JSX, hooks, les nouvelles API Actions, contexte, refs et performance. Gratuit. Gratuit
Generateur de code depuis JSON Transformez n'importe quel exemple JSON en TypeScript, Go, Python, Kotlin ou un JSON Schema — l'inference de types s'execute entierement dans votre navigateur. Gratuit et prive. Gratuit
Antisèche PHP Une référence PHP 8.3+ consultable et imprimable — syntaxe, chaînes, tableaux, fonctions, classes, enums, attributs et fonctionnalités modernes. Gratuit. Gratuit
Antisèche MySQL Une référence MySQL consultable et imprimable — requêtes, jointures, index, fonctions, types de données et commandes d'administration. Gratuit. Gratuit
Antisèche Python Une référence Python 3 consultable et imprimable — syntaxe, structures de données, compréhensions, fonctions, classes, fichiers et bibliothèque standard. Gratuit. Gratuit
Recherches populaires
typescript cheat sheet types typescript types utilitaires typescript génériques typescript typescript interface vs type options tsconfig référence typescript
Besoin d'aide ?
Un problème avec cet outil ? Signalez-le à notre équipe.
Signaler un problème

Ajoutez cet outil gratuit à votre propre site web — copiez-collez le code ci-dessous.