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";
```