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 速查表将类型系统整理在一个可搜索的页面上：基本类型、接口和类型别名、联合类型、交叉类型和类型收窄、泛型、内置工具类型、函数和重载、类、类型守卫和断言、映射类型和条件类型、模块和声明文件，以及真正重要的 tsconfig 选项。

它面向日常开发——泛型约束的确切写法、Pick、Omit、Record 和 ReturnType 的作用、可辨识联合如何收窄、何时用 `satisfies` 而非类型转换——让你无需离开编辑器去翻手册就能确认细节。

与本系列的其他速查表一样，它免费且在客户端运行：使用搜索框实时过滤行，通过固定目录在章节间跳转，点击即可复制任何代码片段，还可以打印页面作为桌边参考。

如何使用 TypeScript 速查表

打开速查表，浏览各章节，从“基本类型”和“泛型”到“tsconfig 要点”。
搜索关键词如 Partial、narrowing 或 satisfies 以实时过滤每一行。
需要高级类型级语法时跳转到“工具类型”或“映射和条件类型”。
点击代码片段或其复制图标，将 TypeScript 代码复制到剪贴板。
使用打印功能获取完整 TypeScript 参考的纸质版。

常见问题

十一个章节：基本类型、接口和类型别名、联合类型和收窄、泛型、工具类型、函数和重载、类、类型守卫和断言、映射和条件类型、模块和声明文件，以及 tsconfig 要点。

是的。专门的章节涵盖了 Partial、Required、Readonly、Pick、Omit、Record、Exclude、Extract、ReturnType、Awaited 等，每个都有一行说明。

非常有帮助。单独的章节展示了 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 参考是免费的吗？

相关工具

热门搜索

嵌入此工具