【TS】TypeScript内置条件类型-ReturnType

ReturnType

在TypeScript中,ReturnType 是一个内置的条件类型(Conditional Type),它用于获取一个函数返回值的类型。这个工具类型非常有用,特别是当你需要引用某个函数的返回类型,但又不想直接写出那个具体的类型时。

ReturnType 的基本语法如下:

type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

例如,如果你有一个函数createApp,它是Vue 3中用于创建Vue应用实例的函数,你可以这样使用ReturnType来获取它的返回类型:

import { createApp } from 'vue';  
  
// 假设App是一个Vue组件  
import App from './App.vue';  
  
// 使用ReturnType获取createApp的返回类型  
type VueApp = ReturnType<typeof createApp>;  
  
const app: VueApp = createApp(App);  
  
// 现在app的类型是VueApp,它实际上是createApp函数的返回类型  
// 在Vue 3中,这通常是一个具有mount、component、directive等方法的对象  
  
// 如果你有一个函数需要接受这样的Vue应用实例作为参数  
function useApp(appInstance: VueApp) {  
  // ...  
}  
  
// 你可以安全地将app传递给这个函数  
useApp(app);

注意,ReturnType 只能用于函数类型。如果你尝试将它用于非函数类型,TypeScript会报错。createApp是Vue库的一部分,并且Vue库是用TypeScript编写的,所以ReturnType能够准确地推断出Vue应用实例的类型。

了解释这个类型定义,我们可以将其分解为几个部分:

  • 泛型约束:T extends (…args: any[]) => any
    这部分定义了一个泛型T,它必须是一个函数类型。这个函数类型可以接受任意数量和类型的参数(由(…args: any[])表示),并返回任意类型的值(由=> any表示)。这是ReturnType能够工作的前提,即它只能用于函数类型。

  • 条件类型:T extends (…args: any[]) => infer R ? R : any
    条件类型允许TypeScript根据某个条件来解析类型。在这个例子中,条件是T(一个函数类型)是否可以被视为一个具有特定签名(即接受任意参数并返回某个值的函数)的类型。如果T满足这个条件(实际上,由于泛型约束,它总是满足的),那么TypeScript将使用infer关键字来推断出函数的返回类型,并将其赋值给R。然后,条件类型的“真”分支(即?后面的部分)就是R,即函数的返回类型。

如果T不满足条件(但实际上由于泛型约束,这种情况不会发生),则条件类型的“假”分支(即:后面的部分)将被使用,这里是any。但在ReturnType的定义中,由于有泛型约束,所以“假”分支实际上永远不会被执行。

  • 类型别名:type ReturnType<…> = …
    最后,整个表达式被定义为一个类型别名ReturnType,它接受一个泛型参数T,并返回该函数的返回类型。

在TypeScript中,infer R表示在条件类型(conditional types)中引入的一个待推断的类型变量。这个变量R用于在条件类型的真实分支中引用,以推断出待推断的类型。infer是TypeScript 2.8及以后版本中引入的一个关键字,它允许在条件类型中进行类型推导,从而实现更灵活和可复用的类型定义。

具体来说,当在extends子句中使用infer时,infer R(其中R可以是任意标识符)用于从满足某个条件的类型中推断出具体的类型。

