映射类型与条件类型

type Mapped<T> = {
  [K in keyof T]: T[K];
};

type Stringify<T> = {
  [K in keyof T]: string;      // 所有属性都变成 string
};
 
type Nullable<T> = {
  [K in keyof T]: T[K] | null;  // 所有属性都可以为空
};

type Partial<T> = { [K in keyof T]?: T[K] };
type Required<T> = { [K in keyof T]-?: T[K] };
type Readonly<T> = { readonly [K in keyof T]: T[K] };

interface User {
  readonly id: number;
  name: string;
  email?: string;
}
 
// 手写 Partial / Required / Readonly
type MyPartial<T> = { [K in keyof T]?: T[K] };
type MyRequired<T> = { [K in keyof T]-?: T[K] };
type MyMutable<T> = { -readonly [K in keyof T]: T[K] };
 
// 全部变成可选：可以只传一部分
function update(user: User, patch: MyPartial<User>): User {
  return { ...user, ...patch };
}
 
const u: User = { id: 1, name: "Ada" };
const u2 = update(u, { name: "Ada L." });
console.log("更新后 name = " + u2.name + "，id = " + u2.id);
 
// 全部变成必选：email 不再可选
const full: MyRequired<User> = { id: 2, name: "Alan", email: "alan@x.com" };
console.log("必选版 email = " + full.email);
 
// 去掉 readonly：id 变得可写
const mutable: MyMutable<User> = { id: 3, name: "Grace" };
mutable.id = 30;
console.log("可写版 id = " + mutable.id);
 
// 改造值类型：把每个字段都变成「取值函数」
type Lazy<T> = { [K in keyof T]: () => T[K] };
 
const lazyUser: Lazy<{ name: string; score: number }> = {
  name: () => "Grace",
  score: () => 91,
};
console.log("惰性求值: " + lazyUser.name() + " " + lazyUser.score());
 
// 值类型统一改写
type Flags<T> = { [K in keyof T]: boolean };
const dirty: Flags<{ name: string; email: string }> = { name: true, email: false };
console.log("name 改过? " + dirty.name + "，email 改过? " + dirty.email);

type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

type OnlyStrings<T> = {
  [K in keyof T as T[K] extends string ? K : never]: T[K];
};

interface Person {
  name: string;
  age: number;
  email: string;
}
 
// 1) as 子句最简单的用法：原样保留（等价于不写 as）
type Identity<T> = {
  [K in keyof T as K]: T[K];
};
 
const p: Identity<Person> = { name: "Ada", age: 36, email: "ada@x.com" };
console.log("as 原样映射保留全部键: " + Object.keys(p).join(","));
 
// 2) 用 never 过滤：只保留值为 string 的属性
type OnlyStrings<T> = {
  [K in keyof T as T[K] extends string ? K : never]: T[K];
};
 
const s: OnlyStrings<Person> = { name: "Alan", email: "alan@x.com" };
console.log("只剩字符串字段: " + Object.keys(s).join(","));
// const bad: OnlyStrings<Person> = { name: "x", age: 1 };  // 错误：age 已被过滤掉
 
// 3) 反向过滤：去掉某些键
type Without<T, Drop extends keyof T> = {
  [K in keyof T as K extends Drop ? never : K]: T[K];
};
 
const noEmail: Without<Person, "email"> = { name: "Grace", age: 45 };
console.log("去掉 email 后: " + Object.keys(noEmail).join(","));
 
function summarize(x: Without<Person, "email">): string {
  return x.name + " / " + x.age;
}
console.log(summarize(noEmail));

type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};
 
type PersonGetters = Getters<{ name: string; age: number }>;
// 等价于 { getName: () => string; getAge: () => number }
 
type EventHandlers<T> = {
  [K in keyof T as `on${Capitalize<string & K>}Change`]?: (v: T[K]) => void;
};

type IsString<T> = T extends string ? true : false;
 
type A = IsString<"hi">;     // true
type B = IsString<42>;       // false

type Unwrap<T> = T extends Array<infer E> ? E : T;

type ReturnOf<F> = F extends (...args: any[]) => infer R ? R : never;
type ElementOf<T> = T extends Array<infer E> ? E : never;
type Head<T> = T extends [infer H, ...unknown[]] ? H : never;

