你的 TypeScript 还只是用来声明 string、number……的吗？

function css(ele: Element, attr: string, value: string | number) {
  // value参数的类型只能是string或者number
  // ......
}
复制代码

type t1 = {
  name: string,
  age: number
}
type t2 = {
  sex: string
}
type t3 = t1 & t2
function sayHi(person: t3) {
  console.log(`${person.name}今年${person.age}岁，性别：${person.sex}`)
}
let king = {
  name: 'king',
  age: 12,
  sex: 'man'
}
let ali = {
  name: 'king',
  sex: 'woman'
}
sayHi(king)
sayHi(ali) // 报错
复制代码

type t1 = {
  name: string,
  sex: 'man' | 'woman'
}
let person: t1 = {
  name: '张三',
  sex: 'middle' // 报错
}
复制代码

let ele = <HTMLImageElement>document.querySelector('.box')
// 或者
let ele2 = document.querySelector('.box') as HTMLImageElement
复制代码

function fun(str: string | string[]) {
  if (typeof str === 'string') {
    str.split('')
  } else {
    // 当其他类型都在if中罗列之后，剩余的一种在else中生效
    str.push()
  }
}
复制代码

type Person = {
  name: string;
  age: number;
}
type PersonKey = keyof Person;
// PersonKey得到的类型为 'name' | 'age'
function getValue(p: Person, k: keyof Person) {
  return p[k];
}
复制代码

// 这个类型可以将任何类型的键值转化成number类型
type TypeToNumber<T> = {
  [key in keyof T]: number
}
复制代码

type Dog<T> = {
  name: string,
  type: T
}
function doSth<T>(dog: Dog<T>) {
  return dog.type
}
let dog = {
  name: 'lucky',
  type: 'pug'
}
// 如果没有泛型推导，就需要写这么多
// let dog: Dog<string> = {
//   name: 'lucky',
//   type: 'pug'
// }
doSth(dog)  // 调用函数时根据type的类型自动推导出了T
复制代码

function sum<T extends number>(value: T[]) {
  let count = 0
  value.forEach(v => count += v)
  return count
}
复制代码

function pick<T, U extends keyof T>(obj: T, proto: U) {
  console.log(obj[proto]);
};
let person = {
  name: '张三',
  age: 14
}
pick(person, 'name')
复制代码

type Per<T> = T extends { t: infer P } ? P : string
type p = Per<number> // string
type p1 = Per<{ t: boolean }> // boolean
type p2 = Per<{ t: number }>  // number
复制代码

type Partial<T> = {
  [P in keyof T]?: T[p]
}
type person = {
  name: string,
  age: number
}
// 使用Partial处理后没有全部属性不再报错
let a: Partial<person> = {
  name: '1q23'
}
复制代码

type Required<T> = {
  [P in keyof T]-?: T[P]
}
type person = {
  name: string,
  age: number
}
let b: Required<person> = {
  name: 'king',
}
复制代码

type Record<K extends keyof any,T> = {
  [key in K]: T
}
// keyof any对应的类型为number | string | symbol,就是可以做索引的类型集合
type person = {
  name: string,
  age: number
}
let c: Record<number, string> = {
  1: 1,
  'str': 123
}
复制代码

type Pick<T, K extends keyof T> = {
  [P in K]: T[P]
}
type person = {
  name: string,
  age: number
}
let d: Pick<person, 'name'> = {
  name: 'king',
  age: 12 
  // 不能将类型“{ name: string; age: number; }”分配给类型“Pick<person, "name">”。对象文字可以只指定已知属性，并且“age”不在类型“Pick<person, "name">”中
}
复制代码

type Exclude<T, U> = T extends U ? never : T
type person = {
  name: string,
  age: number
}
type el = Exclude<person | string, number | 'a' | person> // string
let e: el = 'str'
复制代码

type Omit = Pick<T, Exclude<keyof T, K>>
type person = {
  name: string,
  age: number
}
type oi = Omit<person, 'age'>
let f: oi = {
  name: 'king'
}
复制代码

type ReturnType<T extends (...args: any) => any>
  = T extends (...args: any) => infer R ? R : any;
type T0 = ReturnType<() => string>; // string
type T1 = ReturnType<(s: string) => void>; // void