TypeScript 中的 extends 关键字就像一把瑞士军刀。它用于多种上下文，包括继承、泛型和条件类型。了解如何有效地使用扩展可以生成更健壮、可重用和类型安全的代码。

使用扩展进行继承

extends 的主要用途之一是继承，允许您创建基于现有接口或类的新接口或类。

interface User {
  firstName: string;
  lastName: string;
  email: string;
}

interface StaffUser extends User {
  roles: string[];
  department: string;
}

const regularUser: User = {
  firstName: "John",
  lastName: "Doe",
  email: "[email protected]"
};

const staffMember: StaffUser = {
  firstName: "Jane",
  lastName: "Smith",
  email: "[email protected]",
  roles: ["Manager", "Developer"],
  department: "Engineering"
};

在此示例中，StaffUser 扩展了 User，继承了其所有属性并添加了新属性。这使我们能够基于更通用的类型创建更具体的类型。

类继承

extends关键字也用于类继承：

class Animal {
  constructor(public name: string) {}

  makeSound(): void {
    console.log("Some generic animal sound");
  }
}

class Dog extends Animal {
  constructor(name: string, public breed: string) {
    super(name);
  }

  makeSound(): void {
    console.log("Woof! Woof!");
  }

  fetch(): void {
    console.log(`${this.name} is fetching the ball!`);
  }
}

const myDog = new Dog("Buddy", "Golden Retriever");
myDog.makeSound(); // Output: Woof! Woof!
myDog.fetch(); // Output: Buddy is fetching the ball!

这里，Dog 扩展了 Animal，继承了它的属性和方法，同时还添加了它自己的属性和方法。

泛型中的类型约束

extends 关键字在使用泛型时至关重要，它允许我们限制可与泛型函数或类一起使用的类型。

interface Printable {
  print(): void;
}

function printObject(obj: T) {
  obj.print();
}

class Book implements Printable {
  print() {
    console.log("Printing a book.");
  }
}

class Magazine implements Printable {
  print() {
    console.log("Printing a magazine.");
  }
}

const myBook = new Book();
const myMagazine = new Magazine();

printObject(myBook);      // Output: Printing a book.
printObject(myMagazine);  // Output: Printing a magazine.
// printObject(42);       // Error, number doesn't have a 'print' method

1. 接口Printable：这里，我们定义了一个名为Printable的接口。该接口声明了任何实现它的类都必须遵守的契约。契约规定任何实现 Printable 的类必须提供一个名为 print 的方法，该方法不带参数并返回 void
2. function printObject(obj: T)：这是一个名为 printObject 的通用函数。它采用名为 obj 的单个参数，该参数为 T 类型。类型参数 T 被限制为扩展（实现）Printable 接口的类型，可以用作此函数的参数。
3. Book 类实现 Printable，Magazine 类实现 Printable：这里，我们定义两个类，Book 和 Magazine，它们都实现 Printable 接口。这意味着这些类必须根据 Printable 接口的约定提供打印方法。
4. const myBook = new Book(); const myMagazine = new Magazine();：我们创建 Book 和 Magazine 类的实例。
5. 打印对象（myBook）； and printObject(myMagazine);：我们用 Book 和 Magazine 的实例调用 printObject 函数。由于 Book 和 Magazine 类都实现了 Printable 接口，因此它们满足 T extends Printable 类型参数的约束。在函数内部，调用相应类的 print 方法，从而产生预期的输出。
6. // printObject(42);：如果我们尝试使用未实现 Printable 接口的类型（例如数字 42）调用 printObject，TypeScript 将引发错误。这是因为不满足类型约束，因为 number 没有 Printable 接口所要求的打印方法。

总之，函数 printObject(obj: T) 上下文中的 extends 关键字用于确保用作参数的类型 T 遵守 Printable 接口定义的约定。这确保只有具有 print 方法的类型才能与 printObject 函数一起使用，从而强制执行函数使用的特定行为和契约。

条件类型

T extends U ? X : Y

• T 是正在检查的类型
• U 是 T 正在检查的条件类型。
• 如果 T 扩展（可分配给）U，则 X 是条件类型求值的类型
• Y 是 T 不扩展 U 时条件类型求值的类型

type ExtractNumber = T extends number ? T : never;

type NumberOrNever = ExtractNumber; // number
type StringOrNever = ExtractNumber; // never

此处，ExtractNumber 类型采用类型参数 T。条件类型检查 T 是否扩展了数字类型。如果是，则类型解析为 T（这是数字类型）。如果不存在，则类型解析为 never。

具有联合类型的 extends 关键字

现在，让我们考虑表达式 A |乙| C 扩展了 A。乍一看这似乎违反直觉，但在 TypeScript 中，这个条件实际上是错误的。原因如下：

1. 在 TypeScript 中，当您在左侧使用带有联合类型的 extends 时，相当于询问：“这个联合中的每个可能的类型都可以分配给右侧的类型吗？”
2. 换句话说，A |乙| C 扩展 A 正在询问：“可以将 A 分配给 A，并且可以将 B 分配给 A，并且可以将 C 分配给 A？”
3. 虽然 A 当然可以分配给 A，但 B 和 C 可能无法分配给 A（除非它们是 A 的子类型），因此总体结果为 false。

type Fruit = "apple" | "banana" | "cherry";
type CitrusFruit = "lemon" | "orange";

type IsCitrus = T extends CitrusFruit ? true : false;

type Test1 = IsCitrus; // true
type Test2 = IsCitrus; // false
type Test3 = IsCitrus; // false

在此示例中，IsCitrus 为 false，因为 Fruit 联合中并非所有水果都是 CitrusFruit。

最佳实践和技巧

• 使用扩展来建立有意义的关系：仅当类型之间存在明确的“is-a”关系时才使用继承。
• 优先选择组合而不是继承：在许多情况下，组合（使用接口和类型交集）比类继承更灵活。
• 谨慎对待深层继承链：深层继承会使代码更难理解和维护。
• 利用条件类型实现灵活的 API：使用带有扩展的条件类型来创建根据输入类型进行调整的 API。
• 在泛型中使用扩展来创建可重用的、类型安全的函数：这允许您编写适用于各种类型的函数，同时仍然保持类型安全