小总结

HYI 4/27/2023 总结

# 基本类型

string、number、boolean、bigint、symbol、null、undefined、any、unknown、void、never

# enum 枚举

枚举类型定义取值被限定在一定范围内的场景

enum Days {Sun, Mon, Tue, Wed, Thu, Fri, Sat = '哈哈哈'};

枚举成员会被赋值从0开始递增的数字，同时也会对枚举值到枚举名进行反射

enum Days {Sun, Mon, Tue, Wed, Thu, Fri, Sat};

console.log(Days["Sun"] === 0); // true
console.log(Days["Mon"] === 1); // true
console.log(Days["Tue"] === 2); // true
console.log(Days["Sat"] === '哈哈哈'); // true

console.log(Days[0] === "Sun"); // true
console.log(Days[1] === "Mon"); // true
console.log(Days[2] === "Tue"); // true
console.log(Days['哈哈哈'] === "Sat"); // true

1
2
3
4
5
6
7
8
9
10
11

# interface 接口

可以用来约束一个函数，对象，以及类的结构和类型

interface Data {
    id:number;
    name:string;
}

let data:Data = {
    id: 1,
    name: '你好'
}


interface UpDateData {
    (name:string):Data
}
let add:UpDateData = (name)=> { 
    return {...data,name}
 }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# type

类型别名，为类型创建一个新名称。它并不是一个类型，只是一个别名。待补充

# 知识点

any: 不会对其进行类型推断和类型校验 unknown: 会有一定的类型校验区别： 1. 任意类型都能赋值给 any，any 可以赋值给任意类型；任意类型都能赋值给 unknown，unknown 只能赋值给 unknown/any 类型；

let type1: any
type1 = 1
let type2: number = type1
let type3: unknown
type3 = 1
let type4:number = type3 // type4报错：不能将 unknown 分配给 number

1
2
3
4
5
6

unknown 在不进行类型推断的时候，无法直接使用；any 则没有这个限制

let str1: unknown = 'string';
(str1 as string).slice(0,1) // 使用断言 不报错
str1.slice(0,1) // str1报错：类型 unknown 上不存在属性 slice

let str2: any ='string';
str2.slice(0，1)

1
2
3
4
5
6

# 高级类型

# 交叉类型(&)

interface Ant {
    name: string;
    weight: number;
}

interface Fly {
    flyHeight: number;
    speed: number;
}

const flyAnt: Ant & Fly = {
    name: '蚂蚁呀嘿',
    weight: 0.2,
    flyHeight: 20,
    speed: 1,
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 联合类型(|)

let stringOrNumber：string | number = 0

stringOrNumber = ''

1
2
3

# 关键字

# 类型约束(extends)

这里的 extends 不是类、接口的继承，而是对于类型的判断和约束

function reflectSpecified<P extends number | string | boolean>(param: P):P {

  return param;

}

reflectSpecified('string'); // ok

reflectSpecified(1); // ok

reflectSpecified(true); // ok

reflectSpecified(null); // ts(2345) 'null' 不能赋予类型 'number | string | boolean'

1
2
3
4
5
6
7
8
9
10
11
12
13

# 类型映射(in)

会遍历指定接口的 key 或者是遍历联合类型

interface Person {
    name: string
    age: number
    gender: number
}

// 将 T 的所有属性转换为只读类型
type ReadOnlyType<T> = {
    readonly [P in keyof T]: T[P]
}

// type ReadOnlyPerson = {
//     readonly name: Person;
//     readonly age: Person;
//     readonly gender: Person;
// }
type ReadOnlyPerson = ReadOnlyType<Person>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 类型谓词(is)

待补充

# 映射类型

# record

定义键值对类型

const obj:Record<string,number> = { "asd":1 }

# partial

将类型 T 的所有属性变为可选

const obj:Partial<{a: number, b: string}> = {}

# required

将类型 T 的所有属性变为必需

const obj:Required<{a: number, b: string}> = {a:1,b:'哈哈哈'}

# pick

从类型 T 中选取指定属性 K，创建一个新类型

const obj:Pick<{a: number, b: string, c: boolean}, "a"> = { a:1 }

# omit

从类型 T 中删除指定属性 K，创建一个新类型

const obj:Pick<{a: number, b: string, c: boolean}, "a"> = { b:'123',c:true }

# exclude

从类型 T 中排除可以赋值给类型 U 的所有值，创建一个新类型

const obj:Exclude<number | string,string> = 1

# extract

从类型 T 中提取可以赋值给类型 U 的所有值，创建一个新类型

const obj:Extract<number | string,number> = '2'

# readonly

将类型 T 的所有属性变为只读

# readonlyArray

将类型数组 T 的变为只读。

# nonNullable

从类型 T 中删除 null 和 undefined 类型，创建一个新类型

HYI Blog

Choose mode

小总结

小总结