type ToArray<T> = T extends unknown ? T[] : never;
type R = ToArray<string | number>;   // string[] | number[]

type Exclude<T, U> = T extends U ? never : T;
type X = Exclude<"a" | "b" | "c", "a">;   // "b" | "c"

type IsUnion<T> = [T] extends [infer _] ? false : false;   // 简化示意
type NoDist<T> = [T] extends [string] ? true : false;

// 基本条件类型
type IsString<T> = T extends string ? true : false;
 
const yes: IsString<"hi"> = true;
const no: IsString<42> = false;
console.log("IsString 字符串 = " + yes + "，数字 = " + no);
 
// 分发：联合会被逐个处理
type Boxed<T> = T extends unknown ? { value: T } : never;
type BoxedSN = Boxed<string | number>;   // { value: string } | { value: number }
 
const b1: BoxedSN = { value: "文本" };
const b2: BoxedSN = { value: 42 };
console.log("分发结果可以装字符串: " + b1.value);
console.log("也可以装数字: " + b2.value);
// const bad: BoxedSN = { value: true };   // 错误：布尔不在联合里
 
// 手写 Exclude / Extract
type MyExclude<T, U> = T extends U ? never : T;
type MyExtract<T, U> = T extends U ? T : never;
 
type Level = "debug" | "info" | "warn" | "error";
type Serious = MyExclude<Level, "debug" | "info">;   // "warn" | "error"
type Quiet = MyExtract<Level, "debug" | "info">;     // "debug" | "info"
 
const s: Serious = "error";
const q: Quiet = "debug";
console.log("严重级别: " + s + "，安静级别: " + q);
 
function alarm(level: Serious): string {
  return "触发告警: " + level;
}
console.log(alarm("warn"));
// alarm("debug");   // 错误：debug 已被 Exclude 掉
 
// 关掉分发：用方括号包住类型参数
type NoDist<T> = [T] extends [string] ? "全是字符串" : "不全是";
const r1: NoDist<string> = "全是字符串";
const r2: NoDist<string | number> = "不全是";
console.log(r1 + " / " + r2);

// 1) 取函数返回类型
type ReturnOf<F> = F extends (...args: any[]) => infer R ? R : never;
 
function loadUser(id: number) {
  return { id, name: "Ada", tags: ["admin", "dev"] };
}
type User = ReturnOf<typeof loadUser>;
 
const u: User = { id: 1, name: "Ada", tags: ["admin"] };
console.log("从函数推出的类型: " + u.name + " / " + u.tags.join(","));
 
// 2) 取参数类型元组
type ParamsOf<F> = F extends (...args: infer P) => unknown ? P : never;
 
function send(url: string, retries: number, silent: boolean): string {
  return url + " 重试 " + retries + " 次" + (silent ? "（静默）" : "");
}
type SendArgs = ParamsOf<typeof send>;   // [string, number, boolean]
 
const args: SendArgs = ["/api/user", 3, true];
console.log(send(...args));
 
// 3) 取数组元素类型
type ElementOf<T> = T extends readonly (infer E)[] ? E : never;
 
const colors = ["red", "green", "blue"] as const;
type Color = ElementOf<typeof colors>;   // "red" | "green" | "blue"
 
function paint(c: Color): string {
  return "涂上" + c;
}
console.log(paint("green"));
// paint("black");   // 错误：不在联合里
 
// 4) 拆元组的头和尾
type Head<T> = T extends [infer H, ...unknown[]] ? H : never;
type Tail<T> = T extends [unknown, ...infer R] ? R : never;
 
type Args = [string, number, boolean];
const head: Head<Args> = "第一项是字符串";
const tail: Tail<Args> = [7, false];
console.log(head + "，剩下 " + tail.length + " 项: " + tail.join(","));
 
// 5) 组合：从函数类型直接构造「带缓存的同签名函数」类型
type Cached<F> = F extends (...args: infer P) => infer R
  ? (...args: P) => R
  : never;
 
const cachedSend: Cached<typeof send> = (url, retries, silent) =>
  send(url, retries, silent);
console.log(cachedSend("/api/ping", 1, false));

type DeepReadonly<T> = {
  readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K];
};