extends关键字怎么使用extends关键字概述extendsextendsextendsextendsextendsextendsextendsextendsextendsextendsextendsextendsextendsextendsextendsextendsextendsextendsextendsextendsextendsextendsextendsextendsextendsTypeScript 是一种由微软开发的开源编程语言，它是 JavaScript 的一个超集，添加了可选的静态类型和基于类的面向对象编程。TypeScript 的设计目标是开发大型应用，并且可以编译成纯 JavaScript，从而在任何浏览器、任何计算机和任何操作系统上运行。
在 TypeScript 中，extends 关键字是一个非常重要的概念，它在类继承、接口继承、泛型约束、条件类型等多个场景中都有广泛的应用。本文将详细探讨 extends 关键字在 TypeScript 中的各种用法，并通过丰富的示例代码帮助读者深入理解其工作原理。
extends关键字概述extends 关键字在 TypeScript 中主要用于以下几个方面：
接下来，我们将逐一探讨这些用法。
extends在 TypeScript 中，类继承是通过 extends 关键字实现的。通过继承，子类可以继承父类的属性和方法，并且可以添加新的属性和方法，或者重写父类的方法。
class Parent {
name: string;
constructor(name: string) {
this.name = name;
}
greet(): void {
console.log(`Hello, ${this.name}`);
}
}
class Child extends Parent {
age: number;
constructor(name: string, age: number) {
super(name);
this.age = age;
}
greet(): void {
super.greet();
console.log(`I am ${this.age} years old.`);
}
}
const child = new Child("Alice", 10);
child.greet();
Parent 类有一个 name 属性和一个 greet 方法。Child 类通过 extends 关键字继承了 Parent 类，并添加了一个 age 属性。Child 类重写了 greet 方法，并在其中调用了父类的 greet 方法。Hello, Alice
I am 10 years old.
super()，以初始化父类的属性。super 关键字调用父类的方法。extends在 TypeScript 中，接口继承也是通过 extends 关键字实现的。通过继承，子接口可以继承父接口的属性和方法，并且可以添加新的属性和方法。
interface Person {
name: string;
age: number;
}
interface Employee extends Person {
employeeId: number;
}
const employee: Employee = {
name: "Alice",
age: 30,
employeeId: 12345
};
console.log(employee);
Person 接口定义了 name 和 age 属性。Employee 接口通过 extends 关键字继承了 Person 接口，并添加了一个 employeeId 属性。employee 对象实现了 Employee 接口，因此必须包含 name、age 和 employeeId 属性。{ name: 'Alice', age: 30, employeeId: 12345 }
extends在 TypeScript 中，泛型约束是通过 extends 关键字实现的。通过泛型约束，可以限制泛型参数的类型范围，从而确保类型安全。
function printLength<T extends { length: number }>(arg: T): void {
console.log(arg.length);
}
printLength("Hello"); // 5
printLength([1, 2, 3]); // 3
printLength({ length: 10 }); // 10
printLength 函数接受一个泛型参数 T，并且 T 必须满足 { length: number } 的约束。T 必须是一个具有 length 属性的对象，且 length 属性的类型为 number。printLength 函数可以接受字符串、数组和具有 length 属性的对象。5
3
10
& 符号进行组合。extends在 TypeScript 中，条件类型是通过 extends 关键字实现的。条件类型允许根据类型关系进行条件判断，从而生成不同的类型。
type IsString<T> = T extends string ? true : false;
type A = IsString<"hello">; // true
type B = IsString<123>; // false
IsString 是一个条件类型，它接受一个泛型参数 T。T 是 string 类型的子类型，则 IsString<T> 为 true，否则为 false。A 的类型为 true，因为 "hello" 是 string 类型的子类型。B 的类型为 false，因为 123 不是 string 类型的子类型。true
false
extends在 TypeScript 中，extends 关键字还可以用于创建高级类型，如联合类型、交叉类型、映射类型等。
type A = string | number;
function printValue(value: A): void {
console.log(value);
}
printValue("Hello"); // Hello
printValue(123); // 123
A 是一个联合类型，表示 string 或 number 类型。printValue 函数接受一个 A 类型的参数，因此可以接受 string 或 number 类型的值。Hello
123
type A = { name: string };
type B = { age: number };
type C = A & B;
const person: C = {
name: "Alice",
age: 30
};
console.log(person);
A 和 B 是两个接口类型。C 是一个交叉类型，表示同时具有 A 和 B 的属性和方法。person 对象实现了 C 类型，因此必须包含 name 和 age 属性。{ name: 'Alice', age: 30 }
type Readonly<T> = {
readonly [P in keyof T]: T[P];
};
type Person = {
name: string;
age: number;
};
type ReadonlyPerson = Readonly<Person>;
const person: ReadonlyPerson = {
name: "Alice",
age: 30
};
// person.name = "Bob"; // Error: Cannot assign to 'name' because it is a read-only property.
Readonly 是一个映射类型，它将 T 类型的所有属性设置为只读。Person 是一个普通接口类型。ReadonlyPerson 是 Person 的只读版本，因此 person 对象的属性不能被修改。{ name: 'Alice', age: 30 }
extends在 TypeScript 中，extends 关键字还可以用于类型推断，从而根据类型关系推断出更具体的类型。
type A = string | number;
function printValue<T extends A>(value: T): void {
console.log(value);
}
printValue("Hello"); // Hello
printValue(123); // 123
A 是一个联合类型，表示 string 或 number 类型。printValue 函数接受一个泛型参数 T，并且 T 必须满足 A 的约束。printValue 函数可以接受 string 或 number 类型的值。Hello
123
extends在 TypeScript 中，extends 关键字还可以用于类型保护，从而在运行时判断变量的类型。
function isString(value: any): value is string {
return typeof value === "string";
}
function printValue(value: string | number): void {
if (isString(value)) {
console.log(`String: ${value}`);
} else {
console.log(`Number: ${value}`);
}
}
printValue("Hello"); // String: Hello
printValue(123); // Number: 123
isString 是一个类型保护函数，它判断 value 是否为 string 类型。printValue 函数接受一个 string 或 number 类型的参数。printValue 函数中，通过 isString 函数判断 value 的类型，并根据类型输出不同的结果。String: Hello
Number: 123
extends在 TypeScript 中，extends 关键字还可以用于类型兼容性判断，从而判断一个类型是否是另一个类型的子类型。
type A = string;
type B = string | number;
type C = A extends B ? true : false; // true
A 是 string 类型。B 是 string | number 类型。C 是一个条件类型，它判断 A 是否是 B 的子类型。string 是 string | number 的子类型，因此 C 的类型为 true。true
extends在 TypeScript 中，extends 关键字还可以用于类型别名，从而创建更复杂的类型别名。
type A = string;
type B = A extends string ? true : false; // true
A 是 string 类型。B 是一个条件类型，它判断 A 是否是 string 类型的子类型。A 是 string 类型，因此 B 的类型为 true。true
extends在 TypeScript 中，extends 关键字还可以用于类型映射，从而创建更复杂的类型映射。
type Readonly<T> = {
readonly [P in keyof T]: T[P];
};
type Person = {
name: string;
age: number;
};
type ReadonlyPerson = Readonly<Person>;
const person: ReadonlyPerson = {
name: "Alice",
age: 30
};
// person.name = "Bob"; // Error: Cannot assign to 'name' because it is a read-only property.
Readonly 是一个映射类型，它将 T 类型的所有属性设置为只读。Person 是一个普通接口类型。ReadonlyPerson 是 Person 的只读版本，因此 person 对象的属性不能被修改。{ name: 'Alice', age: 30 }
extends在 TypeScript 中，extends 关键字还可以用于类型操作，从而创建更复杂的类型操作。
type A = string;
type B = number;
type C = A extends string ? B extends number ? true : false : false; // true
A 是 string 类型。B 是 number 类型。C 是一个条件类型，它判断 A 是否是 string 类型的子类型，并且 B 是否是 number 类型的子类型。A 是 string 类型，且 B 是 number 类型，因此 C 的类型为 true。true
extends在 TypeScript 中，extends 关键字还可以用于类型工具，从而创建更复杂的类型工具。
type A = string;
type B = number;
type C = A extends string ? B extends number ? true : false : false; // true
A 是 string 类型。B 是 number 类型。C 是一个条件类型，它判断 A 是否是 string 类型的子类型，并且 B 是否是 number 类型的子类型。A 是 string 类型，且 B 是 number 类型，因此 C 的类型为 true。true
extends在 TypeScript 中，extends 关键字还可以用于类型系统设计，从而创建更复杂的类型系统。
type A = string;
type B = number;
type C = A extends string ? B extends number ? true : false : false; // true
A 是 string 类型。B 是 number 类型。C 是一个条件类型，它判断 A 是否是 string 类型的子类型，并且 B 是否是 number 类型的子类型。A 是 string 类型，且 B 是 number 类型，因此 C 的类型为 true。true
extends在 TypeScript 中，extends 关键字还可以用于类型安全，从而确保类型安全。
type A = string;
type B = number;
type C = A extends string ? B extends number ? true : false : false; // true
A 是 string 类型。B 是 `number免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
