TypeScript 类型系统基础

常用的收窄手段：

// 自定义守卫：注意返回值类型是 x is T，不是 boolean
function isUser(x: unknown): x is { id: string; name: string } {
  return typeof x === "object" && x !== null && "id" in x && "name" in x;
}

// 断言函数：调用后整个作用域都收窄
function assertUser(x: unknown): asserts x is { id: string } {
  if (!isUser(x)) throw new TypeError("not a user");
}

四、泛型

泛型是"类型的参数"，核心价值是保留入参与返回值的类型关联。

// ✗ 用 any：丢失了关联
function firstAny(arr: any[]): any { return arr[0]; }

// ✓ 用泛型：T 被推断并保留
function first<T>(arr: T[]): T | undefined { return arr[0]; }
const s = first(["a", "b"]); // string | undefined

约束与默认值：

function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> {
  const out = {} as Pick<T, K>;
  for (const k of keys) out[k] = obj[k];
  return out;
}

type ApiRes<T = unknown> = { code: number; data: T };

推断优先级：调用时显式传入 > 参数推断 > 默认值。

五、条件类型与 infer

type IsArray<T> = T extends any[] ? true : false;

// infer 在 extends 里"提取"类型
type ElementOf<T> = T extends (infer U)[] ? U : never;
type Unwrap<T> = T extends Promise<infer U> ? U : T;

type A = Unwrap<Promise<number>>;  // number
type B = ElementOf<string[]>;      // string

分布式条件类型：当 T 是裸类型参数且传入联合类型时，会逐个分发。

type ToArray<T> = T extends any ? T[] : never;
type R = ToArray<string | number>; // string[] | number[]（分发）

// 想避免分发：用元组包一层
type ToArrayNoDist<T> = [T] extends [any] ? T[] : never;
type R2 = ToArrayNoDist<string | number>; // (string | number)[]

六、映射类型

type MyPartial<T> = { [K in keyof T]?: T[K] };
type MyReadonly<T> = { readonly [K in keyof T]: T[K] };
type Mutable<T> = { -readonly [K in keyof T]: T[K] };   // 去掉 readonly
type Required<T> = { [K in keyof T]-?: T[K] };          // 去掉可选

// 键重映射（4.1+）
type Getters<T> = { [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K] };

模板字面量类型让字符串也有了类型运算：

type EventName = "click" | "focus";
type Handler = `on${Capitalize<EventName>}`; // "onClick" | "onFocus"

七、常用工具类型速查

实现原理见 类型体操。

八、工程配置要点

tsconfig.json 里影响类型检查行为的几个关键项：

{
  "compilerOptions": {
    "strict": true,              // 一次开启下面所有严格项，新项目必开
    "noImplicitAny": true,       // 禁止隐式 any（迁移老项目时最后再开）
    "strictNullChecks": true,    // null/undefined 不兼容其他类型
    "noUncheckedIndexedAccess": true, // arr[i] 结果带 undefined，防止越界
    "exactOptionalPropertyTypes": true, // 区分"没有该属性"与"值为 undefined"
    "skipLibCheck": true,        // 跳过 node_modules 的 d.ts 检查，显著提速
    "moduleResolution": "bundler" // 配合 vite/webpack，无需写扩展名
  }
}

声明文件：给没有类型的库写 .d.ts，或给全局对象扩展类型。

// types/global.d.ts
declare global {
  interface Window { __APP_VERSION__: string }
}
export {};

九、常见误区

1. as 不是类型转换——它只说服编译器，运行时没有任何检查。能用守卫就不要用断言。
2. 类型只在编译期存在，运行时 instanceof 无法用于 interface。
3. Object.keys() 返回 string[]，不是 keyof T。需要精确键时用 (Object.keys(o) as (keyof T)[])。
4. 过度设计类型：类型体操要服务于可维护性，写完自己读不懂的类型不如 any 加注释。

面试问法

• interface 和 type 的区别？（合并能力 / 映射类型 / 联合类型）
• any 和 unknown 的区别？为什么推荐 unknown？
• 条件类型为什么会"分发"？怎么写不分发的版本？
• 如何给一个函数重载写类型？

参考

• TypeScript 官方手册
• 类型体操