JS `Type Systems` `Structural Typing` vs `Nominal Typing` 的实践差异

咳咳，大家好，我是今天的主讲人，大家可以叫我老码。今天咱们来聊聊JavaScript里的类型系统，尤其是结构化类型（Structural Typing）和名义类型（Nominal Typing）这俩兄弟，看看它们在实践中都有哪些不一样的地方。

开场白：类型，就像给变量穿衣服

咱们写代码，其实就是在告诉电脑“这个数据应该怎么处理”。类型呢，就像是给变量穿的衣服，告诉电脑“这件衣服（这个数据）是啥材质的，应该怎么洗（怎么处理）”。

JavaScript这门语言，它很自由，类型检查比较晚，很多错误都是在运行的时候才发现的。但随着项目越来越大，代码越来越复杂，类型的重要性就凸显出来了。

第一部分：类型系统概览

首先，简单回顾一下类型系统的概念。类型系统就是一套规则，用来保证程序中数据的正确使用。它可以帮助我们：

发现错误： 在代码运行之前，就找出类型不匹配的错误。
提高代码可读性： 明确变量的类型，让代码更容易理解。
增强代码可维护性： 类型信息可以帮助我们更好地重构和修改代码。

常见的类型系统可以分为静态类型和动态类型：

静态类型： 类型检查在编译时进行，例如Java，C++，TypeScript。
动态类型： 类型检查在运行时进行，例如JavaScript，Python，Ruby。

JavaScript本身是动态类型的，但我们可以使用TypeScript来给它加上静态类型的特性。

第二部分：名义类型 (Nominal Typing)：认名字不认人

名义类型，简单来说，就是“认名字不认人”。只有名字完全相同的类型，才被认为是同一个类型。就像身份证，只有身份证号完全一样，才能证明你是同一个人。

举个例子，用Java写个代码：

class Person {
    String name;
    int age;
}

class Employee {
    String name;
    int age;
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        Employee employee = new Employee();

        // 编译错误！即使两个类的属性相同，但因为名字不同，所以不能互相赋值
        // person = employee;
    }
}

在上面的Java代码中，Person和Employee虽然都有name和age属性，但是因为它们是不同的类，所以不能互相赋值。这就是名义类型的特点。

特点：

强制性强： 类型匹配非常严格，必须是同一个类型才能进行操作。
安全性高： 可以有效避免类型混淆导致的错误。
代码可读性好： 类型信息明确，易于理解。
灵活性差： 类型必须完全匹配，不够灵活。

应用场景：

需要高安全性和可靠性的系统，例如金融系统、医疗系统。
大型项目，需要明确的类型定义来保证代码的正确性。

第三部分：结构化类型 (Structural Typing)：认人不认名字

结构化类型，又叫鸭子类型（Duck Typing），它的原则是“只要长得像鸭子，叫起来像鸭子，走起来像鸭子，那它就是鸭子”。也就是说，只要两个对象的结构（属性和方法）相同，就被认为是同一个类型，即使它们的名字不同。

在TypeScript中，就采用了结构化类型。看个例子：

interface Person {
    name: string;
    age: number;
}

interface Employee {
    name: string;
    age: number;
    employeeId: string;
}

let person: Person = { name: "Alice", age: 30 };
let employee: Employee = { name: "Bob", age: 25, employeeId: "123" };

person = employee; // ✅  TypeScript 允许这样做！

function greet(p: Person) {
    console.log(`Hello, ${p.name}! You are ${p.age} years old.`);
}

greet(employee); // ✅  TypeScript 允许这样做！

在上面的TypeScript代码中，Person和Employee虽然是不同的接口，但是因为Employee包含了Person的所有属性，所以可以将Employee类型的对象赋值给Person类型的变量，也可以传递给接受Person类型参数的函数。

特点：

灵活性高： 只要结构相同，就可以认为是同一个类型，不需要关心名字。
代码复用性好： 可以更容易地编写通用的代码，处理不同类型的对象。
类型安全性稍弱： 容易出现类型混淆，需要更仔细地进行类型检查。
代码可读性稍差： 需要仔细分析对象的结构才能确定类型。

应用场景：

需要高灵活性的系统，例如Web开发、动态语言。
快速原型开发，可以更快地构建应用。
需要处理大量不同类型对象的情况。

第四部分：实践差异：代码说了算