TypeScript 内置的数据类型主要包括以下几类:基本类型、复合类型和高级类型。 ### 基本类型 1. **boolean**:表示布尔值,可以是 `true` 或 `false`。 ```typescript let isDone: boolean = false; ``` 2. **number**:表示数字类型,包括整数和浮点数。 ```typescript let age: number = 25; ``` 3. **string**:表示字符串类型,可以使用单引号或双引号。 ```typescript let name: string = "Alice"; ``` 4. **null**:表示空值。 ```typescript let value: null = null; ``` 5. **undefined**:表示未定义值。 ```typescript let u: undefined = undefined; ``` 6. **symbol**:表示唯一的、不可变的值,通常用于对象属性的键。 ```typescript let sym: symbol = Symbol("key"); ``` ### 复合类型 1. **Array**:表示数组类型,可以存储多个相同类型的元素。 ```typescript let numbers: number[] = [1, 2, 3]; ``` 2. **Tuple**:表示一个已知元素数量和类型的数组。 ```typescript let person: [string, number] = ["Alice", 25]; ``` 3. **Object**:表示对象类型,可以存储多个键值对。 ```typescript let user: object = { name: "Alice", age: 25 }; ``` 4. **Function**:表示函数类型,可以作为参数或返回值传递。 ```typescript let greet: Function = function(name: string): string { return "Hello, " + name; }; ``` ### 高级类型 1. **Enum**:枚举类型,表示一组命名的常量值。 ```typescript enum Color { Red, Green, Blue } let c: Color = Color.Green; ``` 2. **Any**:表示任意类型,可以为任何值。在不确定变量类型的情况下使用。 ```typescript let data: any; data = "Hello"; // 字符串 data = 123; // 数字 data = true; // 布尔值 ``` 3. **Void**:表示没有返回值的函数的返回类型。 ```typescript function logMessage(): void { console.log("This is a message"); } ``` 4. **Never**:表示不存在的值的类型,通常用于永远不会返回的函数。 ```typescript function throwError(message: string): never { throw new Error(message); } ``` 5. **Unknown**:类似于 `any`,但更安全。在使用前必须进行类型检查。 ```typescript let value: unknown; value = "Hello"; if (typeof value === "string") { console.log(value.toUpperCase()); } ``` 6. **Union**:联合类型,表示一个值可以是几种类型之一。 ```typescript let result: string | number; result = "Success"; // 字符串 result = 200; // 数字 ``` 7. **Intersection**:交叉类型,表示多个类型的组合。 ```typescript interface A { a: number; } interface B { b: string; } let obj: A & B = { a: 1, b: "Hello" }; ``` 8. **Literal**:字面量类型,表示特定的值。 ```typescript let direction: "left" | "right" | "up" | "down"; direction = "left"; ``` 9. **Mapped Types**:映射类型,基于现有类型创建新类型。 ```typescript type Readonly<T> = { readonly [P in keyof T]: T[P]; }; interface Person { name: string; age: number; } type ReadonlyPerson = Readonly<Person>; ``` 10. **Conditional Types**:条件类型,根据条件选择不同的类型。 ```typescript type TypeName<T> = T extends string ? "string" : "other"; let nameType: TypeName<string> = "string"; ``` 11. **Template Literal Types**:模板字面量类型,基于字符串字面量创建新类型。 ```typescript type Greeting = `Hello, ${string}`; let message: Greeting = "Hello, Alice"; ``` 12. **Index Types**:索引类型,表示对象的键或值的类型。 ```typescript type Keys = keyof { name: string; age: number }; let key: Keys = "name"; ``` 13. **Indexed Access Types**:索引访问类型,表示通过索引获取的值的类型。 ```typescript type Name = { name: string; age: number }["name"]; let personName: Name = "Alice"; ``` 14. **Keyof Types**:表示对象类型的键的集合。 ```typescript type PersonKeys = keyof { name: string; age: number }; let key: PersonKeys = "name"; ``` 15. **Infer Types**:推断类型,用于在条件类型中推断出具体的类型。 ```typescript type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any; function getPerson() { return { name: "Alice", age: 25 }; } type Person = ReturnType<typeof getPerson>; ``` 16. **This Types**:表示函数内部的 `this` 的类型。 ```typescript class MyClass { doSomething(this: void) { // this 不能访问类的属性 } } ``` 17. **Unique Symbol Types**:唯一符号类型,表示唯一的符号值。 ```typescript let sym: unique symbol = Symbol("key"); ``` 18. **Utility Types**:实用类型,提供常见的类型转换功能。 ```typescript type Partial<T> = { [P in keyof T]?: T[P]; }; interface Person { name: string; age: number; } type PartialPerson = Partial<Person>; ``` 19. **Mapped Types with Modifiers**:带有修饰符的映射类型,可以添加或删除属性的修饰符。 ```typescript type RemoveReadonly<T> = { -readonly [P in keyof T]-?: T[P]; }; interface ReadonlyPerson { readonly name: string; readonly age: number; } type MutablePerson = RemoveReadonly<ReadonlyPerson>; ``` 20. **Key Remapping via `as`**:通过 `as` 关键字重新映射键。 ```typescript type Getters<T> = { [P in keyof T as `get${Capitalize<string & P>}`]: () => T[P]; }; interface Person { name: string; age: number; } type PersonGetters = Getters<Person>; ``` 21. **Variadic Tuple Types**:可变元组类型,表示可以接受任意数量的元素的元组。 ```typescript type Concat<T extends any[], U extends any[]> = [...T, ...U]; type Result = Concat<[1, 2], [3, 4]>; ``` 22. **Recursive Conditional Types**:递归条件类型,用于处理复杂的类型逻辑。 ```typescript type DeepReadonly<T> = T extends (...args: any[]) => any ? T : T extends object ? { readonly [P in keyof T]: DeepReadonly<T[P]> } : T; interface Person { name: string; age: number; } type ReadonlyPerson = DeepReadonly<Person>; ``` 23. **Type Guards**:类型守卫,用于在运行时检查类型。 ```typescript function isString(value: any): value is string { return typeof value === "string"; } let data: any = "Hello"; if (isString(data)) { console.log(data.toUpperCase()); } ``` 24. **Discriminated Unions**:可辨识联合类型,通过一个公共的字面量属性来区分不同的类型。 ```typescript interface Square { kind: "square"; size: number; } interface Rectangle { kind: "rectangle"; width: number; height: number; } type Shape = Square | Rectangle; function getArea(shape: Shape): number { switch (shape.kind) { case "square": return shape.size * shape.size; case "rectangle": return shape.width * shape.height; } } ``` 25. **Exhaustiveness Checking**:穷举检查,确保所有可能的类型都被处理。 ```typescript function assertNever(x: never): never { throw new Error("Unexpected object: " + x); } interface Square { kind: "square"; size: number; } interface Rectangle { kind: "rectangle"; width: number; height: number; } type Shape = Square | Rectangle; function getArea(shape: Shape): number { switch (shape.kind) { case "square": return shape.size * shape.size; case "rectangle": return shape.width * shape.height; default: return assertNever(shape); } } ``` 26. **Type Inference**:类型推断,TypeScript 自动推断变量的类型。 ```typescript let age = 25; // 推断为 number 类型 ``` 27. **Contextual Typing**:上下文类型,根据上下文推断函数参数的类型。 ```typescript window.onmousedown = function(event) { console.log(event.button); // 推断 event 类型为 MouseEvent }; ``` 28. **Type Aliases**:类型别名,为现有类型创建一个新的名称。 ```typescript type ID = string | number; let userId: ID = "123"; ``` 29. **Interfaces vs Type Aliases**:接口与类型别名的区别,接口用于定义对象的形状,而类型别名可以用于定义任何类型的别名。 ```typescript interface Person { name: string; age: number; } type PersonAlias = { name: string; age: number; }; ``` 30. **Intersection Types**:交叉类型,表示多个类型的组合。 ```typescript interface A { a: number; } interface B { b: string; } let obj: A & B = { a: 1, b: "Hello" }; ``` 31. **Union Types**:联合类型,表示一个值可以是几种类型之一。 ```typescript let result: string | number; result = "Success"; // 字符串 result = 200; // 数字 ``` 32. **Literal Types**:字面量类型,表示特定的值。 ```typescript let direction: "left" | "right" | "up" | "down"; direction = "left"; ``` 33. **Mapped Types**:映射类型,基于现有类型创建新类型。 ```typescript type Readonly<T> = { readonly [P in keyof T]: T[P]; }; interface Person { name: string; age: number; } type ReadonlyPerson = Readonly<Person>; ``` 34. **Conditional Types**:条件类型,根据条件选择不同的类型。 ```typescript type TypeName<T> = T extends string ? "string" : "other"; let nameType: TypeName<string> = "string"; ``` 35. **Template Literal Types**:模板字面量类型,基于字符串字面量创建新类型。 ```typescript type Greeting = `Hello, ${string}`; let message: Greeting = "Hello, Alice"; ``` 36. **Index Types**:索引类型,表示对象的键或值的类型。 ```typescript type Keys = keyof { name: string; age: number }; let key: Keys = "name"; ``` 37. **Indexed Access Types**:索引访问类型,表示通过索引获取的值的类型。 ```typescript type Name = { name: string; age: number }["name"]; let personName: Name = "Alice"; ``` 38. **Keyof Types**:表示对象类型的键的集合。 ```typescript type PersonKeys = keyof { name: string; age: number }; let key: PersonKeys = "name"; ``` 39. **Infer Types**:推断类型,用于在条件类型中推断出具体的类型。 ```typescript type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any; function getPerson() { return { name: "Alice", age: 25 }; } type Person = ReturnType<typeof getPerson>; ``` 40. **This Types**:表示函数内部的 `this` 的类型。 ```typescript class MyClass { doSomething(this: void) { // this 不能访问类的属性 } } ``` 41. **Unique Symbol Types**:唯一符号类型,表示唯一的符号值。 ```typescript let sym: unique symbol = Symbol("key"); ``` 42. **Utility Types**:实用类型,提供常见的类型转换功能。 ```typescript type Partial<T> = { [P in keyof T]?: T[P]; }; interface Person { name: string; age: number; } type PartialPerson = Partial<Person>; ``` 43. **Mapped Types with Modifiers**:带有修饰符的映射类型,可以添加或删除属性的修饰符。 ```typescript type RemoveReadonly<T> = { -readonly [P in keyof T]-?: T[P]; }; interface ReadonlyPerson { readonly name: string; readonly age: number; } type MutablePerson = RemoveReadonly<ReadonlyPerson>; ``` 44. **Key Remapping via `as`**:通过 `as` 关键字重新映射键。 ```typescript type Getters<T> = { [P in keyof T as `get${Capitalize<string & P>}`]: () => T[P]; }; interface Person { name: string; age: number; } type PersonGetters = Getters<Person>; ``` 45. **Variadic Tuple Types**:可变元组类型,表示可以接受任意数量的元素的元组。 ```typescript type Concat<T extends any[], U extends any[]> = [...T, ...U]; type Result = Concat<[1, 2], [3, 4]>; ``` 46. **Recursive Conditional Types**:递归条件类型,用于处理复杂的类型逻辑。 ```typescript type DeepReadonly<T> = T extends (...args: any[]) => any ? T : T extends object ? { readonly [P in keyof T]: DeepReadonly<T[P]> } : T; interface Person { name: string; age: number; } type ReadonlyPerson = DeepReadonly<Person>; ``` 47. **Type Guards**:类型守卫,用于在运行时检查类型。 ```typescript function isString(value: any): value is string { return typeof value === "string"; } let data: any = "Hello"; if (isString(data)) { console.log(data.toUpperCase()); } ``` 48. **Discriminated Unions**:可辨识联合类型,通过一个公共的字面量属性来区分不同的类型。 ```typescript interface Square { kind: "square"; size: number; } interface Rectangle { kind: "rectangle"; width: number; height: number; } type Shape = Square | Rectangle; function getArea(shape: Shape): number { switch (shape.kind) { case "square": return shape.size * shape.size; case "rectangle": return shape.width * shape.height; } } ``` 49. **Exhaustiveness Checking**:穷举检查,确保所有可能的类型都被处理。 ```typescript function assertNever(x: never): never { throw new Error("Unexpected object: " + x); } interface Square { kind: "square"; size: number; } interface Rectangle { kind: "rectangle"; width: number; height: number; } type Shape = Square | Rectangle; function getArea(shape: Shape): number { switch (shape.kind) { case "square": return shape.size * shape.size; case "rectangle": return shape.width * shape.height; default: return assertNever(shape); } } ``` 50. **Type Inference**:类型推断,TypeScript 自动推断变量的类型。 ```typescript let age = 25; // 推断为 number 类型 ``` 51. **Contextual Typing**:上下文类型,根据上下文推断函数参数的类型。 ```typescript window.onmousedown = function(event) { console.log(event.button); // 推断 event 类型为 MouseEvent }; ``` 52. **Type Aliases**:类型别名,为现有类型创建一个新的名称。 ```typescript type ID = string | number; let userId: ID = "123"; ``` 53. **Interfaces vs Type Aliases**:接口与类型别名的区别,接口用于定义对象的形状,而类型别名可以用于定义任何类型的别名。 ```typescript interface Person { name: string; age: number; } type PersonAlias = { name: string; age: number; }; ``` 54. **Intersection Types**:交叉类型,表示多个类型的组合。 ```typescript interface A { a: number; } interface B { b: string; } let obj: A & B = { a: 1, b: "Hello" }; ``` 55. **Union Types**:联合类型,表示一个值可以是几种类型之一。 ```typescript let result: string | number; result = "Success"; // 字符串 result = 200; // 数字 ``` 56. **Literal Types**:字面量类型,表示特定的值。 ```typescript let direction: "left" | "right" | "up" | "down"; direction = "left"; ``` 57. **Mapped Types**:映射类型,基于现有类型创建新类型。 ```typescript type Readonly<T> = { readonly [P in keyof T]: T[P]; }; interface Person { name: string; age: number; } type ReadonlyPerson = Readonly<Person>; ``` 58. **Conditional Types**:条件类型,根据条件选择不同的类型。 ```typescript type TypeName<T> = T extends string ? "string" : "other"; let nameType: TypeName<string> = "string"; ``` 59. **Template Literal Types**:模板字面量类型,基于字符串字面量创建新类型。 ```typescript type Greeting = `Hello, ${string}`; let message: Greeting = "Hello, Alice"; ``` 60. **Index Types**:索引类型,表示对象的键或值的类型。 ```typescript type Keys = keyof { name: string; age: number }; let key: Keys = "name"; ``` 61. **Indexed Access Types**:索引访问类型,表示通过索引获取的值的类型。 ```typescript type Name = { name: string; age: number }["name"]; let personName: Name = "Alice"; ``` 62. **Keyof Types**:表示对象类型的键的集合。 ```typescript type PersonKeys = keyof { name: string; age: number }; let key: PersonKeys = "name"; ``` 63. **Infer Types**:推断类型,用于在条件类型中推断出具体的类型。 ```typescript type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any; function getPerson() { return { name: "Alice", age: 25 }; } type Person = ReturnType<typeof getPerson>; ``` 64. **This Types**:表示函数内部的 `this` 的类型。 ```typescript class MyClass { doSomething(this: void) { // this 不能访问类的属性 } } ``` 65. **Unique Symbol Types**:唯一符号类型,表示唯一的符号值。 ```typescript let sym: unique symbol = Symbol("key"); ``` 66. **Utility Types**:实用类型,提供常见的类型转换功能。 ```typescript type Partial<T> = { [P in keyof T]?: T[P]; }; interface Person { name: string; age: number; } type PartialPerson = Partial<Person>; ``` 67. **Mapped Types with Modifiers**:带有修饰符的映射类型,可以添加或删除属性的修饰符。 ```typescript type RemoveReadonly<T> = { -readonly [P in keyof T]-?: T[P]; }; interface ReadonlyPerson { readonly name: string; readonly age: number; } type MutablePerson = RemoveReadonly<ReadonlyPerson>; ``` 68. **Key Remapping via `as`**:通过 `as` 关键字重新映射键。 ```typescript type Getters<T> = { [P in keyof T as `get${Capitalize<string & P>}`]: () => T[P]; }; interface Person { name: string; age: number; } type PersonGetters = Getters<Person>; ``` 69. **Variadic Tuple Types**:可变元组类型,表示可以接受任意数量的元素的元组。 ```typescript type Concat<T extends any[], U extends any[]> = [...T, ...U]; type Result = Concat<[1, 2], [3, 4]>; ``` 70. **Recursive Conditional Types**:递归条件类型,用于处理复杂的类型逻辑。 ```typescript type DeepReadonly<T> = T extends (...args: any[]) => any ? T : T extends object ? { readonly [P in keyof T]: DeepReadonly<T[P]> } : T; interface Person { name: string; age: number; } type ReadonlyPerson = DeepReadonly<Person>; ``` 71. **Type Guards**:类型守卫,用于在运行时检查类型。 ```typescript function isString(value: any): value is string { return typeof value === "string"; } let data: any = "Hello"; if (isString(data)) { console.log(data.toUpperCase()); } ``` 72. **Discriminated Unions**:可辨识联合类型,通过一个公共的字面量属性来区分不同的类型。 ```typescript interface Square { kind: "square"; size: number; } interface Rectangle { kind: "rectangle"; width: number; height: number; } type Shape = Square | Rectangle; function getArea(shape: Shape): number { switch (shape.kind) { case "square": return shape.size * shape.size; case "rectangle": return shape.width * shape.height; } } ``` 73. **Exhaustiveness Checking**:穷举检查,确保所有可能的类型都被处理。 ```typescript function assertNever(x: never): never { throw new Error("Unexpected object: " + x); } interface Square { kind: "square"; size: number; } interface Rectangle { kind: "rectangle"; width: number; height: number; } type Shape = Square | Rectangle; function getArea(shape: Shape): number { switch (shape.kind) { case "square": return shape.size * shape.size; case "rectangle": return shape.width * shape.height; default: return assertNever(shape); } } ``` 74. **Type Inference**:类型推断,TypeScript 自动推断变量的类型。 ```typescript let age = 25; // 推断为 number 类型 ``` 75. **Contextual Typing**:上下文类型,根据上下文推断函数参数的类型。 ```typescript window.onmousedown = function(event) { console.log(event.button); // 推断 event 类型为 MouseEvent }; ``` 76. **Type Aliases**:类型别名,为现有类型创建一个新的名称。 ```typescript type ID = string | number; let userId: ID = "123"; ``` 77. **Interfaces vs Type Aliases**:接口与类型别名的区别,接口用于定义对象的形状,而类型别名可以用于定义任何类型的别名。 ```typescript interface Person { name: string; age: number; } type PersonAlias = { name: string; age: number; }; ``` 78. **Intersection Types**:交叉类型,表示多个类型的组合。 ```typescript interface A { a: number; } interface B { b: string; } let obj: A & B = { a: 1, b: "Hello" }; ``` 79. **Union Types**:联合类型,表示一个值可以是几种类型之一。 ```typescript let result: string | number; result = "Success"; // 字符串 result = 200; // 数字 ``` 80. **Literal Types**:字面量类型,表示特定的值。 ```typescript let direction: "left" | "right" | "up" | "down"; direction = "left"; ``` 81. **Mapped Types**:映射类型,基于现有类型创建新类型。 ```typescript type Readonly<T> = { readonly [P in keyof T]: T[P]; }; interface Person { name: string; age: number; } type ReadonlyPerson = Readonly<Person>; ``` 82. **Conditional Types**:条件类型,根据条件选择不同的类型。 ```typescript type TypeName<T> = T extends string ? "string" : "other"; let nameType: TypeName<string> = "string"; ``` 83. **Template Literal Types**:模板字面量类型,基于字符串字面量创建新类型。 ```typescript type Greeting = `Hello, ${string}`; let message: Greeting = "Hello, Alice"; ``` 84. **Index Types**:索引类型,表示对象的键或值的类型。 ```typescript type Keys = keyof { name: string; age: number }; let key: Keys = "name"; ``` 85. **Indexed Access Types**:索引访问类型,表示通过索引获取的值的类型。 ```typescript type Name = { name: string; age: number }["name"]; let personName: Name = "Alice"; ``` 86. **Keyof Types**:表示对象类型的键的集合。 ```typescript type PersonKeys = keyof { name: string; age: number }; let key: PersonKeys = "name"; ``` 87. **Infer Types**:推断类型,用于在条件类型中推断出具体的类型。 ```typescript type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any; function getPerson() { return { name: "Alice", age: 25 }; } type Person = ReturnType<typeof getPerson>; ``` 88. **This Types**:表示函数内部的 `this` 的类型。 ```typescript class MyClass { doSomething(this: void) { // this 不能访问类的属性 } } ``` 89. **Unique Symbol Types**:唯一符号类型,表示唯一的符号值。 ```typescript let sym: unique symbol = Symbol("key"); ``` 90. **Utility Types**:实用类型,提供常见的类型转换功能。 ```typescript type Partial<T> = { [P in keyof T]?: T[P]; }; interface Person { name: string; age: number; } type PartialPerson = Partial<Person>; ``` 91. **Mapped Types with Modifiers**:带有修饰符的映射类型,可以添加或删除属性的修饰符。 ```typescript type RemoveReadonly<T> = { -readonly [P in keyof T]-?: T[P]; }; interface ReadonlyPerson { readonly name: string; readonly age: number; } type MutablePerson = RemoveReadonly<ReadonlyPerson>; ``` 92. **Key Remapping via `as`**:通过 `as` 关键字重新映射键。 ```typescript type Getters<T> = { [P in keyof T as `get${Capitalize<string & P>}`]: () => T[P]; }; interface Person { name: string; age: number; } type PersonGetters = Getters<Person>; ``` 93. **Variadic Tuple Types**:可变元组类型,表示可以接受任意数量的元素的元组。 ```typescript type Concat<T extends any[], U extends any[]> = [...T, ...U]; type Result = Concat<[1, 2], [3, 4]>; ``` 94. **Recursive Conditional Types**:递归条件类型,用于处理复杂的类型逻辑。 ```typescript type DeepReadonly<T> = T extends (...args: any[]) => any ? T : T extends object ? { readonly [P in keyof T]: DeepReadonly<T[P]> } : T; interface Person { name: string; age: number; } type ReadonlyPerson = DeepReadonly<Person>; ``` 95. **Type Guards**:类型守卫,用于在运行时检查类型。 ```typescript function isString(value: any): value is string { return typeof value === "string"; } let data: any = "Hello"; if (isString(data)) { console.log(data.toUpperCase()); } ``` 96. **Discriminated Unions**:可辨识联合类型,通过一个公共的字面量属性来区分不同的类型。 ```typescript interface Square { kind: "square"; size: number; } interface Rectangle { kind: "rectangle"; width: number; height: number; } type Shape = Square | Rectangle; function getArea(shape: Shape): number { switch (shape.kind) { case "square": return shape.size * shape.size; case "rectangle": return shape.width * shape.height; } } ``` 97. **Exhaustiveness Checking**:穷举检查,确保所有可能的类型都被处理。 ```typescript function assertNever(x: never): never { throw new Error("Unexpected object: " + x); } interface Square { kind: "square"; size: number; } interface Rectangle { kind: "rectangle"; width: number; height: number; } type Shape = Square | Rectangle; function getArea(shape: Shape): number { switch (shape.kind) { case "square": return shape.size * shape.size; case "rectangle": return shape.width * shape.height; default: return assertNever(shape); } } ``` 98. **Type Inference**:类型推断,TypeScript 自动推断变量的类型。 ```typescript let age = 25; // 推断为 number 类型 ``` 99. **Contextual Typing**:上下文类型,根据上下文推断函数参数的类型。 ```typescript window.onmousedown = function(event) { console.log(event.button); // 推断 event 类型为 MouseEvent }; ``` 100. **Type Aliases**:类型别名,为现有类型创建一个新的名称。 ```typescript type ID = string | number; let userId: ID = "123"; ``` 101. **Interfaces vs Type Aliases**:接口与类型别名的区别,接口用于定义对象的形状,而类型别名可以用于定义任何类型的别名。 ```typescript interface Person { name: string; age: number; } type PersonAlias = { name: string; age: number; }; ``` 102. **Intersection Types**:交叉类型,表示多个类型的组合。 ```typescript interface A { a: number; } interface B { b: string; } let obj: A & B = { a: 1, b: "Hello" }; ``` 103. **Union Types**:联合类型,表示一个值可以是几种类型之一。 ```typescript let result: string | number; result = "Success"; // 字符串 result = 200; // 数字 ``` 104. **Literal Types**:字面量类型,表示特定的值。 ```typescript let direction: "left" | "right" | "up" | "down"; direction = "left"; ``` 105. **Mapped Types**:映射类型,基于现有类型创建新类型。 ```typescript type Readonly<T> = { readonly [P in keyof T]: T[P]; }; interface Person { name: string; age: number; } type ReadonlyPerson = Readonly<Person>; ``` 106. **Conditional Types**:条件类型,根据条件选择不同的类型。 ```typescript type TypeName<T> = T extends string ? "string" : "other"; let nameType: TypeName<string> = "string"; ``` 107. **Template Literal Types**:模板字面量类型,基于字符串字面量创建新类型。 ```typescript type Greeting = `Hello, ${string}`; let message: Greeting = "Hello, Alice"; ``` 108. **Index Types**:索引类型,表示对象的键或值的类型。 ```typescript type Keys = keyof { name: string; age: number }; let key: Keys = "name"; ``` 109. **Indexed Access Types**:索引访问类型,表示通过索引获取的值的类型。 ```typescript type Name = { name: string; age: number }["name"]; let personName: Name = "Alice"; ``` 110. **Keyof Types**:表示对象类型的键的集合。 ```typescript type PersonKeys = keyof { name: string; age: number }; let key: PersonKeys = "name"; ``` 111. **Infer Types**:推断类型,用于在条件类型中推断出具体的类型。 ```typescript type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any; function getPerson() { return { name: "Alice", age: 25 }; } type Person = ReturnType<typeof getPerson>; ``` 112. **This Types**:表示函数内部的 `this` 的类型。 ```typescript class MyClass { doSomething(this: void) { // this 不能访问类的属性 } } ``` 113. **Unique Symbol Types**:唯一符号类型,表示唯一的符号值。 ```typescript let sym: unique symbol = Symbol("key"); ``` 114. **Utility Types**:实用类型,提供常见的类型转换功能。 ```typescript type Partial<T> = { [P in keyof T]?: T[P]; }; interface Person { name: string; age: number; } type PartialPerson = Partial<Person>; ``` 115. **Mapped Types with Modifiers**:带有修饰符的映射类型,可以添加或删除属性的修饰符。 ```typescript type RemoveReadonly<T> = { -readonly [P in keyof T]-?: T[P]; }; interface ReadonlyPerson { readonly name: string; readonly age: number; } type MutablePerson = RemoveReadonly<ReadonlyPerson>; ``` 116. **Key Remapping via `as`**:通过 `as` 关键字重新映射键。 ```typescript type Getters<T> = { [P in keyof T as `get${Capitalize<string & P>}`]: () => T[P]; }; interface Person { name: string; age: number; } type PersonGetters = Getters<Person>; ``` 117. **Variadic Tuple Types**:可变元组类型,表示可以接受任意数量的元素的元组。 ```typescript type Concat<T extends any[], U extends any[]> = [...T, ...U]; type Result = Concat<[1, 2], [3, 4]>; ``` 118. **Recursive Conditional Types**:递归条件类型,用于处理复杂的类型逻辑。 ```typescript type DeepReadonly<T> = T extends (...args: any[]) => any ? T : T extends object ? { readonly [P in keyof T]: DeepReadonly<T[P]> } : T; interface Person { name: string; age: number; } type ReadonlyPerson = DeepReadonly<Person>; ``` 119. **Type Guards**:类型守卫,用于在运行时检查类型。 ```typescript function isString(value: any): value is string { return typeof value === "string"; } let data: any = "Hello"; if (isString(data)) { console.log(data.toUpperCase()); } ``` 120. **Discriminated Unions**:可辨识联合类型,通过一个公共的字面量属性来区分不同的类型。 ```typescript interface Square { kind: "square"; size: number; } interface Rectangle { kind: "rectangle"; width: number; height: number; } type Shape = Square | Rectangle; function getArea(shape: Shape): number { switch (shape.kind) { case "square": return shape.size * shape.size; case "rectangle": return shape.width * shape.height; } } ``` 121. **Exhaustiveness Checking**:穷举检查,确保所有可能的类型都被处理。 ```typescript function assertNever(x: never): never { throw new Error("Unexpected object: " + x); } interface Square { kind: "square"; size: number; } interface Rectangle { kind: "rectangle"; width: number; height: number; } type Shape = Square | Rectangle; function getArea(shape: Shape): number { switch (shape.kind) { case "square": return shape.size * shape.size; case "rectangle": return shape.width * shape.height; default: return assertNever(shape); } } ``` 122. **Type Inference**:类型推断,TypeScript 自动推断变量的类型。 ```typescript let age = 25; // 推断为 number 类型 ``` 123. **Contextual Typing**:上下文类型,根据上下文推断函数参数的类型。 ```typescript window.onmousedown = function(event) { console.log(event.button); // 推断 event 类型为 MouseEvent }; ``` 124. **Type Aliases**:类型别名,为现有类型创建一个新的名称。 ```typescript type ID = string | number; let userId: ID = "123"; ``` 125. **Interfaces vs Type Aliases**:接口与类型别名的区别,接口用于定义对象的形状,而类型别名可以用于定义任何类型的别名。 ```typescript interface Person { name: string; age: number; } type PersonAlias = { name: string; age: number; }; ``` 126. **Intersection Types**:交叉类型,表示多个类型的组合。 ```typescript interface A { a: number; } interface B { b: string; } let obj: A & B = { a: 1, b: "Hello" }; ``` 127. **Union Types**:联合类型,表示一个值可以是几种类型之一。 ```typescript let result: string | number; result = "Success"; // 字符串 result = 200; // 数字 ``` 128. **Literal Types**:字面量类型,表示特定的值。 ```typescript let direction: "left" | "right" | "up" | "down"; direction = "left"; ``` 129. **Mapped Types**:映射类型,基于现有类型创建新类型。 ```typescript type Readonly<T> = { readonly [P in keyof T]: T[P]; }; interface Person { name: string; age: number; } type ReadonlyPerson = Readonly<Person>; ``` 130. **Conditional Types**:条件类型,根据条件选择不同的类型。 ```typescript type TypeName<T> = T extends string ? "string" : "other"; let nameType: TypeName<string> = "string"; ``` 131. **Template Literal Types**:模板字面量类型,基于字符串字面量创建新类型。 ```typescript type Greeting = `Hello, ${string}`; let message: Greeting = "Hello, Alice"; ``` 132. **Index Types**:索引类型,表示对象的键或值的类型。 ```typescript type Keys = keyof { name: string; age: number }; let key: Keys = "name"; ``` 133. **Indexed Access Types**:索引访问类型,表示通过索引获取的值的类型。 ```typescript type Name = { name: string; age: number }["name"]; let personName: Name = "Alice"; ``` 134. **Keyof Types**:表示对象类型的键的集合。 ```typescript type PersonKeys = keyof { name: string; age: number }; let key: PersonKeys = "name"; ``` 135. **Infer Types**:推断类型,用于在条件类型中推断出具体的类型。 ```typescript type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any; function getPerson() { return { name: "Alice", age: 25 }; } type Person = ReturnType<typeof getPerson>; ``` 136. **This Types**:表示函数内部的 `this` 的类型。 ```typescript class MyClass { doSomething(this: void) { // this 不能访问类的属性 } } ``` 137. **Unique Symbol Types**:唯一符号类型,表示唯一的符号值。 ```typescript let sym: unique symbol = Symbol("key"); ``` 138. **Utility Types**:实用类型,提供常见的类型转换功能。 ```typescript type Partial<T> = { [P in keyof T]?: T[P]; }; interface Person { name: string; age: number; } type PartialPerson = Partial<Person>; ``` 139. **Mapped Types with Modifiers**:带有修饰符的映射类型,可以添加或删除属性的修饰符。 ```typescript type RemoveReadonly<T> = { -readonly [P in keyof T]-?: T[P]; }; interface ReadonlyPerson { readonly name: string; readonly age: number; } type MutablePerson = RemoveReadonly<ReadonlyPerson>; ``` 140. **Key Remapping via `as`**:通过 `as` 关键字重新映射键。 ```typescript type Getters<T> = { [P in keyof T as `get${Capitalize<string & P>}`]: () => T[P]; }; interface Person { name: string; age: number; } type PersonGetters = Getters<Person>; ``` 141. **Variadic Tuple Types**:可变元组类型,表示可以接受任意数量的元素的元组。 ```typescript type Concat<T extends any[], U extends any[]> = [...T, ...U]; type Result = Concat<[1, 2], [3, 4]>; ``` 142. **Recursive Conditional Types**:递归条件类型,用于处理复杂的类型逻辑。 ```typescript type DeepReadonly<T> = T extends (...args: any[]) => any ? T : T extends object ? { readonly [P in keyof T]: DeepReadonly<T[P]> } : T; interface Person { name: string; age: number; } type ReadonlyPerson = DeepReadonly<Person>; ``` 143. **Type Guards**:类型守卫,用于在运行时检查类型。 ```typescript function isString(value: any): value is string { return typeof value === "string"; } let data: any = "Hello"; if (isString(data)) { console.log(data.toUpperCase()); } ``` 144. **Discriminated Unions**:可辨识联合类型,通过一个公共的字面量属性来区分不同的类型。 ```typescript interface Square { kind: "square"; size: number; } interface Rectangle { kind: "rectangle"; width: number; height: number; } type Shape = Square | Rectangle; function getArea(shape: Shape): number { switch (shape.kind) { case "square": return shape.size * shape.size; case "rectangle": return shape.width * shape.height; } } ``` 145. **Exhaustiveness Checking**:穷举检查,确保所有可能的类型都被处理。 ```typescript function assertNever(x: never): never { throw new Error("Unexpected object: " + x); } interface Square { kind: "square"; size: number; } interface Rectangle { kind: "rectangle"; width: number; height: number; } type Shape = Square | Rectangle; function getArea(shape: Shape): number { switch (shape.kind) { case "square": return shape.size * shape.size; case "rectangle": return shape.width * shape.height; default: return assertNever(shape); } } ``` 146. **Type Inference**:类型推断,TypeScript 自动推断变量的类型。 ```typescript let age = 25; // 推断为 number 类型 ``` 147. **Contextual Typing**:上下文类型,根据上下文推断函数参数的类型。 ```typescript window.onmousedown = function(event) { console.log(event.button); // 推断 event 类型为 MouseEvent }; ``` 148. **Type Aliases**:类型别名,为现有类型创建一个新的名称。 ```typescript type ID = string | number; let userId: ID = "123"; ``` 149. **Interfaces vs Type Aliases**:接口与类型别名的区别,接口用于定义对象的形状,而类型别名可以用于定义任何类型的别名。 ```typescript interface Person { name: string; age: number; } type PersonAlias = { name: string; age: number; }; ``` 150. **Intersection Types**:交叉类型,表示多个类型的组合。 ```typescript interface A { a: number; } interface B { b: string; } let obj: A & B = { a: 1, b: "Hello" }; ``` 151. **Union Types**:联合类型,表示一个值可以是几种类型之一。 ```typescript let result: string | number; result = "Success"; // 字符串 result = 200; // 数字 ``` 152. **Literal Types**:字面量类型,表示特定的值。 ```typescript let direction: "left" | "right" | "up" | "down"; direction = "left"; ``` 153. **Mapped Types**:映射类型,基于现有类型创建新类型。 ```typescript type Readonly<T> = { readonly [P in keyof T]: T[P]; }; interface Person { name: string; age: number; } type ReadonlyPerson = Readonly<Person>; ``` 154. **Conditional Types**:条件类型,根据条件选择不同的类型。 ```typescript type TypeName<T> = T extends string ? "string" : "other"; let nameType: TypeName<string> = "string"; ``` 155. **Template Literal Types**:模板字面量类型,基于字符串字面量创建新类型。 ```typescript type Greeting = `Hello, ${string}`; let message: Greeting = "Hello, Alice"; ``` 156. **Index Types**:索引类型,表示对象的键或值的类型。 ```typescript type Keys = keyof { name: string; age: number }; let key: Keys = "name"; ``` 157. **Indexed Access Types**:索引访问类型,表示通过索引获取的值的类型。 ```typescript type Name = { name: string; age: number }["name"]; let personName: Name = "Alice"; ``` 158. **Keyof Types**:表示对象类型的键的集合。 ```typescript type PersonKeys = keyof { name: string; age: number }; let key: PersonKeys = "name"; ``` 159. **Infer Types**:推断类型,用于在条件类型中推断出具体的类型。 ```typescript type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any; function getPerson() { return { name: "Alice", age: 25 }; } type Person = ReturnType<typeof getPerson>; ``` 160. **This Types**:表示函数内部的 `this` 的类型。 ```typescript class MyClass { doSomething(this: void) { // this 不能访问类的属性 } } ``` 161. **Unique Symbol Types**:唯一符号类型,表示唯一的符号值。 ```typescript let sym: unique symbol = Symbol("key"); ``` 162. **Utility Types**:实用类型,提供常见的类型转换功能。 ```typescript type Partial<T> = { [P in keyof T]?: T[P]; }; interface Person { name: string; age: number; } type PartialPerson = Partial<Person>; ``` 163. **Mapped Types with Modifiers**:带有修饰符的映射类型,可以添加或删除属性的修饰符。 ```typescript type RemoveReadonly<T> = { -readonly [P in keyof T]-?: T[P]; }; interface ReadonlyPerson { readonly name: string; readonly age: number; } type MutablePerson = RemoveReadonly<ReadonlyPerson>; ``` 164. **Key Remapping via `as`**:通过 `as` 关键字重新映射键。 ```typescript type Getters<T> = { [P in keyof T as `get${Capitalize<string & P>}`]: () => T[P]; }; interface Person { name: string; age: number; } type PersonGetters = Getters<Person>; ``` 165. **Variadic Tuple Types**:可变元组类型,表示可以接受任意数量的元素的元组。 ```typescript type Concat<T extends any[], U extends any[]> = [...T, ...U]; type Result = Concat<[1, 2], [3, 4]>; ``` 166. **Recursive Conditional Types**:递归条件类型,用于处理复杂的类型逻辑。 ```typescript type DeepReadonly<T> = T extends (...args: any[]) => any ? T : T extends object ? { readonly [P in keyof T]: DeepReadonly<T[P]> } : T; interface Person { name: string; age: number; } type ReadonlyPerson = DeepReadonly<Person>; ``` 167. **Type Guards**:类型守卫,用于在运行时检查类型。 ```typescript function isString(value: any): value is string { return typeof value === "string"; } let data: any = "Hello"; if (isString(data)) { console.log(data.toUpperCase()); } ``` 168. **Discriminated Unions**:可辨识联合类型,通过一个公共的字面量属性来区分不同的类型。 ```typescript interface Square { kind: "square"; size: number; } interface Rectangle { kind: "rectangle"; width: number; height: number; } type Shape = Square | Rectangle; function getArea(shape: Shape): number { switch (shape.kind) { case "square": return shape.size * shape.size; case "rectangle": return shape.width * shape.height; } } ``` 169. **Exhaustiveness Checking**:穷举检查,确保所有可能的类型都被处理。 ```typescript function assertNever(x: never): never { throw new Error("Unexpected object: " + x); } interface Square { kind: "square"; size: number; } interface Rectangle { kind: "rectangle"; width: number; height: number; } type Shape = Square | Rectangle; function getArea(shape: Shape): number { switch (shape.kind) { case "square": return shape.size * shape.size; case "rectangle": return shape.width * shape.height; default: return assertNever(shape); } } ``` 170. **Type Inference**:类型推断,TypeScript 自动推断变量的类型。 ```typescript let age = 25; // 推断为 number 类型 ``` 171. **Contextual Typing**:上下文类型,根据上下文推断函数参数的类型。 ```typescript window.onmousedown = function(event) { console.log(event.button); // 推断 event 类型为 MouseEvent }; ``` 172. **Type Aliases**:类型别名,为现有类型创建一个新的名称。 ```typescript type ID = string | number; let userId: ID = "123"; ``` 173. **Interfaces vs Type Aliases**:接口与类型别名的区别,接口用于定义对象的形状,而类型别名可以用于定义任何类型的别名。 ```typescript interface Person { name: string; age: number; } type PersonAlias = { name: string; age: number; }; ``` 174. **Intersection Types**:交叉类型,表示多个类型的组合。 ```typescript interface A { a: number; } interface B { b: string; } let obj: A & B = { a: 1, b: "Hello" }; ``` 175. **Union Types**:联合类型,表示一个值可以是几种类型之一。 ```typescript let result: string | number; result = "Success"; // 字符串 result = 200; // 数字 ``` 176. **Literal Types**:字面量类型,表示特定的值。 ```typescript let direction: "left" | "right" | "up" | "down"; direction = "left"; ``` 177. **Mapped Types**:映射类型,基于现有类型创建新类型。 ```typescript type Readonly<T> = { readonly [P in keyof T]: T[P]; }; interface Person { name: string; age: number; } type ReadonlyPerson = Readonly<Person>; ``` 178. **Conditional Types**:条件类型,根据条件选择不同的类型。 ```typescript type TypeName<T> = T extends string ? "string" : "other"; let nameType: TypeName<string> = "string"; ``` 179. **Template Literal Types**:模板字面量类型,基于字符串字面量创建新类型。 ```typescript type Greeting = `Hello, ${string}`; let message: Greeting = "Hello, Alice"; ``` 180. **Index Types**:索引类型,表示对象的键或值的类型。 ```typescript type Keys = keyof { name: string; age: number }; let key: Keys = "name"; ``` 181. **Indexed Access Types**:索引访问类型,表示通过索引获取的值的类型。 ```typescript type Name = { name: string; age: number }["name"]; let personName: Name = "Alice"; ``` 182. **Keyof Types**:表示对象类型的键的集合。 ```typescript type PersonKeys = keyof { name: string; age: number }; let key: PersonKeys = "name"; ``` 183. **Infer Types**:推断类型,用于在条件类型中推断出具体的类型。 ```typescript type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any; function getPerson() { return { name: "Alice", age: 25 }; } type Person = ReturnType<typeof getPerson>; ``` 184. **This Types**:表示函数内部的 `this` 的类型。 ```typescript class MyClass { doSomething(this: void) { // this 不能访问类的属性 } } ``` 185. **Unique Symbol Types**:唯一符号类型,表示唯一的符号值。 ```typescript let sym: unique symbol = Symbol("key"); ``` 186. **Utility Types**:实用类型,提供常见的类型转换功能。 ```typescript type Partial<T> = { [P in keyof T]?: T[P]; }; interface Person { name: string; age: number; } type PartialPerson = Partial<Person>; ``` 187. **Mapped Types with Modifiers**:带有修饰符的映射类型,可以添加或删除属性的修饰符。 ```typescript type RemoveReadonly<T> = { -readonly [P in keyof T]-?: T[P]; }; interface ReadonlyPerson { readonly name: string; readonly age: number; } type MutablePerson = RemoveReadonly<ReadonlyPerson>; ``` 188. **Key Remapping via `as`**:通过 `as` 关键字重新映射键。 ```typescript type Getters<T> = { [P in keyof T as `get${Capitalize<string & P>}`]: () => T[P]; }; interface Person { name: string; age: number; } type PersonGetters = Getters<Person>; ``` 189. **Variadic Tuple Types**:可变元组类型,表示可以接受任意数量的元素的元组。 ```typescript type Concat<T extends any[], U extends any[]> = [...T, ...U]; type Result = Concat<[1, 2], [3, 4]>; ``` 190. **Recursive Conditional Types**:递归条件类型,用于处理复杂的类型逻辑。 ```typescript type DeepReadonly<T> = T extends (...args: any[]) => any ? T : T extends object ? { readonly [P in keyof T]: DeepReadonly<T[P]> } : T; interface Person { name: string; age: number; } type ReadonlyPerson = DeepReadonly<Person>; ``` 191. **Type Guards**:类型守卫,用于在运行时检查类型。 ```typescript function isString(value: any): value is string { return typeof value === "string"; } let data: any = "Hello"; if (isString(data)) { console.log(data.toUpperCase()); } ``` 192. **Discriminated Unions**:可辨识联合类型,通过一个公共的字面量属性来区分不同的类型。 ```typescript interface Square { kind: "square"; size: number; } interface Rectangle { kind: "rectangle"; width: number; height: number; } type Shape = Square | Rectangle; function getArea(shape: Shape): number { switch (shape.kind) { case "square": return shape.size * shape.size; case "rectangle": return shape.width * shape.height; } } ``` 193. **Exhaustiveness Checking**:穷举检查,确保所有可能的类型都被处理。 ```typescript function assertNever(x: never): never { throw new Error("Unexpected object: " + x); } interface Square { kind: "square"; size: number; } interface Rectangle { kind: "rectangle"; width: number; height: number; } type Shape = Square | Rectangle; function getArea(shape: Shape): number { switch (shape.kind) { case "square": return shape.size * shape.size; case "rectangle": return shape.width * shape.height; default: return assertNever(shape); } } ``` 194. **Type Inference**:类型推断,TypeScript 自动推断变量的类型。 ```typescript let age = 25; // 推断为 number 类型 ``` 195. **Contextual Typing**:上下文类型,根据上下文推断函数参数的类型。 ```typescript window.onmousedown = function(event) { console.log(event.button); // 推断 event 类型为 MouseEvent }; ``` 196. **Type Aliases**:类型别名,为现有类型创建一个新的名称。 ```typescript type ID = string | number; let userId: ID = "123"; ``` 197. **Interfaces vs Type Aliases**:接口与类型别名的区别,接口用于定义对象的形状,而类型别名可以用于定义任何类型的别名。 ```typescript interface Person { name: string; age: number; } type PersonAlias = { name: string; age: number; }; ``` 198. **Intersection Types**:交叉类型,表示多个类型的组合。 ```typescript interface A { a: number; } interface B { b: string; } let obj: A & B = { a: 1, b: "Hello" }; ``` 199. **Union Types**:联合类型,表示一个值可以是几种类型之一。 ```typescript let result: string | number; result = "Success"; // 字符串 result = 200; // 数字 ``` 200. **Literal Types**:字面量类型,表示特定的值。 ```typescript let direction: "left" | "right" | "up" | "down"; direction = "left"; ``` 201. **Mapped Types**:映射类型,基于现有类型创建新类型。 ```typescript type Readonly<T> = { readonly [P in keyof T]: T[P]; }; interface Person { name: string; age: number; } type ReadonlyPerson = Readonly<Person>; ``` 202. **Conditional Types**:条件类型,根据条件选择不同的类型。 ```typescript type TypeName<T> = T extends string ? "string" : "other"; let nameType: TypeName<string> = "string"; ``` 203. **Template Literal Types**:模板字面量类型,基于字符串字面量创建新类型。 ```typescript type Greeting = `Hello, ${string}`; let message: Greeting = "Hello, Alice"; ``` 204. **Index Types**:索引类型,表示对象的键或值的类型。 ```typescript type Keys = keyof { name: string; age: number }; let key: Keys = "name"; ``` 205. **Indexed Access Types**:索引访问类型,表示通过索引获取的值的类型。 ```typescript type Name = { name: string; age: number }["name"]; let personName: Name = "Alice"; ``` 206. **Keyof Types**:表示对象类型的键的集合。 ```typescript type PersonKeys = keyof { name: string; age: number }; let key: PersonKeys = "name"; ``` 207. **Infer Types**:推断类型,用于在条件类型中推断出具体的类型。 ```typescript type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any; function getPerson() { return { name: "Alice", age: 25 }; } type Person = ReturnType<typeof getPerson>; ``` 208. **This Types**:表示函数内部的 `this` 的类型。 ```typescript class MyClass { doSomething(this: void) { // this 不能访问类的属性 } } ``` 209. **Unique Symbol Types**:唯一符号类型,表示唯一的符号值。 ```typescript let sym: unique symbol = Symbol("key"); ``` 210. **Utility Types**:实用类型,提供常见的类型转换功能。 ```typescript type Partial<T> = { [P in keyof T]?: T[P]; }; interface Person { name: string; age: number; } type PartialPerson = Partial<Person>; ``` 211. **Mapped Types with Modifiers**:带有修饰符的映射类型,可以添加或删除属性的修饰符。 ```typescript type RemoveReadonly<T> = { -readonly [P in keyof T]-?: T[P]; }; interface ReadonlyPerson { readonly name: string; readonly age: number; } type MutablePerson = RemoveReadonly<ReadonlyPerson>; ``` 212. **Key Remapping via `as`**:通过 `as` 关键字重新映射键。 ```typescript type Getters<T> = { [P in keyof T as `get${Capitalize<string & P>}`]: () => T[P]; }; interface Person { name: string; age: number; } type PersonGetters = Getters<Person>; ``` 213. **Variadic Tuple Types**:可变元组类型,表示可以接受任意数量的元素的元组。 ```typescript type Concat<T extends any[], U extends any[]> = [...T, ...U]; type Result = Concat<[1, 2], [3, 4]>; ``` 214. **Recursive Conditional Types**:递归条件类型,用于处理复杂的类型逻辑。 ```typescript type DeepReadonly<T> = T extends (...args: any[]) => any ? T : T extends object ? { readonly [P in keyof T]: DeepReadonly<T[P]> } : T; interface Person { name: string; age: number; } type ReadonlyPerson = DeepReadonly<Person>; ``` 215. **Type Guards**:类型守卫,用于在运行时检查类型。 ```typescript function isString(value: any): value is string { return typeof value === "string"; } let data: any = "Hello"; if (isString(data)) { console.log(data.toUpperCase()); } ``` 216. **Discriminated Unions**:可辨识联合类型,通过一个公共的字面量属性来区分不同的类型。 ```typescript interface Square { kind: "square"; size: number; } interface Rectangle { kind: "rectangle"; width: number; height: number; } type Shape = Square | Rectangle; function getArea(shape: Shape): number { switch (shape.kind) { case "square": return shape.size * shape.size; case "rectangle": return shape.width * shape.height; } } ``` 217. **Exhaustiveness Checking**:穷举检查,确保所有可能的类型都被处理。 ```typescript function assertNever(x: never): never { throw new Error("Unexpected object: " + x); } interface Square { kind: "square"; size: number; } interface Rectangle { kind: "rectangle"; width: number; height: number; } type Shape = Square | Rectangle; function getArea(shape: Shape): number { switch (shape.kind) { case "square": return shape.size * shape.size; case "rectangle": return shape.width * shape.height; default: return assertNever(shape); } } ``` 218. **Type Inference**:类型推断,TypeScript 自动推断变量的类型。 ```typescript let age = 25; // 推断为 number 类型 ``` 219. **Contextual Typing**:上下文类型,根据上下文推断函数参数的类型。 ```typescript window.onmousedown = function(event) { console.log(event.button); // 推断 event 类型为 MouseEvent }; ``` 220. **Type Aliases**:类型别名,为现有类型创建一个新的名称。 ```typescript type ID = string | number; let userId: ID = "123"; ``` 221. **Interfaces vs Type Aliases**:接口与类型别名的区别,接口用于定义对象的形状,而类型别名可以用于定义任何类型的别名。 ```typescript interface Person { name: string; age: number; } type PersonAlias = { name: string; age: number; }; ``` 222. **Intersection Types**:交叉类型,表示多个类型的组合。 ```typescript interface A { a: number; } interface B { b: string; } let obj: A & B = { a: 1, b: "Hello" }; ``` 223. **Union Types**:联合类型,表示一个值可以是几种类型之一。 ```typescript let result: string | number; result = "Success"; // 字符串 result = 200; // 数字 ``` 224. **Literal Types**:字面量类型,表示特定的值。 ```typescript let direction: "left" | "right" | "up" | "down"; direction = "left"; ``` 225. **Mapped Types**:映射类型,基于现有类型创建新类型。 ```typescript type Readonly<T> = { readonly [P in keyof T]: T[P]; }; interface Person { name: string; age: number; } type ReadonlyPerson = Readonly<Person>; ``` 226. **Conditional Types**:条件类型,根据条件选择不同的类型。 ```typescript type TypeName<T> = T extends string ? "string" : "other"; let nameType: TypeName<string> = "string"; ``` 227. **Template Literal Types**:模板字面量类型,基于字符串字面量创建新类型。 ```typescript type Greeting = `Hello, ${string}`; let message: Greeting = "Hello, Alice"; ``` 228. **Index Types**:索引类型,表示对象的键或值的类型。 ```typescript type Keys = keyof { name: string; age: number }; let key: Keys = "name"; ```
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值