rust学习-rust中的格式化打印

一、基本打印宏
- [1. println!](#1. println!)
- [2. print!](#2. print!)
- [3. eprintln!](#3. eprintln!)
- [4. eprint! 宏](#4. eprint! 宏)
二、格式化字符串
- [1. 基本格式化](#1. 基本格式化)
- [2. 带有位置参数的格式化](#2. 带有位置参数的格式化)
- [3. 命名参数](#3. 命名参数)
- [4. 格式化选项](#4. 格式化选项)
[三、使用 format! 宏](#三、使用 format! 宏)
四、调试格式化
五、自定义格式化

一、基本打印宏

1. println!

println! 宏用于打印格式化的字符串，并自动在末尾添加换行符

rust 复制代码

println!(格式字符串, 参数1, 参数2, ...);

rust 复制代码

fn main() {
    println!("Hello, World!");
    let name = "XiaoMing";
    let age = 30;
    println!("Name: {}, Age: {}", name, age);
}

格式字符串中使用 {} 作为占位符，实际的参数值会替换这些占位符
参数的类型必须与格式字符串中指定的占位符兼容

2. print!

print! 宏类似于 println!，但它不会在末尾添加换行符

rust 复制代码

print!(格式字符串, 参数1, 参数2, ...);

rust 复制代码

fn main() {
    print!("Hello, ");
    print!("World!");
    // 输出：Hello, World!
}

使用 print! 宏时，多个连续的 print! 调用不会自动换行，直到遇到 println! 或手动添加换行符

3. eprintln!

eprintln! 宏用于将格式化的字符串打印到标准错误流（stderr）

rust 复制代码

eprintln!(格式字符串, 参数1, 参数2, ...);

rust 复制代码

fn main() {
    eprintln!("This is an error message.");
}

标准错误流常用于输出错误信息，与标准输出流（stdout）分开，这在需要区分正常输出和错误输出时非常有用

4. eprint! 宏

eprint! 宏的语法与 print! 类似：

rust 复制代码

eprint!(格式字符串, 参数1, 参数2, ...);

rust 复制代码

fn main() {
    eprint!("This is an error message.");
}

eprint! 不会自动添加换行符，你需要手动添加 \n 来换行

二、格式化字符串

1. 基本格式化

rust 复制代码

fn main() {
    let number = 42;
    println!("The number is: {}", number);
}

{} 是格式占位符，会被相应的参数替换

2. 带有位置参数的格式化

可以通过指定${index}来指定参数的位置

rust 复制代码

fn main() {
    let name = "XiaoMing";
    let age = 25;
    println!("{} is {} years old.", name, age);
    println!("{1} is {0} years old.", age, name);
}

默认情况下，参数按照在格式字符串中出现的顺序进行替换
可以通过 {index} 显式指定参数的位置

3. 命名参数

可以为参数命名，从而使代码更易读

rust 复制代码

fn main() {
    let name = "Charlie";
    let age = 35;
    println!("{name} is {age} years old.");
}

这种方式在参数较多时特别有用，可以明确每个参数对应的位置

4. 格式化选项

可以为格式占位符添加格式化选项，以控制输出的格式。

rust 复制代码

fn main() {
    let pi = 3.1415926535;
    println!("Pi is approximately {:.2}", pi); // 输出小数点后两位
    println!("Hex: {:x}", 255); // 以十六进制输出
}

:.2 表示浮点数保留两位小数。
:x 表示以十六进制格式输出整数。

三、使用 format! 宏

format! 宏类似于 println!，但它返回一个 String 而不是打印到控制台

rust 复制代码

let s = format!(格式字符串, 参数1, 参数2, ...);

rust 复制代码

fn main() {
    let name = "Diana";
    let age = 40;
    let message = format!("{} is {} years old.", name, age);
    println!("{}", message);
}

format! 宏适用于需要将格式化字符串存储在变量中，而不是立即打印的情况

四、调试格式化

{:#?} 和 {:?} 用于调试目的，可以打印出数据结构的详细信息

rust 复制代码

fn main() {
    let vec = vec![1, 2, 3, 4, 5];
    println!("Vector: {:?}", vec);
    println!("Vector with pretty print:\n{:#?}", vec);
}

{:?} 提供简化的调试输出
{:#?} 提供更详细的、带缩进的输出，适用于复杂数据结构

五、自定义格式化

可以通过实现 std::fmt::Display 和 std::fmt::Debug trait 来为自定义类型定义格式化行为

rust 复制代码

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

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

impl std::fmt::Debug for Point {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("Point")
            .field("x", &self.x)
            .field("y", &self.y)
            .finish()
    }
}

fn main() {
    let p = Point { x: 10, y: 20 };
    println!("Display: {}", p);
    println!("Debug: {:?}", p);
}

Display trait 用于定义类型的字符串表示，适用于用户友好的输出
Debug trait 用于调试目的，提供详细的内部结构信息