内置工具类型

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] };

type User = { id: number; name: string; email?: string };
 
// 1) Partial: 全部变可选，适合「补丁对象」
const patch: Partial<User> = { name: "Ada" };
console.log("Partial:", JSON.stringify(patch));
 
// 2) Required: 全部变必填，email 也不能少了
const full: Required<User> = { id: 1, name: "Ada", email: "ada@example.com" };
console.log("Required:", JSON.stringify(full));
 
// 3) Readonly: 全部只读
const frozen: Readonly<User> = full;
// frozen.id = 2;  // 若取消注释会报错：无法为只读属性赋值
console.log("Readonly id:", frozen.id);
 
// 4) 手写实现
type MyPartial<T> = { [K in keyof T]?: T[K] };
type MyRequired<T> = { [K in keyof T]-?: T[K] };
type MyReadonly<T> = { readonly [K in keyof T]: T[K] };
 
const mine: MyPartial<User> = { email: "x@y.z" };
console.log("MyPartial:", JSON.stringify(mine));
 
function applyPatch(base: User, p: Partial<User>): User {
  return Object.assign({}, base, p);
}
console.log("merged:", JSON.stringify(applyPatch(full, { name: "Grace" })));

type Pick<T, K extends keyof T> = { [P in K]: T[P] };

type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

type Record<K extends keyof any, V> = { [P in K]: V };

type Todo = { id: number; title: string; done: boolean; owner: string };
 
type TodoPreview = Pick<Todo, "id" | "title">;
const preview: TodoPreview = { id: 1, title: "写 TS 教程" };
console.log("Pick:", JSON.stringify(preview));
 
type PublicTodo = Omit<Todo, "owner">;
const pub: PublicTodo = { id: 2, title: "复习类型", done: false };
console.log("Omit:", JSON.stringify(pub));
 
type Page = "home" | "about" | "contact";
// 少写一个 key 就会编译报错，天然的穷尽性检查
const titles: Record<Page, string> = {
  home: "首页",
  about: "关于我们",
  contact: "联系我们",
};
console.log("Record:", JSON.stringify(titles));
 
// 手写实现
type MyPick<T, K extends keyof T> = { [P in K]: T[P] };
type MyRecord<K extends keyof any, V> = { [P in K]: V };
type MyOmit<T, K extends keyof any> = MyPick<T, Exclude<keyof T, K>>;
 
const slim: MyOmit<Todo, "owner" | "done"> = { id: 3, title: "手写 Omit" };
console.log("MyOmit:", JSON.stringify(slim));
 
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;
}
const t: Todo = { id: 4, title: "运行一下", done: true, owner: "me" };
console.log("运行时 pick:", JSON.stringify(pick(t, ["id", "done"])));

type Exclude<T, U>   = T extends U ? never : T;
type Extract<T, U>   = T extends U ? T : never;
type NonNullable<T>  = T & {};   // TS 4.9 起改成了交叉写法

type ReturnType<T extends (...a: any) => any> = T extends (...a: any) => infer R ? R : any;
type Parameters<T extends (...a: any) => any> = T extends (...a: infer P) => any ? P : never;

function makeUser(id: number, name: string) {
  return { id, name, createdAt: "2026-01-01" };
}
 
type UserShape = ReturnType<typeof makeUser>;
type UserArgs = Parameters<typeof makeUser>;
 
const args: UserArgs = [7, "Grace"];
const u: UserShape = makeUser(...args);
console.log("ReturnType:", JSON.stringify(u));
 
async function fetchCount(): Promise<number> {
  return 42;
}
type Count = Awaited<ReturnType<typeof fetchCount>>;
const c: Count = 42;
console.log("Awaited:", c);
 
// 手写 ReturnType
type MyReturnType<T extends (...a: never[]) => unknown> =
  T extends (...a: never[]) => infer R ? R : never;
const same: MyReturnType<typeof makeUser> = u;
console.log("MyReturnType 通过:", same.name);
 
// 用「参数元组 + 返回值」两个类型参数写一个通用日志包装器
function withLog<A extends unknown[], R>(name: string, fn: (...a: A) => R) {
  return (...args: A): R => {
    console.log("调用", name, "参数:", JSON.stringify(args));
    return fn(...args);
  };
}
const logged = withLog("makeUser", makeUser);
type LoggedArgs = Parameters<typeof logged>;
const nextArgs: LoggedArgs = [9, "Linus"];
console.log("结果:", JSON.stringify(logged(...nextArgs)));
 
type Kind = "a" | "b" | 1 | 2;
const onlyStr: Extract<Kind, string> = "a";
const onlyNum: Exclude<Kind, string> = 2;
const notNull: NonNullable<string | null | undefined> = "safe";
console.log(onlyStr, onlyNum, notNull);