工具类型

interface User {
    name: string
    age: number
    email?: string
}

type PartialUser = Partial<User>
// { name?: string; age?: number; email?: string }

const partial: PartialUser = { name: "Willow" }  // ✅ OK

function updateUser(id: number, patch: Partial<User>): void {
    // 只需要传入要修改的字段
}
updateUser(1, { name: "Ming" })

type Partial<T> = { [P in keyof T]?: T[P] }

interface Config {
    host?: string
    port?: number
}

type RequiredConfig = Required<Config>
// { host: string; port: number }

const config: RequiredConfig = { host: "localhost", port: 8080 }  // ✅ OK
// const bad: RequiredConfig = { host: "localhost" }  // ❌ port 缺失

function startServer(config: Required<Config>): void {
    // 此时 host 和 port 保证存在
    console.log(`Listening at ${config.host}:${config.port}`)
}

type Required<T> = { [P in keyof T]-?: T[P] }

interface Point {
    x: number
    y: number
}

type FrozenPoint = Readonly<Point>
// { readonly x: number; readonly y: number }

const p: FrozenPoint = { x: 0, y: 0 }
// p.x = 1  // ❌ Cannot assign to 'x' because it is a read-only property

const DEFAULTS: Readonly<Config> = {
    host: "0.0.0.0",
    port: 3000,
}
// DEFAULTS.port = 8080  // ❌ 编译报错

type Readonly<T> = { readonly [P in keyof T]: T[P] }

interface User {
    id: number
    name: string
    age: number
    email: string
}

type UserPreview = Pick<User, "id" | "name">
// { id: number; name: string }

const preview: UserPreview = { id: 1, name: "Ming" }  // ✅ OK

// 数据库实体 → API 公开字段
type PublicUser = Pick<User, "id" | "name">
// 提交表单只需部分字段
type SignupForm = Pick<User, "name" | "email">

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

interface User {
    id: number
    name: string
    password: string
    email: string
}

type PublicUser = Omit<User, "password">
// { id: number; name: string; email: string }

const publicUser: PublicUser = { id: 1, name: "Ming", email: "ming@example.com" }  // ✅ OK

// 排除敏感字段
type SafeUser = Omit<User, "password" | "email">
// 比 Pick 更方便：当要保留的字段远多于排除的字段时
type WithoutId = Omit<User, "id">

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

type Omit<T, K extends keyof any> = { [P in keyof T as Exclude<P, K>]: T[P] }

type Role = "admin" | "editor" | "viewer"
type Permissions = Record<Role, boolean>
// { admin: boolean; editor: boolean; viewer: boolean }

const perms: Permissions = {
    admin: true,
    editor: false,
    viewer: false,
}  // ✅ OK

// 字典
type UserMap = Record<string, User>
// 配置表
type FeatureFlags = Record<string, boolean>
// 枚举映射
type StatusLabel = Record<"pending" | "done" | "failed", string>

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

type All = "a" | "b" | "c" | "d"
type WithoutAB = Exclude<All, "a" | "b">
// "c" | "d"

type Numbers = 1 | 2 | 3 | 4
type Even = Exclude<Numbers, 1 | 3>
// 2 | 4

type Exclude<T, U> = T extends U ? never : T

type All = string | number | boolean | null
type Primitives = Extract<All, string | number | boolean>
// string | number | boolean

type Events = "click" | "scroll" | "keyup" | "keydown"
type KeyEvents = Extract<Events, `key${string}`>
// "keyup" | "keydown"

// 从混合响应类型中提取成功分支
type Response = { ok: true; data: string } | { ok: false; error: Error }
type Success = Extract<Response, { ok: true }>
// { ok: true; data: string }

type Extract<T, U> = T extends U ? T : never

type MaybeString = string | null | undefined
type Clean = NonNullable<MaybeString>
// string

type UserId = NonNullable<number | undefined>
// number

// 过滤掉数组中的空值
const items: (string | null)[] = ["a", null, "b", undefined as unknown as null]
const nonNull: string[] = items.filter((x): x is string => x !== null)
// 或者用类型工具声明过滤后的数组元素类型
type CleanArray = NonNullable<(string | null)[]>[number]
// string

type NonNullable<T> = T extends null | undefined ? never : T

function getUser() {
    return { id: 1, name: "Ming" }
}

type User = ReturnType<typeof getUser>
// { id: number; name: string }

const user: User = getUser()  // ✅ OK

// 工厂函数返回类型复用
function createStore() {
    return {
        count: 0,
        increment: () => {},
        decrement: () => {},
    }
}
type Store = ReturnType<typeof createStore>

type ReturnType<T extends (...args: any[]) => any> =
    T extends (...args: any[]) => infer R ? R : never

function greet(name: string, age: number): string {
    return `${name} is ${age}`
}

