TS 高级类型

交叉类型

T & U
示例：
type IPerson {
  name: string;
  age: number;
}

type IMan {
  love: string;
  age: number;
}
type mixin = IPerson & IMan
//{
//  name: string;
//  age: number;
//  love: string;
//}

联合类型

T | U

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

interface IMan {
  love: string;
  age: number;
}

type me = IPerson | IMan;
//{
//  age: number;
//}

类型断言/类型保护

断言 as
保护 is
interface IPerson {
  name: string;
  age: number;
}
function isIPerson(obj: IPerson | IMan): obj is IPerson {
  return (obj as IPerson).name !== undefined;
}

属性

只读属性 readonly
任意属性 any
可选属性 ?
强制解析 ！
interface Person {
    readonly id: number;
    name: string;
    age?: number;
    [propName: string]: any;
}

条件类型

Exclude<T, U> -- 从T中剔除可以赋值给U的类型。
Extract<T, U> -- 提取T中可以赋值给U的类型。
NonNullable<T> -- 从T中剔除null和undefined。
ReturnType<T> -- 获取函数返回值类型。
InstanceType<T> -- 获取构造函数类型的实例类型。

Partial类型

//将所有类型变成可选

type User = {
    id: number,
    name: string
}

type PartialUser = MyPartial<User>

//PartialUser => {
    id?: number,
    name?: string
}

pick<Type, Keys>函数

Pick

const User = {
    name: "张三",
    age: 18,
}
const nameValue = pick(User, "name")//胡先生

Omit

//找到泛型T中除了K以外的其他属性
type Props = { name: string; age: number; visible: boolean };
type omitTy = Omit<Props, 'name'>;
//omitTy => { age: number; visible: boolean}

Record

//用于构建一个对象类型，将一种类型的属性映射到另一种类型

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

type KeyTy = "keyone" | "keytwo" 
type RcTy = Record<KeyTy, OneTy>;

// 结果
ReTy => {
  keyone: {
   name: string;
   age: number;
  },
  keytwo: {
   name: string;
   age: number;
  },
}
 

Exclude<Type, ExcludedUnion>

//在联合类型中排除一个类型构建新类型
type T1 = Exclude<"a" | "b" | "c", "a" | "b">  
//type T1 = "c"

Extract

//类型交集 和Exclude相反
type T2 = Extract<"a" | "b" | "c",  "a" | "b">  
//type T2 = "a" | "b"

ReturnType

type T3 = ReturnType<() => string>;  
// type T3 = string
type T4 = ReturnType<(s: string) => void>;  
// type T4 = void
type T5 = ReturnType<(<T>() => T)>;  
// type T5 = {}