现在，咱们来深入探讨一下，在实际开发中，结构化类型和名义类型有哪些具体的差异。

1. 类型兼容性：

特性	名义类型 (Nominal Typing)	结构化类型 (Structural Typing)
类型兼容性要求	类型名称必须完全相同	结构（属性和方法）必须兼容
赋值	只有相同类型才能赋值	结构兼容即可赋值
函数参数传递	只有相同类型才能传递	结构兼容即可传递

2. 类型定义：

名义类型： 需要显式地定义类型名称，例如Java中的class。
结构化类型： 类型定义可以更灵活，只需要描述对象的结构即可，例如TypeScript中的interface。

3. 代码复用：

名义类型： 代码复用通常需要继承或者实现接口，比较繁琐。
结构化类型： 可以更容易地编写通用的代码，处理不同类型的对象，只需要保证对象的结构兼容即可。

4. 类型推断：

名义类型： 类型推断相对简单，因为类型名称是明确的。
结构化类型： 类型推断可能更复杂，需要分析对象的结构才能确定类型。

5. 错误检测：

名义类型： 类型错误通常在编译时就能发现，更早地发现错误。
结构化类型： 类型错误可能在运行时才发现，需要更仔细地进行测试。

代码示例：

咱们用TypeScript来演示一下结构化类型和名义类型在实践中的差异。

// 结构化类型
interface Point {
    x: number;
    y: number;
}

interface LabelledPoint {
    x: number;
    y: number;
    label: string;
}

function printPoint(p: Point) {
    console.log(`x: ${p.x}, y: ${p.y}`);
}

let point: Point = { x: 10, y: 20 };
let labelledPoint: LabelledPoint = { x: 30, y: 40, label: "origin" };

printPoint(point); // ✅
printPoint(labelledPoint); // ✅  结构化类型允许这样做

// 模拟名义类型 (在 TypeScript 中，我们通常使用 class 来模拟名义类型)
class NominalPoint {
    x: number;
    y: number;

    constructor(x: number, y: number) {
        this.x = x;
        this.y = y;
    }
}

class AnotherNominalPoint {
    x: number;
    y: number;

    constructor(x: number, y: number) {
        this.x = x;
        this.y = y;
    }
}

let nominalPoint: NominalPoint = new NominalPoint(50, 60);
let anotherNominalPoint: AnotherNominalPoint = new AnotherNominalPoint(70, 80);

//  在 TypeScript 中，即使结构相同，但不同的 class 实例赋值仍然可行（因为 TypeScript 主要是结构化类型，但 class 引入了一些名义类型的特性）
// printPoint(nominalPoint); // ❌ 如果 `printPoint` 接受 `NominalPoint` 类型，则会报错
// printPoint(anotherNominalPoint); // ❌ 如果 `printPoint` 接受 `AnotherNominalPoint` 类型，则会报错

//  可以通过类型断言来解决
printPoint(nominalPoint as any);
printPoint(anotherNominalPoint as any);

第五部分：TypeScript 中的类型系统

TypeScript 融合了结构化类型和名义类型的特点。

主要采用结构化类型： TypeScript 的接口和类型别名主要基于结构化类型。
class 引入了名义类型的特性： 虽然 TypeScript 主要采用结构化类型，但 class 引入了一些名义类型的特性。例如，不同的 class 实例不能直接互相赋值，除非它们之间存在继承关系或者使用了类型断言。

第六部分：选择哪种类型系统？

选择哪种类型系统，取决于具体的项目需求。

如果需要高安全性和可靠性， 并且对代码的灵活性要求不高，可以选择名义类型。
如果需要高灵活性和代码复用性， 并且可以容忍一些类型错误，可以选择结构化类型。
如果使用 TypeScript， 可以充分利用其结构化类型的特性，同时使用 class 来模拟名义类型，以达到更好的平衡。

总结：

名义类型： 认名字不认人，类型匹配严格，安全性高，灵活性差。
结构化类型： 认人不认名字，类型匹配灵活，代码复用性好，类型安全性稍弱。
TypeScript： 融合了结构化类型和名义类型的特点，可以根据项目需求选择合适的类型定义方式。

最后：

理解结构化类型和名义类型的差异，可以帮助我们更好地设计和编写代码，提高代码的质量和可维护性。希望今天的分享对大家有所帮助！

好了，今天的讲座就到这里，大家有什么问题可以提问。

发表回复 取消回复

发表回复取消回复