1
2
3
4
5
6
7
8

// 约束 T 必须有 length
function len<T extends { length: number }>(x: T): number {
  return x.length;
}
len("abc");        // ✅
len([1, 2]);       // ✅
len(123);          // ❌ TS2345: Argument of type 'number' is not assignable to
                   //    parameter of type '{ length: number; }'.

1
2
3
4
5
6
7
8

function get<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];          // ✅ 返回类型精确到属性类型
}

const user = { name: "a", age: 1 };
const n = get(user, "name");   // string
const g = get(user, "age");    // number
get(user, "typo");             // ❌ TS2345: '"typo"' is not assignable to '"name" | "age"'.

1
2
3
4

function bad<T extends { a: number }>(x: T) {
  return x.a;          // ✅ 可以读约束里声明的成员
  // return x.b;       // ❌ TS2339: Property 'b' does not exist on type 'T'.
}

1
2

declare const lit: { a: 1; b: 2 };
const r = bad(lit);       // T 仍是 { a: 1; b: 2 }，不是 { a: number } ✅

1
2
3
4
5
6
7

function withoutConst<T>(x: T) { return x; }
function withConst<const T>(x: T) { return x; }

const w1 = withoutConst({ a: 1 });   // { a: number }
const w2 = withConst({ a: 1 });      // { readonly a: 1 }        🔥
const w3 = withConst(["a", "b"]);    // readonly ["a", "b"]      🔥
const w4 = withoutConst(["a", "b"]); // string[]

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

// 1. 路由/配置表：既要检查又要保留字面量
function defineRoutes<const T extends Record<string, `/${string}`>>(routes: T): T {
  return routes;
}
const routes = defineRoutes({
  home: "/",
  user: "/users/:id",
});
type RouteName = keyof typeof routes;      // "home" | "user"  ✅ 保留了

// 2. 元组保持长度
function tuple<const T extends readonly unknown[]>(...args: T): T { return args; }
const t = tuple(1, "a", true);             // readonly [1, "a", true]

1
2
3

function f<const T>(x: T): T { return x; }
const o = f({ a: 1 });      // { readonly a: 1 }
// o.a = 2;                 // ❌ TS2540

1
2
3
4
5

// 🛑 问题：期望 initial 被 states 约束，实际却反过来扩大了 T
function fsmBad<T extends string>(states: T[], initial: T) { return initial; }

const r1 = fsmBad(["idle", "done"], "idle");     // T = "idle" | "done" （恰好对）
const r2 = fsmBad(["idle", "done"], "typo");     // T = "idle" | "done" | "typo" ⚠️ 竟然通过！

1
2
3
4
5
6

// ✅ 用 NoInfer 排除该位置的推断
function fsm<T extends string>(states: T[], initial: NoInfer<T>) { return initial; }

fsm(["idle", "done"], "idle");   // ✅ T = "idle" | "done"
fsm(["idle", "done"], "typo");
// ❌ TS2345: Argument of type '"typo"' is not assignable to parameter of type '"idle" | "done"'.

1
2

// 用条件类型把候选排除
type NoInferOld<T> = [T][T extends any ? 0 : never];

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 上下文类型：参数自动获得类型，不用重复标注
const nums: number[] = [];
nums.map((n) => n.toFixed(2));    // n 自动是 number

// 显式类型参数解决推断失败
const empty = first<string>([]);   // T = string，而不是 never

// 显式标注回调参数（当上下文丢失时）
declare const cb: (f: (x: { id: number }) => void) => void;
cb((x: { id: number }) => x.id);

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

// 解包 Promise
type Unwrap<T> = T extends Promise<infer U> ? U : T;
type A = Unwrap<Promise<string>>;    // string
type B = Unwrap<number>;             // number

// 取数组元素类型
type El<T> = T extends (infer U)[] ? U : never;
type C = El<string[]>;               // string

// 取函数返回值
type Ret<T> = T extends (...args: never[]) => infer R ? R : never;
type D = Ret<() => number>;          // number

// 取函数参数（更简单的做法：内置 Parameters）
type Args<T> = T extends (...args: infer P) => unknown ? P : never;
type E = Args<(a: string, b: number) => void>;   // [a: string, b: number]

1
2
3
4
5
6

type Unpack2<T> =
  T extends Promise<infer U> ? Unpack2<U> :   // 递归解包
  T extends readonly (infer V)[] ? V :
  T;

type F = Unpack2<Promise<Promise<number[]>>>;   // number

1
2
3
4
5
6
7
8