type GreetArgs = Parameters<typeof greet>
// [name: string, age: number]

const args: GreetArgs = ["Ming", 25]

// 包装函数，保持一模一样的参数列表
function logWrapper(fn: (...args: any[]) => any, ...args: Parameters<typeof fn>) {
    console.log("Called with", args)
    return fn(...args)
}

type Parameters<T extends (...args: any[]) => any> =
    T extends (...args: infer P) => any ? P : never

class Person {
    constructor(public name: string, public age: number) {}
}

type PersonArgs = ConstructorParameters<typeof Person>
// [name: string, age: number]

const args: PersonArgs = ["Ming", 30]
const person = new Person(...args)

function factory<T extends abstract new (...args: any[]) => any>(
    Ctor: T,
    ...args: ConstructorParameters<T>
): InstanceType<T> {
    return new Ctor(...args)
}

type ConstructorParameters<T extends abstract new (...args: any[]) => any> =
    T extends abstract new (...args: infer P) => any ? P : never

class Person {
    name = "Ming"
    age = 30
}

type PersonInstance = InstanceType<typeof Person>
// Person

const p: PersonInstance = new Person()  // ✅ OK

// 从构造函数引用获取实例类型，无需 import 具体类型
function di<T extends abstract new (...args: any[]) => any>(Ctor: T): InstanceType<T> {
    return new Ctor()
}

type InstanceType<T extends abstract new (...args: any[]) => any> =
    T extends abstract new (...args: any[]) => infer R ? R : never

function handleClick(this: HTMLElement, e: MouseEvent) {
    this.classList.toggle("active")
}

type Context = ThisParameterType<typeof handleClick>
// HTMLElement

type HandlerCtx = ThisParameterType<typeof handleClick>
const button: HandlerCtx = document.createElement("button")
handleClick.call(button, new MouseEvent("click"))

type ThisParameterType<T> =
    T extends (this: infer U, ...args: any[]) => any ? U : unknown

function handleClick(this: HTMLElement, e: MouseEvent) {
    this.classList.toggle("active")
}

type Unbound = OmitThisParameter<typeof handleClick>
// (e: MouseEvent) => void

// 绑定 this 后赋值给独立函数
const bound = handleClick.bind(document.body)
// bound 的类型是 (e: MouseEvent) => void

type OmitThisParameter<T> =
    T extends (this: any, ...args: infer A) => infer R ? (...args: A) => R : T

type P = Promise<string>
type S = Awaited<P>
// string

// 递归解包嵌套 Promise
type Nested = Promise<Promise<number>>
type Num = Awaited<Nested>
// number

async function fetchUser(): Promise<{ id: number; name: string }> {
    return await fetch("/api/user").then(r => r.json())
}

type User = Awaited<ReturnType<typeof fetchUser>>
// { id: number; name: string }

type Awaited<T> =
    T extends null | undefined ? T :                          // 特殊处理 null/undefined
    T extends object & { then(onfulfilled: infer F, ...args: any[]): any } ?
        F extends (value: infer V, ...args: any[]) => any ? Awaited<V> : never :
    T

type Shout = Uppercase<"hello">   // "HELLO"
type Upper = Uppercase<"TypeScript">  // "TYPESCRIPT"

type Whisper = Lowercase<"HELLO">  // "hello"
type Lower = Lowercase<"TypeScript">  // "typescript"

type Title = Capitalize<"hello world">  // "Hello world"
type ClassName = Capitalize<"button">   // "Button"

type Id = Uncapitalize<"Button">  // "button"
type VarName = Uncapitalize<"MyComponent">  // "myComponent"

// 自动生成 getter 名称
type EventName = "click" | "scroll"
type HandlerName = `on${Capitalize<EventName>}`
// "onClick" | "onScroll"

// 驼峰转属性名
type PropName<T extends string> = `$${Uncapitalize<T>}`
type LinkProp = PropName<"Component">
// "$component"

type DeepPartial<T> = {
    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P]
}

// 使用
interface Config {
    server: { host: string; port: number }
    database: { url: string; pool: number }
}

type PartialConfig = DeepPartial<Config>
// 现在 server 和 database 的内部字段也都是可选的了
const cfg: PartialConfig = { server: { host: "localhost" } }  // ✅ OK

type RequiredKeys<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? never : K
}[keyof T]

// 使用
interface User {
    id: number       // 必选
    name?: string    // 可选
    age?: number     // 可选
}

type Mandatory = RequiredKeys<User>
// "id"

type Brand<T, B> = T & { __brand: B }

type UserId = Brand<string, "UserId">
type OrderId = Brand<string, "OrderId">

function getUser(id: UserId) { /* ... */ }

const uid: UserId = "abc" as UserId         // ✅ 需要显式断言
// getUser("abc")                            // ❌ string 不能赋值给 UserId
getUser(uid)                                 // ✅ OK