三大常用 trait（Debug/Display/From）

前面讲了 trait 的通用机制。这一章落地三个你每天都会碰到的标准库 trait。它们都不复杂，但用得极频。

1-1 Debug：调试打印

Debug 让你用 println!("{:?}", x) 把任意类型打印出来，方便开发时看内部状态。最常见的是用 derive 自动派生，不用自己写：

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 3, y: 7 };
    println!("{:?}", p);
    println!("{:#?}", p); // 带缩进的漂亮格式
}

#[derive(Debug)] 让编译器自动生成实现，输出类似 Point { x: 3, y: 7 }。{:#?} 则是多行缩进版，结构嵌套深时更好读。

1-2 Display：给用户看的展示

Display 是”用户视角”的展示，用普通的 {} 打印，输出要友好、可读。它不能 derive，必须手动实现，因为”怎么展示给用户”只有你才知道：

use std::fmt;

struct Point {
    x: i32,
    y: i32,
}

impl fmt::Display for Point {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

fn main() {
    let p = Point { x: 3, y: 7 };
    println!("坐标：{}", p); // 坐标：(3, 7)
}

fmt 方法里用 write!(f, ...) 写入格式化器，返回 fmt::Result。注意 Display 用 {}，Debug 用 {:?}——这是两者最直观的区别。

Debug 和 Display 的分工可以这样记：

• Debug 给程序员调试用，能暴露内部结构，可自动派生；
• Display 给最终用户看，要整洁可读，必须手写实现。

不是所有类型都该有 Display。比如 Vec 只有 Debug，因为它没有”唯一正确的用户展示形式”。你为自己的业务类型实现 Display 最合适。

1-3 格式化参数也靠这两个 trait 撑着

你平时写的 {:.2}、{:>5}、{:#x} 这类”格式化参数”，其实都建立在 Display 或 Debug 之上：用 {} 时，它们作用于类型的 Display 表示；用 {:?} 时，作用于 Debug 表示。

let v = 3.1415926;
println!("{:.2}", v);    // 3.14，精度：保留两位
println!("{:>6}", "hi"); // "    hi"，右对齐、宽度 6
println!("{:04}", 42);   // 0042，用 0 填充到宽度 4

let n = 27;
println!("{:#x}", n);    // 0x1b，十六进制带前缀

这些修饰符只是”在已有的展示形式上再加工”。所以一个类型若没实现 Display，你用 {} 配 {:.2} 之类也会报错——要么为它实现 Display，要么退回 {:?} 走 Debug。记住这条链路：{} → Display，{:?} → Debug，格式化参数只是叠在它们之上的外衣。

1-4 From：类型转换

From trait 表达”从另一种类型转换而来”，实现后就能用 From::from 或对称的 .into() 做转换。先定义一个目标类型，再实现 From<源类型>：

struct Number {
    value: i32,
}

impl From<i32> for Number {
    fn from(item: i32) -> Self {
        Number { value: item }
    }
}

fn main() {
    let n1 = Number::from(5);
    let n2: Number = 5.into(); // into 与 from 对称
    println!("{} {}", n1.value, n2.value);
}

Number::from(5) 和 5.into() 等价。用 into() 时，因为编译器要靠目标类型推断，常需标类型（如 let n2: Number = ...）。

标准库已经为很多类型实现了 From，开箱即用：

let s: String = String::from("hello"); // From<&str> for String
let n: i32 = i32::from('A');           // From<char> for i32，'A' 是 65

String::from("...") 你早就用过，它背后就是 From<&str>。

1-5 From 在错误传播里的关键作用

第 41 章提过，? 运算符能自动转换错误类型，靠的就是 From。回忆这个例子：

use std::fs::File;
use std::error::Error;

fn open_file() -> Result<File, Box<dyn Error>> {
    let mut f = File::open("hello.txt")?;
    Ok(f)
}

File::open 出错返回 io::Error，但函数声明的错误是 Box<dyn Error>。? 发现类型不符，就调用 From 把 io::Error 转成 Box<dyn Error>。只要目标错误类型实现了 From<源错误类型>，转换就自动发生。

这让你能定义一个”大统一”错误类型，为各种子错误实现 From，? 就全自动归拢，不用手写转换代码。

1-6 一个综合小例子

把三个 trait 用在同一类型上：

use std::fmt;

#[derive(Debug)] // 自动获得 Debug
struct Meter {
    value: f64,
}

impl fmt::Display for Meter {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{} 米", self.value)
    }
}

impl From<f64> for Meter {
    fn from(v: f64) -> Self {
        Meter { value: v }
    }
}

fn main() {
    let m = Meter::from(3.5);
    println!("{}", m);     // 3.5 米（Display）
    println!("{:?}", m);   // Meter { value: 3.5 }（Debug）
    let m2: Meter = 2.0.into();
    println!("{}", m2);    // 2 米
}

同一份数据，{} 给用户看友好形式，{:?} 给开发者看内部结构，.into() 做转换——三个 trait 各司其职。

1-7 给自己的类型同时实现 Debug 和 Display

写库或写结构体时，几乎总该为它实现 Debug（通常直接 #[derive(Debug)] 即可），方便你在 println!("{:?}") 和测试里观察它。Display 则一般需要手写，因为你才有资格决定”展示给用户时该长什么样”。

两者职责不同：Debug 面向开发者，可以暴露内部细节、甚至多行；Display 面向最终用户，应该是一句通顺、好读的话。标准库规定：若类型实现了 Display，通常也应实现 Debug，但反过来不强制。

From 也常常配合错误类型使用：当你为自己的错误类型实现 From<其它错误>，? 就能自动把那种错误转成你的错误，链条顺畅。下面这个例子把三者串起来：

use std::fmt;

#[derive(Debug)] // 开发者视角，直接 derive 即可
struct Point { x: i32, y: i32 }

impl fmt::Display for Point { // 用户视角，手动决定展示形式
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

fn main() {
    let p = Point { x: 1, y: 2 };
    println!("{:?}", p); // 开发者视角
    println!("{}", p);   // 用户视角
}

1-8 From 与 Into 的默契

From 和 Into 是一对好搭档。你只需为类型实现 From<T>，标准库就通过 blanket impl 自动送你一个 Into——也就是说，实现了 From 后，value.into() 立刻可用，不用再写 Into。

struct Meter(u32);
struct Cm(u32);

impl From<Meter> for Cm {
    fn from(m: Meter) -> Self { Cm(m.0 * 100) }
}

let cm: Cm = Meter(3).into(); // 自动得到 Cm(300)

into 的价值在于”调用方决定目标类型”，编译器按你标注的变量类型反推该调哪个 From。它和 ? 的错误转换是同一套机制：? 内部正是靠 From 把各类错误统一转成函数声明的错误类型。

1-9 Debug 的漂亮打印与 dbg! 宏

Debug 除了 #[derive(Debug)] 一键生成，打印时还有两个小技巧。其一是”漂亮打印”：用 {:#?} 而不是 {:?，结构体、枚举会被按层级缩进展开，读起来清爽得多，特别适合嵌套数据结构。

其二是 dbg! 宏——调试时它比 println! 还顺手：dbg!(某表达式) 会打印出文件名、行号、表达式原文和它的值，并返回原值，所以你能把它直接嵌进表达式里而不破坏逻辑：

let x = dbg!(2 + 3); // 终端会打印 [src/main.rs:3] 2 + 3 = 5

再回头看 From：它是 ? 自动转换错误的根基，也是 .into() 的来源。你实现 From<源错误> 后，凡是需要目标错误类型的地方，? 和 into() 都能帮你无缝转过去。三个 trait 串起来就是：用 Debug/Display 把类型看清楚、说清楚，用 From 把错误转清楚。

1-10 给枚举实现 Display 的套路

为结构体实现 Display 你已经见过了，给枚举实现思路完全一样：在 match 里把每个变体都”说成一句人话”。枚举的变体往往携带数据，记得在分支里把数据也展示出来。

use std::fmt;

enum Status {
    Ok,
    Err(String),
}

impl fmt::Display for Status {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Status::Ok => write!(f, "成功"),
            Status::Err(msg) => write!(f, "失败：{msg}"),
        }
    }
}

Debug 这边通常直接 #[derive(Debug)] 就行，连带变体里的数据一起打印，方便排查。Display 才需要你手写，因为它是”给用户看的门面”，该简略还是该详细由你定。

再补一句 From：前面说过实现 From 就免费得到 Into。凡是你的类型之间存在”一个自然转换成另一个”的关系（比如把 Meter 转成 Cm、把底层错误包成上层错误），实现 From 后，调用方用 .into() 或 ? 都能优雅转换，代码一下子干净不少。

1-11 小结

• Debug（可 derive）用 {:?} 打印，给调试看，能暴露内部；
• Display（须手写 fmt）用 {} 打印，给用户看，要整洁；
• From<U> for T 实现后可用 T::from(u) 或 u.into() 转换，Into 自动对称获得；
• 标准库已为常用类型实现 From，如 String::from("...")；
• ? 借助 From 自动转换错误类型，是错误归拢的关键；
• 三者常配合：调试、展示、转换各管一段。

下一章进入函数式三件套的第一件：闭包（Closures）。