// 只匹配第一个元素是 string 的元组
type FirstString<T> = T extends [infer S extends string, ...unknown[]] ? S : never;
type G = FirstString<["a", 1]>;      // "a"
type H = FirstString<[1, "a"]>;      // never

// 5.4 之前要写两层的写法
type FirstStringOld<T> =
  T extends [infer S, ...unknown[]] ? (S extends string ? S : never) : never;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 同一处 infer，位置决定推出来的类型
type Param<T> = T extends (x: infer P) => void ? P : never;   // 逆变位置
type RetOf<T> = T extends (x: never) => infer R ? R : never;  // 协变位置

type I = Param<(x: string) => void>;    // string
type J = RetOf<(x: string) => number>;  // number

// 同一函数类型，用在两个位置会得到不同的「最大公共」类型
type Both<T> = T extends (x: infer P) => infer R ? [P, R] : never;
type K = Both<(x: string | number) => boolean>;   // [string | number, boolean]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 递归解包 Promise（内置 Awaited 就是这么做的简化版）
type DeepUnwrap<T> = T extends Promise<infer U> ? DeepUnwrap<U> : T;
type A = DeepUnwrap<Promise<Promise<Promise<string>>>>;   // string

// 深层只读
type DeepReadonly<T> = {
  readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K];
};
type DR = DeepReadonly<{ a: { b: { c: 1 } } }>;
// { readonly a: { readonly b: { readonly c: 1 } } }

1

error TS2589: Type instantiation is excessively deep and possibly infinite.

1
2
3
4
5
6

// 用计数器限制递归深度
type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

type DeepPartial<T, D extends number = 5> =
  D extends 0 ? T :
  { [K in keyof T]?: T[K] extends object ? DeepPartial<T[K], Prev[D]> : T[K] };

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

// 加前缀生成 getter 类型
type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};
type G = Getters<{ name: string; age: number }>;
// { getName: () => string; getAge: () => number }

// 去掉特定前缀
type StripOn<T> = {
  [K in keyof T as K extends `on${infer E}` ? Uncapitalize<E> : never]: T[K];
};

// 按值类型筛选键（把值为函数的键挑出来）
type FunctionKeys<T> = {
  [K in keyof T as T[K] extends (...args: any[]) => any ? K : never]: T[K];
};

// 排除某些键
type OmitByKey<T, K extends PropertyKey> = {
  [P in keyof T as P extends K ? never : P]: T[P];
};

1
2
3
4
5

// 🛑 直接传 K 会报错
type Bad<T> = { [K in keyof T as `get${Capitalize<K>}`]: T[K] };
//                                          ~~~~~~~~~~~ error TS2345
// ✅ 加 string & 交叉
type Good<T> = { [K in keyof T as `get${Capitalize<string & K>}`]: T[K] };

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

// 把可选属性变必需，其余保持
type RequiredKeys<T> = {
  [K in keyof T as {} extends Pick<T, K> ? never : K]: T[K];
};
type OptionalKeys<T> = {
  [K in keyof T as {} extends Pick<T, K> ? K : never]: T[K];
};

// 按值类型分组
type PickByValue<T, V> = {
  [K in keyof T as T[K] extends V ? K : never]: T[K];
};
type StringsOnly = PickByValue<{ a: string; b: number; c: string }, string>;
// { a: string; c: string }

// 深层 Partial
type DeepPartial<T> = T extends object
  ? { [K in keyof T]?: DeepPartial<T[K]> }
  : T;

// 深层只读（保留数组语义）
type DeepReadonly<T> = T extends (infer U)[]
  ? readonly DeepReadonly<U>[]
  : T extends object
    ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
    : T;

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

// out：T 只出现在输出位置（协变）
interface Producer<out T> {
  get(): T;
}

// in：T 只出现在输入位置（逆变）
interface Consumer<in T> {
  set(value: T): void;
}

// in out：双向（不变）
interface Both<in out T> {
  get(): T;
  set(value: T): void;
}

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

// ❌ 函数属性：T 在逆变位置，与 out 冲突
interface B<out T> {
  set: (value: T) => void;
  //   ~~~~~~~~~~~~~~~~~ error TS2636: Type 'B<sub-T>' is not assignable to type
  //                     'B<super-T>' as implied by variance annotation.
  //                     Types of property 'set' are incompatible.
}

// ❌ 返回值位置与 in 冲突
interface C<in T> {
  get(): T;
  //   ~ error TS2636: The types returned by 'get()' are incompatible
  //     between these types.
}

1
2

interface Method<out T> { set(value: T): void }    // ✅ 不报错！
interface Prop<out T>   { set: (value: T) => void } // ❌ TS2636