trait 定义共享行为

前面讲泛型时，频繁出现 T: PartialOrd、T: Add 这样的约束。那些 PartialOrd、Add 就是 trait。这一章把 trait 本身讲清楚——理解了 trait，前面那些”约束”就不再是一团黑话，而是”要求类型具备某种能力”的白话。

1-1 trait 是什么

假设你要做一个内容系统，有”文章”和”微博”两种载体，都能被”总结”。总结这个行为，不管是文章还是微博都具备——这就是共享行为。trait 的作用，就是把一组共享行为抽象出来。

学过其他语言的话，trait 很像接口（interface）：它定义”有哪些行为、长什么样”，但不关心”具体怎么实现”。只要某个类型实现了这个 trait，它就能用这套行为。

你早就见过 trait 了：#[derive(Debug)] 就是自动给你的类型实现 Debug trait，于是能用 println!("{:?}", x) 打印；T: std::ops::Add 约束则是要求 T 实现了 Add trait 才能相加。

1-2 定义 trait

用 trait 关键字定义，大括号里罗列方法签名（只写长相，不写实现，结尾是 ;）：

pub trait Summary {
    fn summarize(&self) -> String;
}

这里 Summary 是 trait 名，summarize 是它定义的行为。注意方法签名后面是分号、没有 {}——因为 trait 只声明”要有什么行为”，不写”行为怎么做”。

1-3 为类型实现 trait

定义完，得为具体类型把行为补上。语法和给结构体实现方法很像：impl Trait名 for 类型名：

pub struct Post {
    pub title: String,
    pub author: String,
    pub content: String,
}

impl Summary for Post {
    fn summarize(&self) -> String {
        format!("文章{}，作者是{}", self.title, self.author)
    }
}

pub struct Weibo {
    pub username: String,
    pub content: String,
}

impl Summary for Weibo {
    fn summarize(&self) -> String {
        format!("{}发表了微博{}", self.username, self.content)
    }
}

编译器会确保每个实现 Summary 的类型，都有签名完全一致的 summarize 方法。之后就能直接调用：

fn main() {
    let post = Post { title: "Rust 简介".to_string(), author: "码上学".to_string(), content: String::new() };
    let weibo = Weibo { username: "max".to_string(), content: "今天学 Rust".to_string() };

    println!("{}", post.summarize());
    println!("{}", weibo.summarize());
}

1-4 孤儿规则：实现放在哪

为类型实现 trait 时，有一条铁律叫孤儿规则：要为一个类型 A 实现 trait T，那么 A 和 T 至少有一个是在当前包里定义的。

拆开看就很好懂：

• 给自己的 Post 实现标准库的 Display——可以，因为 Post 是你定义的；
• 给当前包的 Post 实现你自己的 Summary——可以，因为 Summary 是你定义的；
• 给标准库的 String 实现标准库的 Display——不行，因为 String 和 Display 都在标准库，跟你当前包没关系。

这条规则保证了你的代码不会被别人的实现意外破坏，也不会误伤八竿子打不着的代码。它是 Rust 生态能平稳共存多个库的基础。

1-5 用 trait 作函数参数

trait 最出彩的用处，是让函数接收”任何实现了某 trait 的类型”。写法是用 impl Trait：

pub fn notify(item: &impl Summary) {
    println!("快讯！{}", item.summarize());
}

&impl Summary 读作”一个实现了 Summary 的引用”。你可以传 Post 或 Weibo 进去，函数体内都能调 summarize。而 String、i32 这类没实现 Summary 的类型，编译器会拒绝传入。

这种写法的意义是：函数不再关心具体类型，只关心”你有没有这个能力”。这正是多态——同一份逻辑，适配所有满足条件的类型。

1-6 trait 与方法调用的关系

有一点容易绕：某个 trait 的方法，要能调用，往往得把 trait 引入作用域。比如标准库里有些 trait 没被预导入，你调用它上面的方法时，就得 use 引入那个 trait，否则编译器不知道方法从哪来（像 TryInto 这种在 2024 Edition 已进 prelude 的，通常就不用写）。

不过最常用的标准库 trait 已经被 prelude 预先引入了，所以像 PartialOrd 的比较、Debug 的打印，你平时感觉不到要 use。

1-7 trait 带来的多态

