TypeScriptチートシート

全開発ツール

無料

検索・印刷可能なTypeScriptリファレンス。型、インターフェース、ジェネリクス、ユーティリティ型、絞り込み、宣言ファイル、tsconfigを網羅。無料。

Basic types

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

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

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

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

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

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

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

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

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

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

"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

「:q」に一致する項目はありません。

TypeScriptチートシートについて

このTypeScriptチートシートは、型システムを1つの検索可能なページにまとめたものです。基本型、インターフェースと型エイリアス、ユニオン、インターセクションと絞り込み、ジェネリクス、組み込みのユーティリティ型、関数とオーバーロード、クラス、型ガードとアサーション、マップ型と条件型、モジュールと宣言ファイル、そして実際に重要なtsconfigオプションを網羅しています。

日常の作業を想定して書かれています。ジェネリック制約の正確な形、Pick、Omit、Record、ReturnTypeが何をするか、判別可能なユニオンがどう絞り込まれるか、キャストではなく`satisfies`を使うべき場面はいつかなど、エディタからハンドブックに移動せずに細かい点を確認できます。

このグループの他のチートシートと同様、無料でクライアント側で動作します。検索ボックスで行をリアルタイムに絞り込み、追従する目次でセクション間を移動し、任意のコードスニペットをワンクリックでコピーし、デスクでの参照用にページを印刷できます。

TypeScriptチートシートの使い方

シートを開き、基本型とジェネリクスからtsconfigの要点まで、各セクションにざっと目を通します。
Partial、narrowing、satisfiesなどのキーワードを検索して、すべての行をリアルタイムに絞り込みます。
高度な型レベルの構文が必要な場合は、ユーティリティ型やマップ型・条件型のセクションに移動します。
スニペットまたはそのコピーアイコンをクリックして、TypeScriptのコードをクリップボードにコピーします。
印刷機能を使って、TypeScriptリファレンス全体の紙のコピーを作成します。

よくある質問

基本型、インターフェースと型エイリアス、ユニオンと絞り込み、ジェネリクス、ユーティリティ型、関数とオーバーロード、クラス、型ガードとアサーション、マップ型と条件型、モジュールと宣言ファイル、tsconfigの要点の11セクションです。

はい。専用のセクションで、Partial、Required、Readonly、Pick、Omit、Record、Exclude、Extract、ReturnType、Awaitedなどを、それぞれ1行の説明付きで扱っています。

非常に役立ちます。個別のセクションで、typeofやinstanceofによる絞り込み、判別可能なユニオン、ユーザー定義の型述語、アサーション関数、キャストと`satisfies`の違いを扱っています。

はい。どの行のコードでもクリックするか、そのコピーアイコンをクリックすれば、すぐにクリップボードにコピーされます。

はい、完全無料で、ログイン不要でブラウザ内で動作します。

TypeScriptチートシート

Basic types

Interfaces & type aliases

Unions, intersections & narrowing

Generics

Utility types

Functions & overloads

Classes

Type guards & assertions

Mapped & conditional types

Modules & declaration files

tsconfig essentials

TypeScriptチートシートについて

TypeScriptチートシートの使い方

よくある質問

TypeScriptチートシートは何を扱っていますか？

組み込みのユーティリティ型は一覧になっていますか？

絞り込みや型ガードにも役立ちますか？

スニペットをワンクリックでコピーできますか？

TypeScriptリファレンスは無料ですか？

関連ツール

人気の検索

このツールを埋め込む