如果你刚开始学习 Rust，一定会被这三个家伙搞得晕头转向：它们长得太像了！都使用 {} 作为占位符，语法结构几乎一模一样。但千万别被表象迷惑——它们的目的地和返回值完全不同，适用的场景也天差地别。

今天我们用一个通俗的比喻来彻底搞懂它们。

统一前置：相同的"语法界面"

先说共同点：这三个宏都使用相同的格式化语法。

let name = "Alice";
let age = 25;

// 它们都支持这样的占位符
println!("Name: {}, Age: {}", name, age);
format!("Name: {}, Age: {}", name, age);
write!(f, "Name: {}, Age: {}", name, age);

所以当你在写代码时，真正需要思考的是：这段格式化后的内容，你想让它去哪里？

1. print! / println! —— 大喇叭喊话

行为描述

你拿着大喇叭，直接对着终端屏幕喊话。

技术细节

比喻理解

你走到广场上，直接把内容念给所有人听。念完就没了，没有留下任何纸质记录。你无法"抓住"这段内容，也无法把它传递给其他函数。

代码示例

print!("Hello, ");      // 不换行
println!("World!");      // 自动换行
println!("Name: {}", name);

适用场景

• 调试输出
• 向用户展示运行结果
• 日志输出（简单场景）

2. format! —— 造一张新的纸

行为描述

你拿出一张全新的白纸，把内容工工整整地写在纸上，然后把这张纸交给你。

技术细节

比喻理解

你在书房里写了一封信装在信封里，现在你拥有了一封实体的信（变量）。你可以把这封信存起来、传给别人，或者以后再看。这张纸是全新的，写完后你拿着它，而不是它自己跑到某个地方。

代码示例

let name = "Bob";
let greeting = format!("Hello, {}!", name);
// 现在 greeting 是一个 String 类型，你可以随意使用它
println!("{}", greeting);      // 打印出来
let upper = greeting.to_uppercase();  // 继续处理

内存分配细节

// format! 永远会创建一个新的 String
let s1 = String::from("hello");
let s2 = format!("{} world", s1);  // s1 被复制，s2 是全新的 String

适用场景

• 需要构建一个字符串供后续使用
• 字符串拼接和模板生成
• 当你需要"捕获"格式化结果时

3. write! / writeln! —— 写进指定的本子

行为描述

别人递给你一个特定的本子（或文件、或网络通道），要求你把内容写进他给你的这个本子里。

技术细节

比喻理解

别人递给你一个特定的本子（可能是文件、可能是网络连接、可能是内存缓冲区），你要乖乖地把内容写进这个本子里。写完了，本子还在主人手里，你只是完成了一次"写入"操作，并告诉主人"写好了"或"写失败了"。

代码示例

写入文件

use std::fs::File;
use std::io::Write;

let mut file = File::create("output.txt").unwrap();
write!(file, "Hello, {}!", "World").unwrap();
writeln!(file, "This is on a new line").unwrap();

写入网络连接

use std::net::TcpStream;
use std::io::Write;

let mut stream = TcpStream::connect("127.0.0.1:8080").unwrap();
write!(stream, "GET / HTTP/1.1\r\n\r\n").unwrap();

写入内存缓冲区（Vec）

use std::io::Write;

let mut buffer = Vec::new();
write!(&mut buffer, "Data: {}", 42).unwrap();
println!("{:?}", buffer); // [b'D', b'a', b't', b'a', b':', b' ', b'4', b'2']

关键区别速查表

为什么这个区别很重要？

场景一：实现 Display trait

这是最重要的场景！当你为自己的类型实现 Display trait 时，你必须使用 write!。

use std::fmt;

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

impl fmt::Display for Point {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        // ❌ 错误！不能直接 print!，这会绕过 f 的控制
        // println!("({}, {})", self.x, self.y);

        // ❌ 不推荐！format! 会创建不必要的字符串，浪费内存
        // write!(f, "{}", format!("({}, {})", self.x, self.y));

        // ✅ 正确！直接写入 f
        write!(f, "({}, {})", self.x, self.y)
    }
}

let p = Point { x: 3, y: 4 };
println!("{}", p);  // 输出: (3, 4)

为什么不能用 print!？

因为 Display::fmt 的目的是让调用者决定输出到哪里。如果你用 print!，就强行把输出写死了到屏幕上。调用者可能想把你的类型序列化到文件、网络，或者仅仅想转换成字符串，你的 print! 就破坏了这种灵活性。

为什么尽量不用 format!？

format! 会在堆上分配一个新字符串，这是不必要的开销。write! 直接写入 f 的缓冲区，效率更高。

场景二：日志分级

// 简单场景，直接输出
println!("Debug info: {}", data);

// 需要记录到文件
write!(log_file, "Debug info: {}", data)?;

// 需要构建复杂消息
let message = format!("Error: {} at line {}", error, line);
logger.log(&message);

场景三：性能敏感的场景

// ❌ 低效：多次内存分配
for i in 0..1000 {
    let s = format!("Item: {}", i);
    write!(file, "{}", s)?;
}

// ✅ 高效：直接写入
for i in 0..1000 {
    write!(file, "Item: {}", i)?;
}

深入理解：背后的设计哲学

Rust 的这三个宏体现了三个不同的设计理念：

1. print! —— 副作用优先：它的目的就是产生副作用（显示在屏幕上），不关心返回值。

2. format! —— 值优先：它把格式化结果作为一个值返回，符合 Rust 的值语义思想。

3. write! —— 抽象优先：它基于 trait（Write）抽象，让代码与具体的输出介质解耦，这是 Rust 抽象能力的体现。

常见陷阱

陷阱 1：混淆 println! 和 writeln!

let mut file = File::create("test.txt").unwrap();

// ❌ 错误！println! 只能输出到屏幕
println!(file, "Hello");  // 编译错误

// ✅ 正确！writeln! 写入文件
writeln!(file, "Hello").unwrap();

陷阱 2：忘记处理 write! 的错误

// ⚠️ 不推荐：直接 unwrap 可能导致 panic
write!(file, "data").unwrap();

// ✅ 推荐：使用 ? 操作符或 match
write!(file, "data")?;
// 或
match write!(file, "data") {
    Ok(_) => {},
    Err(e) => eprintln!("Write failed: {}", e),
}

陷阱 3：在热代码路径中使用 format!

// ❌ 性能差：每次循环都分配内存
for item in items {
    let s = format!("Processing: {}", item);
    process(&s);
}

// ✅ 性能好：直接传递引用
for item in items {
    process(item);  // 让 process 内部自己决定如何格式化
}

总结

用一句话概括三者的核心区别：

print! 是喊话，format! 是造纸，write! 是写作业。

当你需要决定用哪个时，问自己三个问题：

1. 我只是想在终端显示吗？ → println!
2. 我需要一个 String 变量来存这个结果吗？ → format!
3. 我需要写入文件、网络，或者实现 Display trait 吗？ → write!

记住：在实现自定义打印逻辑时，你绝对不能用 print!（写死到屏幕），也极其不推荐 format!（浪费内存）。你只能用 write!，乖乖地把内容写进 Rust 递给你的 f（接收器）里。

延伸阅读

• Rust 官方文档：std::fmt
• Rust by Example：print!
• Rust Book：格式化打印
• std::io::Write trait