掌握 TypeScript:了解扩展的力量

掌握 typescript:了解扩展的力量

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: "john@example.com"
};

const staffmember: staffuser = {
  firstname: "jane",
  lastname: "smith",
  email: "jane@company.com",
  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<t extends printable>(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
</t>
  1. 接口printable:这里,我们定义了一个名为printable的接口。该接口声明了任何实现它的类都必须遵守的契约。契约规定任何实现 printable 的类必须提供一个名为 print 的方法,该方法不带参数并返回 void
  2. function printobject printable>(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 printable>(obj: t) 上下文中的 extends 关键字用于确保用作参数的类型 t 遵守 printable 接口定义的约定。这确保只有具有 print 方法的类型才能与 printobject 函数一起使用,从而强制执行函数使用的特定行为和契约。

条件类型

t extends u ? x : y
  • t 是正在检查的类型
  • u 是 t 正在检查的条件类型。
  • 如果 t 扩展(可分配给)u,则 x 是条件类型求值的类型
  • y 是 t 不扩展 u 时条件类型求值的类型
type extractnumber<t> = t extends number ? t : never;

type numberornever = extractnumber<number>; // number
type stringornever = extractnumber<string>; // never
</string></number></t>

这里,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> = T extends CitrusFruit ? true : false;

type Test1 = IsCitrus; // true
type Test2 = IsCitrus; // false
type Test3 = IsCitrus<fruit>; // false
</fruit></t>

在此示例中,iscitrus 为 false,因为并非 fruit union 中的所有水果都是 citrusfruit。

最佳实践和技巧

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

以上就是掌握 TypeScript:了解扩展的力量的详细内容,更多请关注www.sxiaw.com其它相关文章!