学习TS(11) 内置类型

「这是我参与2022首次更文挑战的第40天，活动详情查看：2022首次更文挑战」。

Partial

Partial 的作用就是将某个类型里的属性全部变为可选项 ?。

type Partial<T> = { [K in keyof T]?: T[K] }; 实现原理

在以上代码中，首先通过 keyof T 拿到 T 的所有属性名，然后使用 in 进行遍历，将值赋给 k，最后通过 T[k] 取得相应的属性值。中间的 ? 号，用于将所有属性变为可选。

Partial 转化可选属性

interface Company {
    num:number
}
interface Person {
    name: string,
    age: string,
    company: Company
}

type PartialPerson = Partial<Person>;

遍历所有的属性将属性设置为可选属性,但是无法实现深度转化!

type DeepPartial<T> = {
    [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K]
}
type DeepPartialPerson = DeepPartial<Person>;

我们可以实现深度转化,如果值是对象可以继续深度转化

Required 转化必填属性

interface Company {
    num: number
}
interface Person {
    name: string,
    age: string,
    company: Company
}
type PartialPerson = Partial<Person>;
type Required<T> = {[K in keyof T]-?:T[K]} 
type RequiredPerson = Required<PartialPerson>

将所有属性转化成为必填属性

Readonly 转化仅读属性

type Readonly<T> = { readonly [K in keyof T]: T[K] }
type RequiredPerson = Readonly<Person>

将所有属性变为仅读状态

Pick 挑选所需的属性

type Pick<T, U extends keyof T> = { [P in U]: T[P] }
type PickPerson = Pick<Person, 'name' | 'age'>

在已有类型中挑选所需属性

Record 记录类型

type Record<K extends keyof any, T> = { [P in K]  : T }
let person: Record<string, any> = { name: 'zf', age: 11 };

实现map方法，我们经常用record类型表示映射类型

function map<T extends keyof any, K, U>(obj: Record<T, K>, callback: (item: K, key: T) => U) {
    let result = {} as Record<T, U>
    for (let key in obj) {
        result[key] = callback(obj[key], key)
    }
    return result
}
const r = map({ name: 'dafei', age: 18 }, (item, key) => {
    return item
});

Omit忽略属性

let person = {
    name: 'dafei',
    age: 18,
    address: '回龙观'
}
type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>
type OmitAddress = Omit<typeof person, 'address'>

忽略person中的address属性 (先排除掉不需要的key，在通过key选出需要的属性)

unknown

unknown类型

unknown 类型，任何类型都可以赋值为unknown类型。 它是 any 类型对应的安全类型

let unknown:unknown;
unknown = 'df';
unknown = 18;

不能访问unknown类型上的属性，不能作为函数、类来使用

• 联合类型中的unknown

type UnionUnknown = unknown | null | string | number

联合类型与unknown都是unknown类型

• 交叉类型中的unknown

type inter = unknown & null

交叉类型与unknown都是其他类型

unknown 特性

• never 是 unknown 的子类型

type isNever = never extends unknown ? true : false;

• keyof unknown 是 never

type key = keyof unknown;

• unknown 类型不能被遍历

type IMap<T> = {
    [P in keyof T]:number
}
type t = IMap<unknown>;

unknown类型不能和number类型进行 +运算,可以用于等或不等操作