typescript（TypeScript 开发）

TypeScript

Overview

TypeScript is a statically typed superset of JavaScript that compiles to plain JavaScript. It adds optional type annotations, interfaces, generics, and advanced type-level programming to JavaScript, enabling safer refactoring, better tooling, and self-documenting code. TypeScript has become the default choice for professional JavaScript development across frontend frameworks, backend services, CLIs, and serverless functions.

Knowledge Map

typescript/
├── project-system/       # tsconfig.json, build tools, bundlers, compilation
├── package-management/   # npm, yarn, pnpm, bun, workspaces, publishing
├── cli/                  # Commander, yargs, oclif, ink, chalk, CLI tooling
└── packages/             # Popular libraries (Express, Next.js, Zod, Prisma, etc.)

Choosing Guide

TypeScript Version Landscape

Core Language Features Quick Reference

Type System Fundamentals

// Union types — value can be one of several types
type Result = "success" | "error" | "pending";
type ID = string | number;

// Intersection types — combine multiple types
type Employee = Person & { employeeId: string };

// Generics — parameterized types
function first<T>(arr: T[]): T | undefined {
  return arr[0];
}

// Conditional types — type-level if/else
type IsString<T> = T extends string ? true : false;

// Mapped types — transform properties
type Readonly<T> = { readonly [K in keyof T]: T[K] };
type Optional<T> = { [K in keyof T]?: T[K] };

// Template literal types — string manipulation at the type level
type EventName<T extends string> = `on${Capitalize<T>}`;
type ClickEvent = EventName<"click">; // "onClick"

// satisfies operator — validate type without widening
const palette = {
  red: [255, 0, 0],
  green: "#00ff00",
} satisfies Record<string, string | number[]>;

// const assertions — narrow to literal types
const routes = ["home", "about", "contact"] as const;
type Route = (typeof routes)[number]; // "home" | "about" | "contact"

// Discriminated unions — tagged union pattern
type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rectangle"; width: number; height: number };

function area(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;
    case "rectangle":
      return shape.width * shape.height;
  }
}

Key Utility Types

Runtime Options

Choosing a Runtime

• Building a production server or API? Node.js has the broadest library support and hosting options.
• Want built-in TypeScript with no config? Deno runs .ts natively with LSP and formatter included.
• Need maximum startup speed or an all-in-one tool? Bun combines runtime, bundler, package manager, and test runner.
• Deploying at the edge? Cloudflare Workers provide sub-millisecond cold starts globally.

Best Practices

1. Enable strict mode in every project. It enables strictNullChecks, noImplicitAny, strictFunctionTypes, and other flags that catch real bugs.
2. Avoid any — it disables all type checking. Use unknown when the type is truly unknown, then narrow with type guards.
3. Prefer unknown over any for values of uncertain type: function parse(input: unknown): Config {if (typeof input === "object" && input!== null && "port" in input) {return input as Config;} throw new Error("Invalid config");}
4. Use type narrowing instead of type assertions: // Prefer this if (typeof value === "string") {console.log(value.toUpperCase());} // Over this console.log((value as string).toUpperCase());
5. Use branded types for domain identifiers to prevent mixing: type UserId = string & {__brand: "UserId"}; type OrderId = string & {__brand: "OrderId"}; function getUser(id: UserId): User {/*... */} // getUser(orderId) — compile error!
6. Use satisfies to validate object shapes without widening types.
7. Use const assertions for literal tuples and objects that should not be widened.
8. Use discriminated unions for state machines and variant types instead of optional properties.
9. Enable noUncheckedIndexedAccess to force undefined checks on dynamic property access.
10. Keep any out of library boundaries — validate external data at the edge with Zod, io-ts, or similar runtime validators.