Pick
Pick<T, K>用于从类型 T 中选取一组属性 K，创建一个新的类型。
1
2
3
4
5
6
7
8
9
10
11
12
| interface Person {
name: string
age: number
address: string
}
type PersonNameAndAge = Pick<Person, "name" | "age">
const personData: PersonNameAndAge = {
name: "Alice",
age: 30,
}
|
Omit
Omit<T, K>用于从类型 T 中排除一组属性 K，创建一个新的类型。
1
2
3
4
5
6
7
8
9
10
11
12
| interface Person {
name: string
age: number
address: string
}
type PersonWithoutAddress = Omit<Person, "address">
const personData: PersonWithoutAddress = {
name: "Bob",
age: 25,
}
|
Partial
Partial 将类型 T 的所有属性变为可选的。
1
2
3
4
5
6
7
8
9
10
11
| interface Person {
name: string
age: number
address: string
}
type PartialPerson = Partial<Person>
const partialPersonData: PartialPerson = {
name: "Alice",
}
|
Required
Required 将类型 T 的所有属性变为必填的。
1
2
3
4
5
6
7
8
9
10
11
12
13
| interface Person {
name?: string
age?: number
address?: string
}
type RequiredPerson = Required<Person>
const requiredPersonData: RequiredPerson = {
name: "Bob",
age: 30,
address: "Somewhere",
}
|
Readonly
Readonly 将类型 T 的所有属性变为只读的。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| interface Person {
name: string
age: number
}
type ReadonlyPerson = Readonly<Person>
const readonlyPersonData: ReadonlyPerson = {
name: "Charlie",
age: 25,
}
readonlyPersonData.name = "David"
|
Record
Record<K, T> 创建一个对象类型，其属性键为 K 类型，属性值为 T 类型。
1
2
3
4
5
6
7
8
9
10
| type KeyType = "key1" | "key2" | "key3"
type ValueType = string
type MyRecord = Record<KeyType, ValueType>
const recordData: MyRecord = {
key1: "value1",
key2: "value2",
key3: "value3",
}
|
Exclude
Exclude<T, U> 从类型 T 中排除可以赋值给类型 U 的类型。
1
2
3
4
| type Primitive = string | number | boolean
type NonNumber = Exclude<Primitive, number>
const nonNumberData: NonNumber = "stringValue" as NonNumber
|
Extract<T, U> 从类型 T 中提取可以赋值给类型 U 的类型。
1
2
3
4
5
| type Primitive = string | number | boolean
type Numeric = number | bigint
type NumericPrimitive = Extract<Primitive, Numeric>
const numericPrimitiveData: NumericPrimitive = 10 as NumericPrimitive
|
ReturnType
ReturnType用于获取函数类型 T 的返回值类型。
1
2
3
4
5
6
7
| function add(a: number, b: number): number {
return a + b
}
type AddReturnType = ReturnType<typeof add>
const result: AddReturnType = 5
|