typescript类型进阶

超类型与子类型

• 任何能使用超类型的地方都可以使用子类型
• never 是所有类型的子类型，在任何地方都可以使用never

function Never():never{
  throw ''
}
let test:string=Never()

• 所有类型都是any的子类型
• A类型<:B类型，A类型是B 类型的子类型
• number 是 number | string的子类型
• 对于结构类型,约束越多(属性，方法越多)，可表示的东西就越少，类型就越小

type A={
 id:number
 name:string
}
type B={
 name:string
}
//A<B,A是B的子类型
let a:A={
	id:2,
	name:''
}
let b:B=a

keyof 运算符

• keyof取得类型的key值组成的联合类型。将类型的键作为类型
  type A= keyof any 等价于 type A= string | number | symbol
• 获取普通对象的结构

type User={
  name:string
  age:number
}
// 获取类型中的key,UserKeys='name'|'age'
type UserKeys=keyof User 
//=> type UserKeys='name'|'age'
let keys:UserKeys='age'	
// 获取对象的结构
const obj={
  props:[],
  get(){},
  set(param:string){},
}
type ObjT=typeof obj
/* 
type ObjT = {
    props: never[];
    get(): void;
    set(param: string): void;
}
*/

Record<K,V>

键的类型是K,值的类型是V
Record<K,T> 将类型K作为索引签名，将T作为索引签名值的类型
K:可以是string,number,symbol这种宽类型
K:也可以是由一个对象的键所组成的字面量类型

type Record<K extends keyof any, T> = {
    [P in K]: T;
};
type MyRecord={
[Key in UnionType]:ValueType
}

// 根据作者映射作品信息
type author='A'|'B'|'C'
interface book{
 id:number
 name:string
 description:string
}
// books键的类型是author,值的类型是book数组
const books:Record<author,book[]>={
  'A':[{
    id:1,
    name:'',
    description:''
  }],
  'B':[{
    id:1,
    name:'',
    description:''
  }],
  'C':[{
    id:1,
    name:'',
    description:''
  }],
}
// 与下面的写法相同
const otherbooks:{[k in author]:book[]}={
  'A':[{
    id:1,
    name:'',
    description:''
  }],
  'B':[{
    id:1,
    name:'',
    description:''
  }],
  'C':[{
    id:1,
    name:'',
    description:''
  }],
}

in操作符

in 会对联合类型进行迭代，类似于for...of,上面的例子已经使用过了。

Partial

把Object中的每个字段都标记为可选

type Partial<T> = {
    [P in keyof T]?: T[P]
}
interface Props {
  a: number;
  b: string;
}
// 使Props的属性可选
let prop:Partial<Props>={
  b:''
}

Required

把Object中的每个字段都标记为必选，与Partial 相反

type Required<T> = {
    [P in keyof T]-?: T[P]
}
interface Props {
  a?: number;
  b?: string;
}
// Props的每个字段都是必须的
let prop:Required<Props>={
  b:'',
  a:1
}

Readonly

把Object中的每个字段标记为只读

Pick<Object,Keys>

返回Object的子类型，只含指定的keys

interface Props {
  a?: number;
  b?: string;
}
let prop:Pick<Props,'a'|'b'>={
  b:'',
  a:1
}

infer variable

用于推断infer所处位置的变量 variable的类型
type ParamType<T> = T extends (arg: infer P) => any ? P : T; 观察infer的位置,这里推断函数参数的类型

// 推断参数位置的类型，当三元运算为true，就返回推断结果。
// 如果泛型T是函数类型，那么就返回参数的类型
type ParamType<T> = T extends (arg: infer P) => any ? P : T;
interface User {
  name: string;
  age: number;
}

type Func = (user: User) => void;
// Func 是函数类型，满足条件，返回infer推断的类型
type Param = ParamType<Func>; // infer的推断结果为User, Param = User
type AA = ParamType<string>; // string

type ReturnType<T> = T extends (...args: any[]) => infer P ? P : any; 请观察infer的位置，这里推断函数返回值的类型。

// 函数返回值的类型为User
type Func = () => User;
type Test = ReturnType<Func>; // Test = User

Exclude<T,U>

返回T中有，U中没有的类型

type A='string'|'number'
type B='string'
type C=Exclude<A,B> // 'number'

Extract<T,U>

返回T，U中都有的类型

NonNullable

排除掉null和undefined

type A={a:number|null}
type B=NonNullable<A['a']>

ReturnType

计算函数的返回类型（不适用于泛型和重载的函数）

type F=(a:number)=>string
type R=ReturnType<F> // string