Question

在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试图引入静态检查，类，接口等。但在我看来，类实例的鸭子类型看起来相当混乱和容易出错。

Answer 1

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

然而，只有在添加私有类时，您的问题才会显示为普通类，即使它们具有相同的结构，类也会变得不兼容：

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＃，这一开始看起来很疯狂，但是当谈到可扩展性时，这种类型检查方式可以提供更大的灵活性，一旦你习惯它，你就会看到它的好处。

Answer 2

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

Atomic type discrimination (nominal atomic types) in 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

为什么TypeScript中的类允许使用duck typing

2 个答案: