格式化输出
此笔记记录于Rust Course,大多数为其中的摘要,少数为笔者自己的理解
rust
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
print!,println!,format!
print!
将格式化文本输出到标准输出,不带换行符println!
同上,但是在行的末尾添加换行符format!
将格式化文本输出到String
字符串
rust
fn main() {
let s = "hello";
println!("{}, world", s);
let s1 = format!("{}, world", s);
print!("{}", s1);
print!("{}\n", "!");
}
eprint!,eprintln!
除了三大金刚外,还有两大护法,使用方式跟 print!
,println!
很像,但是它们输出到标准错误输出:
rust
eprintln!("Error: Could not complete task")
它们仅应该被用于输出错误信息和进度信息,其它场景都应该使用 print!
系列
{}
统一用 {}
来替代即可,剩下的类型推导等细节只要交给 Rust 去做。
与 {}
类似,{:?}
也是占位符:
{}
适用于实现了std::fmt::Display
特征的类型,用来以更优雅、更友好的方式格式化文本,例如展示给用户{:?}
适用于实现了std::fmt::Debug
特征的类型,用于调试场景
Debug 特征
rust
#[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: "sunface".to_string(), age: 18};
println!("{:?}, {:?}, {:?}, {:?}", i, s, v, p);
}
对于数值、字符串、数组,可以直接使用 {:?}
进行输出,但是对于结构体,需要派生Debug
特征后,才能进行输出,总之很简单。
Display 特征
与大部分类型实现了 Debug
不同,实现了 Display
特征的 Rust 类型并没有那么多,往往需要我们自定义想要的格式化方式:
rust
let i = 3.1415926;
let s = String::from("hello");
let v = vec![1, 2, 3];
let p = Person {
name: "sunface".to_string(),
age: 18,
};
println!("{}, {}, {}, {}", i, s, v, p);
运行后可以看到 v
和 p
都无法通过编译,因为没有实现 Display
特征,但是你又不能像派生 Debug
一般派生 Display
,只能另寻他法:
- 使用
{:?}
或{:#?}
- 为自定义类型实现
Display
特征 - 使用
newtype
为外部类型实现Display
特征
下面来一一看看这三种方式。
{:#?}
与 {:?}
几乎一样,唯一的区别在于它能更优美地输出内容:
rust
// {:?}
[1, 2, 3], Person { name: "sunface", age: 18 }
// {:#?}
[
1,
2,
3,
], Person {
name: "sunface",
}
因此对于 Display
不支持的类型,可以考虑使用 {:#?}
进行格式化,虽然理论上它更适合进行调试输出。
为自定义类型实现 Display 特征
rust
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: "sunface".to_string(),
age: 18,
};
println!("{}", p);
}
为外部类型实现 Display 特征
在 Rust 中,无法直接为外部类型实现外部特征,但是可以使用newtype
解决此问题:
rust
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
特征,即可进行格式化输出
位置参数
rust
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
}
具名参数
rust
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"
}
需要注意的是:带名称的参数必须放在不带名称参数的后面
格式化参数
输出小数点后两位
rust
fn main() {
let v = 3.1415926;
// Display => 3.14
println!("{:.2}", v);
// Debug => 3.14
println!("{:.2?}", v);
}
宽度
1)字符串填充
rust
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);
}
2)数字填充:符号和 0
rust
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);
}
对齐
rust
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");
}
精度
rust
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 我是 Sunface 孙飞";
// 保留字符串前三个字符 => hi 我
println!("{:.3}", s);
// {:.*}接收两个参数,第一个是精度,第二个是被格式化的值 => Hello abc!
println!("Hello {:.*}!", 3, "abcdefg");
}
进制
rust
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);
}
#b
, 二进制#o
, 八进制#x
, 小写十六进制#X
, 大写十六进制x
, 不带前缀的小写十六进制
指数
rust
fn main() {
println!("{:2e}", 1000000000); // => 1e9
println!("{:2E}", 1000000000); // => 1E9
}
指针地址
rust
let v= vec![1, 2, 3];
println!("{:p}", v.as_ptr()) // => 0x600002324050
转义
rust
fn main() {
// "{{" 转义为 '{' "}}" 转义为 '}' "\"" 转义为 '"'
// => Hello "{World}"
println!(" Hello \"{{World}}\" ");
// 下面代码会报错,因为占位符{}只有一个右括号},左括号被转义成字符串的内容
// println!(" {{ Hello } ");
// 也不可使用 '\' 来转义 "{}"
// println!(" \{ Hello \} ")
}
在格式化字符串时捕获环境中的值
rust 1.58 新增
rust
fn get_person() -> String {
String::from("sunface")
}
fn main() {
let person = get_person();
println!("Hello, {person}!");
}