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

const bar = {
  name: 'bar'
}

// 差集
type Diff<T extends object, K extends object> = Omit<T, keyof K>

type Res = Diff<typeof foo, typeof bar>

// 交集
type InterSection<T extends object, K extends object> = Pick<T, Extract<keyof T, keyof K>>
type Res = InterSection<typeof foo, typeof bar>

// 覆盖
// 1.先去除不同属性
type OverWrite<T extends object, K extends object> = Omit<T, keyof Diff<T, K>> & Pick<K, keyof Diff<K, T>>

interface foo {
  name: string,
  age: number,
  gender: number
}

interface bar {
  name: string,
  age: string,
  address: string
}

type Res = OverWrite<typeof bar, typeof foo> // { name: string, age: string, gender: number }

// 合并
type Compute<T> = {[K in keyof T]: T[K]}
type Merge<T, K> = Omit<T, keyof K> & K

const foo = {
  name: 'foo'
}

const bar = {
  age: 18
}

type Res = Compute<Merge<typeof foo, typeof bar>>