1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 至少一个键必填
type RequireAtLeastOne<T, K extends keyof T = keyof T> =
  Omit<T, K> & { [P in K]-?: Required<Pick<T, P>> & Partial<Pick<T, Exclude<K, P>>> }[K];

// 恰好一个键必填（互斥）
type RequireExactlyOne<T, K extends keyof T = keyof T> =
  Omit<T, K> & {
    [P in K]: Required<Pick<T, P>> & Partial<Record<Exclude<K, P>, never>>
  }[K];

// 全部必填或全部不填
type AllOrNone<T> = T | { [K in keyof T]?: never };

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

type SearchParams = RequireAtLeastOne<{
  byId?: string;
  byName?: string;
  byEmail?: string;
}>;

const a: SearchParams = { byId: "1" };                    // ✅
const b: SearchParams = { byId: "1", byName: "x" };       // ✅ 可以多个
const c: SearchParams = {};                               // ❌ 一个都没有

type Shape = RequireExactlyOne<{ circle: number; square: number }>;

const s1: Shape = { circle: 1 };            // ✅
const s2: Shape = { circle: 1, square: 2 }; // ❌ 两个都给
const s3: Shape = {};                       // ❌ 都没给

type Opts = AllOrNone<{ timeout: number; retries: number }>;
const o1: Opts = {};                        // ✅
const o2: Opts = { timeout: 1, retries: 2 }; // ✅
const o3: Opts = { timeout: 1 };            // ❌ 只给一个

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

declare const brand: unique symbol;

// 通用品牌类型工厂
type Brand<T, B extends string> = T & { readonly [brand]: B };

type UserId = Brand<string, "UserId">;
type OrderId = Brand<string, "OrderId">;
type Cents = Brand<number, "Cents">;
type Dollars = Brand<number, "Dollars">;

// 铸造函数（唯一允许断言的地方）
const UserId = (s: string): UserId => s as UserId;
const OrderId = (s: string): OrderId => s as OrderId;

// 内部算术保持品牌
const addCents = (a: Cents, b: Cents): Cents => (a + b) as Cents;

// 只在边界处解包
const toNumber = (c: Cents): number => c;

1
2
3
4

declare const uid: UserId;
declare const oid: OrderId;
const a: OrderId = uid;      // ❌ TS2322: 无法互赋 ✅ 正是我们要的
const b: string = uid;       // ✅ 可以当 string 用（子类型）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class UserId {
  private readonly _brand!: void;   // 只存在于类型层
  constructor(readonly value: string) {}
}

class OrderId {
  private readonly _brand!: void;
  constructor(readonly value: string) {}
}

function findUser(id: UserId) { /* ... */ }
findUser(new OrderId("x"));
// ❌ TS2345: Types have separate declarations of a private property '_brand'.

1
2
3
4
5
6
7

// 把交叉类型展平成单个对象类型 🔥
type Prettify<T> = { [K in keyof T]: T[K] } & {};

// 变体：只展平一层，保留嵌套结构
type Flatten<T> = T extends object
  ? { [K in keyof T]: T[K] }
  : T;

1
2
3
4
5

type Raw = { a: 1 } & { b: 2 } & { c: 3 };
// 编辑器悬停显示：{ a: 1 } & { b: 2 } & { c: 3 }   😖

type Clean = Prettify<Raw>;
// 编辑器悬停显示：{ a: 1; b: 2; c: 3 }            😊

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// 拆分路径
type Split<S extends string, D extends string = "/"> =
  S extends `${infer H}${D}${infer R}` ? [H, ...Split<R, D>] : [S];

// 提取路由参数
type RouteParams<T extends string> =
  T extends `${string}:${infer P}/${infer R}`
    ? P | RouteParams<`/${R}`>
    : T extends `${string}:${infer P}`
      ? P
      : never;

// 去掉前缀
type StripPrefix<S extends string, P extends string> =
  S extends `${P}${infer R}` ? R : S;

// 短横线转驼峰
type KebabToCamel<S extends string> =
  S extends `${infer H}-${infer T}`
    ? `${H}${Capitalize<KebabToCamel<T>>}`
    : S;

1
2
3
4

type P1 = RouteParams<"/user/:id/post/:postId">;   // "id" | "postId"  ✅
type P2 = Split<"a/b/c">;                          // ["a", "b", "c"]
type P3 = StripPrefix<"onClick", "on">;            // "Click"
type P4 = KebabToCamel<"my-long-name">;            // "myLongName"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

type Routes = "/" | "/users" | "/users/:id" | "/posts/:postId/comments";

// 把 :id 位置变成必需参数
type ExtractParams<T extends string> =
  T extends `${string}:${infer P}/${infer R}`
    ? Record<P, string> & ExtractParams<`/${R}`>
    : T extends `${string}:${infer P}`
      ? Record<P, string>
      : {};

type RouteArgs<R extends string> = ExtractParams<R> extends infer P
  ? keyof P extends never ? [] : [params: P]
  : [];

function navigate<R extends Routes>(route: R, ...args: RouteArgs<R>): void { /* ... */ }

navigate("/");                                       // ✅
navigate("/users");                                  // ✅
navigate("/users/:id", { id: "1" });                 // ✅
navigate("/users/:id");                              // ❌ 缺少参数
navigate("/users/:id", { wrong: "1" });              // ❌ 参数名不对

1
2
3
4

npx tsc --noEmit --extendedDiagnostics
# Types:          1234567
# Instantiations: 9876543     ← 这个数爆炸就是类型体操过重的信号
# Check time:     45.67s

1
2

type Result = DeepReadonly<DeepPartial<Prettify<UnionToIntersection<T>>>>;
// 一旦报错，错误信息里是一坨无法阅读的类型展开

1
2
3
4
5
6
7
8

// 🛑 每次用都重新算
function f1<T>(x: T): DeepReadonly<DeepPartial<T>> { /* ... */ }
function f2<T>(x: T): DeepReadonly<DeepPartial<T>> { /* ... */ }

// ✅ 起个名字，通常也会被复用
type FrozenPatch<T> = DeepReadonly<DeepPartial<T>>;
function f3<T>(x: T): FrozenPatch<T> { /* ... */ }
function f4<T>(x: T): FrozenPatch<T> { /* ... */ }