工具类型

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

// 所有属性变为可选
type PartialUser = Partial<User>;

function updateUser(user: User, updates: PartialUser): User {
  return { ...user, ...updates };
}

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

// 所有属性变为必需
type RequiredUser = Required<User>;

let user: RequiredUser = {
  name: 'John',
  age: 25,
  email: 'john@example.com'
};

interface User {
  name: string;
  age: number;
}

// 所有属性变为只读
type ReadonlyUser = Readonly<User>;

let user: ReadonlyUser = {
  name: 'John',
  age: 25
};

// user.name = 'Jane'; // 错误

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

// 选择部分属性
type UserPreview = Pick<User, 'id' | 'name'>;

let preview: UserPreview = {
  id: 1,
  name: 'John'
};

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

// 排除部分属性
type UserPublic = Omit<User, 'password'>;

let user: UserPublic = {
  id: 1,
  name: 'John',
  email: 'john@example.com'
};

// 创建对象类型
type Role = 'admin' | 'user' | 'guest';

type Permissions = Record<Role, string[]>;

let permissions: Permissions = {
  admin: ['read', 'write', 'delete'],
  user: ['read', 'write'],
  guest: ['read']
};

// 从联合类型中排除
type T1 = Exclude<'a' | 'b' | 'c', 'a'>; // 'b' | 'c'
type T2 = Exclude<string | number | boolean, boolean>; // string | number

// 从联合类型中提取
type T1 = Extract<'a' | 'b' | 'c', 'a' | 'f'>; // 'a'
type T2 = Extract<string | number | boolean, boolean>; // boolean

// 排除 null 和 undefined
type T1 = NonNullable<string | number | null | undefined>; // string | number
type T2 = NonNullable<string | null>; // string

// 获取函数返回值类型
function getUser() {
  return {
    id: 1,
    name: 'John',
    age: 25
  };
}

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

// 获取函数参数类型
function createUser(name: string, age: number, email: string) {
  return { name, age, email };
}

type Params = Parameters<typeof createUser>;
// [string, number, string]

function wrapper(...args: Params) {
  return createUser(...args);
}

// 获取构造函数参数类型
class User {
  constructor(public name: string, public age: number) {}
}

type UserParams = ConstructorParameters<typeof User>;
// [string, number]

// 获取构造函数实例类型
class User {
  name: string;
  age: number;
}

type UserInstance = InstanceType<typeof User>;
// User

// 获取函数 this 参数类型
function toHex(this: Number) {
  return this.toString(16);
}

type T = ThisParameterType<typeof toHex>; // Number

// 移除函数 this 参数
function toHex(this: Number) {
  return this.toString(16);
}

type T = OmitThisParameter<typeof toHex>; // () => string

type T = Uppercase<'hello'>; // 'HELLO'

type T = Lowercase<'HELLO'>; // 'hello'

type T = Capitalize<'hello'>; // 'Hello'

type T = Uncapitalize<'Hello'>; // 'hello'

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

interface User {
  name: string;
  address: {
    city: string;
    street: string;
  };
}

let user: DeepPartial<User> = {
  address: {
    city: 'Beijing'
  }
};

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

type Mutable<T> = {
  -readonly [P in keyof T]: T[P];
};

interface User {
  readonly name: string;
  readonly age: number;
}

type MutableUser = Mutable<User>;
// { name: string; age: number }