Published on

Rust入门笔记(九)

Authors
  • avatar
    Name
    Et cetera
    Twitter

Rust 的格式化输出

除了使用 {} 情况下的格式化输出

println!() & print!() & format!()

核心用途:

  • print! 将格式化文本输出到标准输出,不带换行符
  • println! 同上,但是在行的末尾添加换行符
  • format! 将格式化文本输出到 String 字符串
println!("Hello");                 // => "Hello"
println!("Hello, {}!", "world");   // => "Hello, world!"
println!("The number is {}", 1);   // => "The number is 1"
println!("{:?}", (3, 4));          // => "(3, 4)"
println!("{value}", value=4);      // => "4"
println!("{} {}", 1, 2);           // => "1 2"
println!("{:04}", 42);             // => "0042" with leading zeros

println! 宏接受的是可变参数,第一个参数是一个字符串常量,它表示最终输出字符串的格式,包含其中形如 {} 的符号是占位符,会被 println! 后面的参数依次替换

最常用的主要便是 println!() 和 format!(),前者常用来调试输出,后者常用来生成格式化的字符串:

fn main() {
    let s = "hello";
    println!("{}, world", s);
    let s1 = format!("{}, world", s);
    print!("{}", s1);
    print!("{}\n", "!");
}

输出结果:

hello, world
hello, world!

eprint!() & eprintln!()

使用方式跟 print!(),println!() 很像,但是它们输出到标准错误输出:

eprintln!("Error: Could not complete task");

{} 与 {:?}: Rust 中的 %d %s %f...

与其它语言常用的 %d,%s 不同,Rust 特立独行地选择了 {} 作为格式化占位符(说到这个,有点想吐槽下,Rust 中自创的概念其实还挺多的,真不知道该夸奖还是该吐槽-,-),事实证明,这种选择非常正确,它帮助用户减少了很多使用成本,你无需再为特定的类型选择特定的占位符,统一用 {} 来替代即可,剩下的类型推导等细节只要交给 Rust 去做.

同样,{:?} 也是占位符(需要调试的时候就是用它):

  • {} 适用于实现了 std::fmt::Display 特征的类型,用来以更优雅、更友好的方式格式化文本
  • {:?} 适用于实现了 std::fmt::Debug 特征的类型,用于调试场景

Debug trait

事实上,为了方便我们调试,大多数 Rust 类型都实现了 Debug trait 或者支持派生该 trait:

#[derive(Debug)]
struct Person {
    name: String,
    age: u8
}

fn main() {
    let i = 3.1415926;
    let s = String::from("hello");
    let v = vec![1, 2, 3];
    let p = Person{name: "etcetera".to_string(), age: 18};
    println!("{:?}, {:?}, {:?}, {:?}", i, s, v, p);
}

对于数值、字符串、数组,可以直接使用 {:?} 进行输出,但是对于 Struct,需要派生 Debug trait 后,才能进行输出

Display trait

与大部分类型实现了 Debug 不同,实现了 Display trait 的 Rust 类型并没有那么多,往往需要我们自定义想要的格式化方式:

fn main() {
  let i = 3.1415926;
  let s = String::from("hello");
  let v = vec![1, 2, 3];
  let p = Person {
      name: "etcetera".to_string(),
      age: 18,
  };
  println!("{}, {}, {}, {}", i, s, v, p);
}

