为什么 TypeScript 中的类允许使用鸭子类型

IT技术 javascript class typescript interface duck-typing
2021-01-18 17:31:29

看起来在 TypeScript 中有这样的代码绝对没问题（从编译器的角度来看）：

class Vehicle {
    public run(): void { console.log('Vehicle.run'); }
}

class Task {
    public run(): void { console.log('Task.run'); }
}

function runTask(t: Task) {
    t.run();
}

runTask(new Task());
runTask(new Vehicle());

但在同一时间，我会期望一个编译错误，因为Vehicle并Task没有什么共同点。

而理智的用途可以通过明确的接口定义来实现：

interface Runnable {
    run(): void;
}

class Vehicle implements Runnable {
    public run(): void { console.log('Vehicle.run'); }
}

class Task implements Runnable {
    public run(): void { console.log('Task.run'); }
}

function runRunnable(r: Runnable) {
    r.run();
}

runRunnable(new Task());
runRunnable(new Vehicle());

...或一个共同的父对象：

class Entity {
    abstract run(): void;
}

class Vehicle extends Entity {
    public run(): void { console.log('Vehicle.run'); }
}

class Task extends Entity {
    public run(): void { console.log('Task.run'); }
}

function runEntity(e: Entity) {
    e.run();
}

runEntity(new Task());
runEntity(new Vehicle());

是的，对于 JavaScript 来说，拥有这样的行为绝对没问题，因为根本没有类和编译器（只有语法糖），并且鸭子类型对于该语言来说是很自然的。但是 TypeScript 试图引入静态检查、类、接口等。然而，在我看来，类实例的鸭子类型看起来相当混乱且容易出错。

2个回答

这就是结构类型的工作方式。Typescript 有一个结构类型系统，可以最好地模拟 Javscript 的工作方式。由于 Javascript 使用鸭子类型，因此定义合约的任何对象都可以在任何函数中使用。Typescript 只是尝试在编译时而不是在运行时验证鸭子类型。

然而，您的问题只会出现在琐碎的类中，一旦您添加私有类，即使它们具有相同的结构，类也会变得不兼容：

class Vehicle {
    private x: string;
    public run(): void { console.log('Vehicle.run'); }
}

class Task {
    private x: string;
    public run(): void { console.log('Task.run'); }
}

function runTask(t: Task) {
    t.run();
}

runTask(new Task());
runTask(new Vehicle()); // Will be a compile time error

这种行为还允许您不显式实现接口，例如您的函数可以为参数内联定义接口，并且任何满足契约的类都将兼容，即使它们没有显式实现任何接口：

function runTask(t: {  run(): void }) {
    t.run();
}

runTask(new Task());
runTask(new Vehicle());

就个人而言，从 C# 开始这似乎很疯狂，但是当涉及到可扩展性时，这种类型检查方式允许更大的灵活性，一旦你习惯了它，你就会看到它的好处。

@ivan 我认为typescript会从“不可删减的类型”中受益......当你打开一个提案时告诉我，我会支持:)
2021-03-21 17:31:29
@titian 我知道，但这是一个糟糕的解决方法。我使用 eg type userID = string,type groupID = string来区分两者，因为它们非常相似。防止鸭子在那里打字会很好。
2021-03-21 17:31:29
只是为了清楚起见：结构类型和鸭子类型或多或少是一回事，这两者的对比类型系统称为名义类型：en.wikipedia.org/wiki/Nominal_type_system
2021-03-21 17:31:29
@乔纳斯。typescript 编译器团队做了类似的事情，这就是我想添加属性以使类型不兼容的想法。来自 TS 编译器代码：export type Path = string & { __pathBrand: any }; github.com/Microsoft/TypeScript/blob/master/src/compiler/...
2021-03-29 17:31:29
@乔纳斯。我很确定有一个，同时，简单的解决方案是添加一个私有的，您甚至不必使用它，因此没有运行时惩罚，class Task { private unduckable : true }就足够了，在运行时unduckable将不存在
2021-04-04 17:31:29

现在可以使用 TypeScript 创建名义类型，允许您根据上下文区分类型。请考虑以下问题：

TypeScript 中的原子类型区分（名义原子类型）

用它的例子：

export type Kilos<T> = T & { readonly discriminator: unique symbol };
export type Pounds<T> = T & { readonly discriminator: unique symbol };

export interface MetricWeight {
    value: Kilos<number>
}

export interface ImperialWeight {
    value: Pounds<number>
}

const wm: MetricWeight = { value: 0 as Kilos<number> }
const wi: ImperialWeight = { value: 0 as Pounds<number> }

wm.value = wi.value;                  // Gives compiler error
wi.value = wi.value * 2;              // Gives compiler error
wm.value = wi.value * 2;              // Gives compiler error
const we: MetricWeight = { value: 0 } // Gives compiler error
其它你可能感兴趣的问题
上一篇如何在 JavaScript 中使变量可按名称作为字符串寻址？ 下一篇我应该避免异步处理 Promise 拒绝吗？