编程语言的类型系统（Type System）是语言设计中最核心的决策之一，它直接影响代码的安全性、表达力和开发体验。类型系统的分类并非简单的二元对立，而是由多个正交的维度组成。

本文整理自 Reddit 上一篇经典的类型系统分类讨论（原文链接），并在此基础上做了扩展和补充。

类型系统的四个正交维度

维度一：Static vs Dynamic Typing（静态类型 vs 动态类型）

区分的关键点：类型检查发生在编译期还是运行期。

静态类型（Static Typing）：变量的类型在编译期确定，类型错误在编译阶段就能被发现。编译器可以利用类型信息进行优化。
动态类型（Dynamic Typing）：变量的类型在运行期确定，同一个变量可以在不同时刻持有不同类型的值。类型错误只有在运行到相关代码时才会暴露。

分类	代表语言	特点
静态类型	Java、Scala、Haskell、Go、Rust	编译期发现类型错误，IDE 支持好
动态类型	Ruby、Python、Erlang、JavaScript	开发灵活，但类型错误延迟到运行期

渐进类型（Gradual Typing）是近年来的趋势，允许在同一语言中混合使用静态和动态类型。TypeScript 就是 JavaScript 的渐进类型化方案，Python 3.5+ 的 Type Hints 也属于此类。

维度二：Strong vs Weak Typing（强类型 vs 弱类型）

区分的关键点：运行时是否允许隐式类型转换（implicit type coercion）。

强类型（Strong Typing）：不同类型之间的操作需要显式转换，类型边界严格。
弱类型（Weak Typing）：允许不同类型之间的隐式转换，类型边界模糊。

分类	代表语言	特点
强类型	Java、Scala、Python、Haskell、Rust	类型安全，减少隐式错误
弱类型	C、Assembly、JavaScript、PHP	灵活但容易产生意外行为

典型的弱类型行为示例（JavaScript）：

1
2
3

"5" - 3    // 结果为 2，字符串被隐式转换为数字
"5" + 3    // 结果为 "53"，数字被隐式转换为字符串
[] + {}    // 结果为 "[object Object]"

需要注意的是，"强/弱"是一个连续光谱而非二元分类。Java 的自动装箱（autoboxing）和字符串拼接中的隐式 toString() 调用，使得 Java 并非绝对的强类型。

维度三：Latent (Implicit) vs Manifest (Explicit) Typing（隐式类型 vs 显式类型）

区分的关键点：是否需要在源码中显式声明变量的类型。

隐式类型（Implicit/Latent Typing）：编译器或解释器通过类型推断（Type Inference）自动确定变量类型，无需程序员显式标注。
显式类型（Explicit/Manifest Typing）：程序员必须在源码中显式声明变量的类型。

分类	代表语言	特点
隐式类型	Haskell、Erlang、Python、Kotlin（`val`）	代码简洁，减少样板代码
显式类型	C、C++、Java（传统风格）	类型信息一目了然，可读性强

现代语言的趋势是在静态类型的基础上支持类型推断，兼顾安全性和简洁性：

Java 10 引入 var 关键字：var list = new ArrayList<String>()
Kotlin 的 val/var：val name = "hello" 自动推断为 String
Rust 的 let：let x = 42 自动推断为 i32
Go 的 :=：x := 42 自动推断为 int

维度四：Nominal vs Structural Typing（名义类型 vs 结构类型）

区分的关键点：类型兼容性的判定依据是类型的名称（标称）还是类型的结构（内容）。

名义类型（Nominal Typing）：两个类型是否兼容取决于它们的名称和显式的继承/实现关系。即使两个类型的结构完全相同，如果没有显式声明关系，它们也不兼容。
结构类型（Structural Typing）：两个类型是否兼容取决于它们的结构（字段和方法签名）。只要结构匹配，就认为类型兼容，也称为"鸭子类型"（Duck Typing）的静态版本。

分类	代表语言	特点
名义类型	C、C++、Java、C#	类型关系显式、清晰，适合大型工程
结构类型	Haskell、Go（接口）、TypeScript	灵活解耦，无需显式声明实现关系

Go 语言的接口是结构类型的典型代表：

type Writer interface {
    Write(p []byte) (n int, err error)
}

// MyWriter 没有显式声明 implements Writer
// 但因为它有 Write 方法，所以自动满足 Writer 接口
type MyWriter struct{}

func (w MyWriter) Write(p []byte) (int, error) {
    return len(p), nil
}

维度组合与语言定位

将四个维度组合起来，可以更精确地描述一门语言的类型系统特征：

语言	静态/动态	强/弱	隐式/显式	名义/结构
Java	静态	强	显式（Java 10 后部分隐式）	名义
Haskell	静态	强	隐式	结构
Python	动态	强	隐式	结构（鸭子类型）
JavaScript	动态	弱	隐式	结构
TypeScript	静态（渐进）	强	混合	结构
Go	静态	强	混合	结构（接口）/名义（其他）
Rust	静态	强	混合	名义 + Trait
C	静态	弱	显式	名义

类型系统设计的权衡

类型系统的设计本质上是在以下几个维度之间做权衡：

权衡维度	偏左	偏右
安全性 vs 灵活性	静态 + 强类型（Java、Rust）	动态 + 弱类型（JavaScript）
简洁性 vs 可读性	隐式类型（Haskell）	显式类型（C、Java）
解耦性 vs 明确性	结构类型（Go 接口）	名义类型（Java 接口）
编译期保障 vs 开发速度	静态类型	动态类型

没有"最好"的类型系统，只有最适合特定场景的类型系统。大型工程倾向于静态 + 强 + 名义的组合（如 Java），快速原型开发倾向于动态 + 强 + 结构的组合（如 Python）。

关于编程语言的typing(一些基本概念)