运行后可以看到 v 和 p 都无法通过编译,因为没有实现 Display trait,但是你又不能像派生 Debug 一般派生 Display,只能另寻他法:

  • 使用 {:?} 或 {:#?}
  • 为自定义类型实现 Display trait
  • 使用 newtype 为外部类型实现 Display trait

使用{:#?} 与 {:?}

{:#?} 与 {:?} 几乎一样,唯一的区别在于它能更优美地输出内容：

{:?} 用于输出一行,{:#?} 用于输出多行,比如:

# {:?}
[1, 2, 3], Person { name: "etcetera", age: 18 }

# {:#?}
[
    1,
    2,
    3,
], Person {
    name: "etcetera",
}

因此对于 Display 不支持的类型,可以考虑使用 {:#?} 进行格式化,虽然理论上它更适合进行调试输出

为自定义类型实现 Display trait

如果你的类型是定义在当前作用域中的,那么可以为其实现 Display trait,即可用于格式化输出:

struct Person {
    name: String,
    age: u8,
}

use std::fmt;
impl fmt::Display for Person {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "大佬在上,请受我一拜,小弟姓名{},年芳{},家里无田又无车,生活苦哈哈",
            self.name, self.age
        )
    }
}

fn main() {
    let p = Person {
        name: "etcetera".to_string(),
        age: 18,
    };
    println!("{}", p);
}

如上所示,只要实现 Display trait 中的 fmt 方法,即可为自定义结构体 Person 添加自定义输出:

大佬在上,请受我一拜,小弟姓名etcetera,年芳18,家里无田又无车,生活苦哈哈

为外部类型实现 Display trait

如果你的类型是定义在外部作用域中的,那么就无法为其实现 Display trait,因此需要使用 newtype 来为其实现 Display trait:

struct Array(Vec<i32>);

use std::fmt;
impl fmt::Display for Array {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "数组是：{:?}", self.0)
    }
}
fn main() {
    let arr = Array(vec![1, 2, 3]);
    println!("{}", arr);
}

Array 就是我们的 newtype,它将想要格式化输出的 Vec 包裹在内,最后只要为 Array 实现 Display trait,即可进行格式化输出:

数组是：[1, 2, 3]

位置参数

除了按照依次顺序使用值去替换占位符之外,还能让指定位置的参数去替换某个占位符,例如 {1},表示用第二个参数替换该占位符(索引从 0 开始):

fn main() {
    println!("{}{}", 1, 2); // => "12"
    println!("{1}{0}", 1, 2); // => "21"
    // => Alice, this is Bob. Bob, this is Alice
    println!("{0}, this is {1}. {1}, this is {0}", "Alice", "Bob");
    println!("{1}{}{0}{}", 1, 2); // => 2112
}

具名参数

还可以为参数指定名称:

fn main() {
    println!("{argument}", argument = "test"); // => "test"
    println!("{name} {}", 1, name = 2); // => "2 1"
    println!("{a} {c} {b}", a = "a", b = 'b', c = 3); // => "a 3 b"
}

需要注意的是: 带名称的参数必须放在不带名称参数的后面,例如下面代码将报错:

fn main() {
    println!("{abc} {1}", abc = "def", 2);
}

error: positional arguments cannot follow named arguments
 --> src/main.rs:4:36
   |
 4 | println!("{abc} {1}", abc = "def", 2);
   |                             -----  ^ positional arguments must be before named arguments
   |                             |
   |                             named argument

格式化参数

格式化输出,意味着对输出格式会有更多的要求,例如只输出浮点数的小数点后两位:

fn main() {
    let v = 3.1415926;
    // Display => 3.14
    println!("{:.2}", v);
    // Debug => 3.14
    println!("{:.2?}", v);
}

上面代码只输出小数点后两位.同时我们还展示了 {} 和 {:?} 的用法,后面如无特殊区别,就只针对 {} 提供格式化参数说明.

宽度

宽度用来指示输出目标的长度,如果长度不够,则进行填充和对齐:

字符串填充

字符串格式化默认使用空格进行填充,并且进行左对齐

fn main() {
    //-----------------------------------
    // 以下全部输出 "Hello x    !"
    // 为"x"后面填充空格,补齐宽度5
    println!("Hello {:5}!", "x");
    // 使用参数5来指定宽度
    println!("Hello {:1$}!", "x", 5);
    // 使用x作为占位符输出内容,同时使用5作为宽度
    println!("Hello {1:0$}!", 5, "x");
    // 使用有名称的参数作为宽度
    println!("Hello {:width$}!", "x", width = 5);
    //-----------------------------------

    // 使用参数5为参数x指定宽度,同时在结尾输出参数5 => Hello x    !5
    println!("Hello {:1$}!{}", "x", 5);
}

数字填充: 符号和 0

数字格式化默认也是使用空格进行填充,但与字符串左对齐不同的是,数字是右对齐:

fn main() {
    // 宽度是5 => Hello     5!
    println!("Hello {:5}!", 5);
    // 显式的输出正号 => Hello +5!
    println!("Hello {:+}!", 5);
    // 宽度5,使用0进行填充 => Hello 00005!
    println!("Hello {:05}!", 5);
    // 负号也要占用一位宽度 => Hello -0005!
    println!("Hello {:05}!", -5);
}

对齐

fn main() {
    // 以下全部都会补齐5个字符的长度
    // 左对齐 => Hello x    !
    println!("Hello {:<5}!", "x");
    // 右对齐 => Hello     x!
    println!("Hello {:>5}!", "x");
    // 居中对齐 => Hello   x  !
    println!("Hello {:^5}!", "x");

    // 对齐并使用指定符号填充 => Hello x&&&&!
    // 指定符号填充的前提条件是必须有对齐字符
    println!("Hello {:&<5}!", "x");
}

精度

fn main() {
    let v = 3.1415926;
    // 保留小数点后两位 => 3.14
    println!("{:.2}", v);
    // 带符号保留小数点后两位 => +3.14
    println!("{:+.2}", v);
    // 不带小数 => 3
    println!("{:.0}", v);
    // 通过参数来设定精度 => 3.1416,相当于{:.4}
    println!("{:.1$}", v, 4);

    let s = "hi我是 etcetera";
    // 保留字符串前三个字符 => hi我
    println!("{:.3}", s);
    // {:.*}接收两个参数,第一个是精度,第二个是被格式化的值 => Hello abc!
    println!("Hello {:.*}!", 3, "abcdefg");
}

进制

可以使用 # 号来控制数字的进制输出:

  • #b, 二进制
  • #o, 八进制
  • #x, 小写十六进制
  • #X, 大写十六进制
  • x, 不带前缀的小写十六进制
fn main() {
    // 二进制 => 0b11011!
    println!("{:#b}!", 27);
    // 八进制 => 0o33!
    println!("{:#o}!", 27);
    // 十进制 => 27!
    println!("{}!", 27);
    // 小写十六进制 => 0x1b!
    println!("{:#x}!", 27);
    // 大写十六进制 => 0x1B!
    println!("{:#X}!", 27);

    // 不带前缀的十六进制 => 1b!
    println!("{:x}!", 27);

    // 使用0填充二进制,宽度为10 => 0b00011011!
    println!("{:#010b}!", 27);
}

指数

fn main() {
    println!("{:2e}", 1000000000); // => 1e9
    println!("{:2E}", 1000000000); // => 1E9
}

指针地址

fn main() {
  let v= vec![1, 2, 3];
  println!("{:p}", v.as_ptr()) // => 0x600002324050
}

转义

有时需要输出 { 和 },但这两个字符是特殊字符,需要进行转义:

fn main() {
    // "{{" 转义为 '{'   "}}" 转义为 '}'   "\"" 转义为 '"'
    // => Hello "{World}"
    println!(" Hello \"{{World}}\" ");

    // 下面代码会报错,因为占位符{}只有一个右括号},左括号被转义成字符串的内容
    // println!(" {{ Hello } ");
    // 也不可使用 '\' 来转义 "{}"
    // println!(" \{ Hello \} ")
}

在格式化字符串时捕获环境中的值(Rust 1.58 新增)

在以前,想要输出一个函数的返回值:

fn get_person() -> String {
    String::from("etcetera")
}
fn main() {
    let p = get_person();
    println!("Hello, {}!", p);                // implicit position
    println!("Hello, {0}!", p);               // explicit index
    println!("Hello, {person}!", person = p);
}

现在可以这样:

fn get_person() -> String {
    String::from("etcetera")
}
fn main() {
    let person = get_person();
    println!("Hello, {person}!");
}

甚至还可以将环境中的值用于格式化参数:

fn main() {
  let (width, precision) = get_format();
  for (name, score) in get_scores() {
    println!("{name}: {score:width$.precision$}");
  }
}

但也有局限,它只能捕获普通的变量,对于更复杂的类型(例如表达式),可以先将它赋值给一个变量或使用以前的 name = expression 形式的格式化参数。 目前除了 panic! 外,其它接收格式化参数的宏,都可以使用新的特性。对于 panic! 而言,如果还在使用 2015 版本 或 2018 版本,那 panic!("{ident}") 依然会被当成 正常的字符串来处理,同时编译器会给予 warn 提示。而对于 2021 版本 ,则可以正常使用:

fn get_person() -> String {
    String::from("etcetera")
}
fn main() {
    let person = get_person();
    panic!("Hello, {person}!");
}
View on GitHub