内置类型（转化类型）

interface Foo {
  name: string,
  age: number,
  address: string
}

// Error，但有时候信息缺失也必须添加，直接修改原始类型 Foo 不合适。
let foo: Foo = {
  name: 'foo'
}

// 全都变成可选属性了
type MyFoo = Partial<Foo>
// Ok
let foo: MyFoo = {
  name: 'Foo'
}

// keyof T 获取对象 T 的所有属性
// [K in keyof T] 表示遍历每个属性
type Partical<T> = {[K in keyof T]?: T[K]}

// 深度全部可选
type DeepPartial<T> = {[K in keyof T]?: T[K] extends object ? DeepPartical<T[K]> : T[K]}
interface Foo = {
  name: string,
  age: number,
  info: {
    address: string,
    salary: number
  }
}
type MyFoo = DeepPartical<Foo>
let foo: MyFoo = {
  name: 'foo',
  age: 18,
  info:  {
    address: 'address'
  }
}

interface Foo {
  name?: string,
  age?: number,
  address?: string
}
// 可选变为必选
type MyFoo = Require<Foo>
// -? 表示可选变成必选 
type Require<T> = { [K in keyof T]-?: T[K] }
export {}

// 只读
type MyFoo = Readonly<Foo>
type Readonly<T> = { readonly [K in keyof T]: T[K] }

// Pick 精挑细选
interface Foo {
  name: string,
  age: number,
  address: string
}
// 抽离是 n 个类型中选 1 个
// Pick 是对象 n 个属性中选 1-n 个
type PickFoo = Pick<Foo, 'name' | 'age'>
type Pick<T, K extends keyof T> = {[U in K]: T[U]}

// Record
const foo: Record<string, any> = {
  name: 'foo',
  age: 18
}
type Record<K extends keyof any, T> = {
  [P in K]: T
}

const foo = {
  name: 'foo',
  age: 18
}

function map<T extends keyof any, K, U> (
  target: Record<T, K>,
  cb: (value: K, key: T) => U
): Record<T, U> {
  let res = {} as Record<T, U>

  for (let key in target) {
    res[key] = cb(target[key], key)
  }

  return res
}

map(foo, (value, key) => {
  return value + ''
})
const foo = {
  name: 'foo',
  age: 18
}

function map<T extends keyof any, K, U> (
  target: Record<T, K>,
  cb: (value: K, key: T) => U
): Record<T, U> {
  let res = {} as Record<T, U>

  for (let key in target) {
    res[key] = cb(target[key], key)
  }

  return res
}

map(foo, (value, key) => {
  return value + ''
})
const foo = {
  name: 'foo',
  age: 18
}

function map<T extends keyof any, K, U> (
  target: Record<T, K>,
  cb: (value: K, key: T) => U
): Record<T, U> {
  let res = {} as Record<T, U>

  for (let key in target) {
    res[key] = cb(target[key], key)
  }

  return res
}

map(foo, (value, key) => {
  return value + ''
})
const foo = {
  name: 'foo',
  age: 18
}

function map<T extends keyof any, K, U> (
  target: Record<T, K>,
  cb: (value: K, key: T) => U
): Record<T, U> {
  let res = {} as Record<T, U>

  for (let key in target) {
    res[key] = cb(target[key], key)
  }

  return res
}

map(foo, (value, key) => {
  return value + ''
})
const foo = {
  name: 'foo',
  age: 18
}

function map<T extends keyof any, K, U> (
  target: Record<T, K>,
  cb: (value: K, key: T) => U
): Record<T, U> {
  let res = {} as Record<T, U>

  for (let key in target) {
    res[key] = cb(target[key], key)
  }

  return res
}

map(foo, (value, key) => {
  return value + ''
})
const foo = {
  name: 'foo',
  age: 18
}

function map<T extends keyof any, K, U> (
  target: Record<T, K>,
  cb: (value: K, key: T) => U
): Record<T, U> {
  let res = {} as Record<T, U>

  for (let key in target) {
    res[key] = cb(target[key], key)
  }

  return res
}

map(foo, (value, key) => {
  return value + ''
})
const foo = {
  name: 'foo',
  age: 18
}

function map<T extends keyof any, K, U> (
  target: Record<T, K>,
  cb: (value: K, key: T) => U
): Record<T, U> {
  let res = {} as Record<T, U>

  for (let key in target) {
    res[key] = cb(target[key], key)
  }

  return res
}

map(foo, (value, key) => {
  return value + ''
})
const foo = {
  name: 'foo',
  age: 18
}

function map<T extends keyof any, K, U> (
  target: Record<T, K>,
  cb: (value: K, key: T) => U
): Record<T, U> {
  let res = {} as Record<T, U>

  for (let key in target) {
    res[key] = cb(target[key], key)
  }

  return res
}

map(foo, (value, key) => {
  return value + ''
})

// Omit 忽略属性
interface Foo {
  name: string,
  age: number
}

type MyFoo = Omit<Foo, 'age'> // { name: string }
type Omit<K, T extends keyof any> = Pick<K, Exclude<keyof K, T>>