trait 的意义不只是”约束泛型”，它本身也是一种多态机制。只要多个不同类型都实现了同一个 trait，你就可以把它们当作”同一类能做某事的东西”来统一处理——这正是面向对象里”接口”的味道，但 Rust 做得更轻。

比如 i32 和 f64 都实现了 PartialOrd，所以一个接收 impl PartialOrd 的函数，既能收 i32 也能收 f64，内部统一调用比较方法，不必关心具体类型。这种”针对行为编程、而非针对具体类型编程”的思路，是 Rust 代码复用的大杀器。

fn larger<T: PartialOrd>(a: T, b: T) -> T {
    if a > b { a } else { b }
}
// larger(3, 5) 和 larger(2.0, 1.0) 都能用

1-8 默认方法带来的代码复用

trait 里除了”必须自己实现”的方法，还可以放”默认实现”的方法。这样，所有实现该 trait 的类型都能免费获得这套行为，只在必要时重写。

trait Logger {
    fn target(&self) -> String;          // 必须实现：去哪打日志
    fn log(&self, msg: &str) {            // 有默认实现
        println!("[{}] {}", self.target(), msg);
    }
}

struct Console;
impl Logger for Console {
    fn target(&self) -> String { "console".into() }
}

这里 Console 只实现了 target，就自动拥有了 log——因为 log 的默认实现调用了 target。这比”每个类型都手写一遍 log”省事太多，也是 Rust 标准库里大量 trait（比如 Iterator 的几十个适配器）的设计秘密：核心方法你来实现，便利方法库已经用默认实现替你写好了。

1-9 trait 实现的两种来源

你写的类型实现你定义的 trait，这是最常见的；但还有两种容易忽略的来源。第一，标准库已经为很多类型实现了大量 trait：比如 i32 实现了 Display、PartialOrd、Add 等，所以你能直接 print!("{}", 3)、3 > 2、1 + 2。这些实现是标准库在它自己的类型上做的，符合孤儿规则（trait 和类型至少有一方在标准库里）。

第二，derive 宏本质上就是”自动为你实现一个 trait”。#[derive(Debug, Clone, PartialEq)] 让编译器帮你写出这些 trait 的 impl 块。所以当你 derive(Debug) 时，其实相当于让编译器替你 impl Debug for 你的类型。理解了这一点，trait 就不再是”要手写的接口”，而是”编译器能帮你批量生成的能力”。

1-10 用 impl Trait 当返回值

impl Trait 不仅能用在参数上，也能用在返回值上：告诉调用者”我返回一个实现了某 trait 的类型，但具体是哪个你不用管”。

fn make_summary() -> impl Summary {
    Weibo {
        username: "max".into(),
        content: "今天又学了 trait".into(),
    }
}

对调用者来说，只知道拿到的是”某个能 summarize 的东西”，不知道（也不需要知道）它具体是 Weibo 还是 Post。这个写法在后面讲闭包和迭代器时会特别香——因为闭包和迭代器的真实类型又长又怪，连编译器都替你算出来，你根本没法、也不用写出它的具体类型，直接用 impl Iterator、impl Fn 挡在返回值上就行。

不过它有个硬限制：只能返回”一种”具体类型。下面的代码会报错，因为 if 分支返回 Post、else 分支返回 Weibo，是两个不同类型：

fn make_summary(switch: bool) -> impl Summary {
    if switch {
        Post { /* ... */ }
    } else {
        Weibo { /* ... */ }
    }
}

真要根据运行期情况返回不同类型，得用”trait 对象” Box<dyn Summary>（动态分发），那是进阶话题，记住 impl Trait 是”单一固定类型、写法最省”的版本即可。

1-11 小结

• trait 抽象”共享行为”，类似其他语言的接口；只定义方法签名，不写实现；
• 用 impl Trait for Type 为类型实现行为，编译器保证签名一致；
• 孤儿规则：类型或 trait 至少有一个在当前包定义，才能在此实现；
• &impl Trait 让函数接收任何实现了该 trait 的类型，实现多态；
• 调用定义在 trait 上的方法，需要把该 trait 引入作用域（常用 trait 已在 prelude 中）。

下一章深入 trait 的默认实现，以及 trait 约束（trait bound）的多种写法。