Rust语言学习之格式化输出

已于 2023-08-02 21:07:32 修改
阅读量1k 收藏 2
点赞数 1
分类专栏： Rust语言学习 文章标签： rust 学习 开发语言
于 2023-07-07 10:26:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a_qwq_a/article/details/131577745
版权

1、初识格式化输出：

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! 后面的参数依次替换。

2、Rust格式化输出的三大金刚：

  • print! 将格式化文本输出到标准输出，不带换行符
  • println! 同上，但是在行的末尾添加换行符
  • format! 将格式化文本输出到 String 字符串
    最常用的是 println! 及 format!，前者常用来调试输出，后者常用来生成格式化的字符串。

3、Rust格式化输出之两大护法：

使用方式跟 print!，println! 很像，但是它们输出到标准错误输出：

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

它们仅应该被用于输出错误信息和进度信息，其它场景都应该使用 print! 系列。

4、{}与{:?}：

与其它语言常用的 %d，%s 不同，Rust 特立独行地选择了 {} 作为格式化占位符，它帮助用户减少了很多使用成本，你无需再为特定的类型选择特定的占位符，统一用 {} 来替代即可，剩下的类型推导等细节只要交给 Rust 去做。
与 {} 类似，{:?} 也是占位符：

  • {} 适用于实现了 std::fmt::Display 特征的类型，用来以更优雅、更友好的方式格式化文本，例如展示给用户；
  • {:?} 适用于实现了std::fmt::Debug特征的类型，用于调试场景。
    在写代码需要调试时，使用 {:?}，剩下的场景，选择 {}。

5、Debug特征：

方便调试，大多数 Rust 类型都实现了 Debug 特征或者支持派生该特征：

#[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特征后，才能进行输出。

6、Display特征：

与大部分类型实现了 Debug 不同，实现了 Display特征的 Rust 类型并没有那么多，往往需要我们自定义想要的格式化方式。
实现Display的三种方法：

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

①、使用{:#?}：

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

// {:?}
[1, 2, 3], Person { name: "sunface", age: 18 }

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

因此对于 Display 不支持的类型，可以考虑使用 {:#?} 进行格式化。

②、为自定义类型实现 Display 特征：

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

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 特征中的 fmt 方法，即可为自定义结构体 Person 添加自定义输出：

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

③、为外部类型实现 Display 特征：

在 Rust 中，无法直接为外部类型实现外部特征，但是可以使用newtype解决此问题：

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 特征，即可进行格式化输出：

数组是：[1, 2, 3]

7、位置参数：

除了按照依次顺序使用值去替换占位符之外，还能让指定位置的参数去替换某个占位符，例如 {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
}

8、具名参数：

除了指定位置外，还可以为参数指定名称：

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"
}

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

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

9、格式化参数：

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

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

上面代码只输出小数点后两位。

Rust 中的格式化参数：

①、宽度：

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

a、字符串填充：

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

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);
}
b、数字填充:符号和 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我是Sunface孙飞";
    // 保留字符串前三个字符 => 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
}
⑥、指针地址：
let v= vec![1, 2, 3];
println!("{:p}", v.as_ptr()) // => 0x600002324050
⑦、转义：

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

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

    // 下面代码会报错，因为占位符{}只有一个右括号}，左括号被转义成字符串的内容
    // println!(" {{ Hello } ");
    // 也不可使用 '\' 来转义 "{}"
    // println!(" \{ Hello \} ")
}
爱折腾的捣蛋鬼
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Rust语言学习万字指南！.md
03-19
这是一份全面的Rust语言学习指南,详细介绍了Rust的开发环境、语法、属性、内存管理和Unicode等方面的知识。主要内容包括: 1. Rust开发环境指南 - Rust代码执行流程 - Rust安装方法 - Rust编译和运行命令 - ...
Rust 格式化输出
Bruce__taotao的博客
02-09 1993
Rust学习系列-本文根据教程学习Rust的格式化输出，包括fmt::Debug等。
Rust中的格式化输出
z974656361的专栏
06-07 6905
Rust中的格式化输出格式化输出println的使用fmt::Debug的使用fmt::Display的使用一个list类型的对象的自定义格式化输出format的使用 格式化输出 rust中由一些宏(macro)负责输出，这些宏定义在std::fmt中，下面是一些常用的宏: format!()：向字符串中输出格式化字符串。 print()!：向标准输出打印字符串。 println()!：向标准输出打印字符串，同时会打印一个换行符。 eprint()!：向标准错误打印字符串。 eprintln()!：向标准
[rust-007]rust的println!函数的各种用法
大数据和机器学习研究
08-19 7971
println!是宏。 println!的第一个参数，是格式化字符串，其他参数要放在这个字符串里打印出来。 第一种情况，格式化字符串，是纯粹的字符串： println!("Hello World"); // 输出结果如下: // Hello World 第二种情况，格式化字符串里有替换占位符"{}"，从第二个参数开始，各参数逐个替换格式化字符串的占位符： println!("{} World {} {}", "Hello", true, 42); //输出结果: //Hello World t
【工作记录】保留除法运算小数位数的问题
迷途小书童的博客
08-25 358
float price=(float) 625.2135; DecimalFormat decimalFormat=new DecimalFormat("0.00");//这里有几个0就保留几位，如果小数不足位,会以0补足. String price1=decimalFormat.format(price);//format 返回的是字符串 System.out.println(price1); ...
使用Rust从零写操作系统 (3) —— 格式化输出
xiangxianghehe的博客
06-19 1992
本小节代码对应 commit ：1b493d3bcaca2d41123adcaaa7174daaa26852a6 概要 通过上一章，我们已经可以在屏幕上打印简单的字符串了。但是这并不足够，本章我们将实现 rust 中最经典的宏： println! ，以便于后续的调试输出。这需要我们对 rust 的一些特性有一定的了解： 宏的使用。 trait 的特性。 打印字符和字符串 在一个文件内实现过多...
rust println!格式化输出
小码农的博客
05-09 923
格式 格式说明 样例代码 输出效果 {} 将任何实现了std::fmt::Display trait的类型格式化为字符串输出 println!("Hello, {}!", "world"); Hello, world! {:?} 以调试模式打印任何实现了std::fmt::Debug trait的类型 println!("Debug: {:?}", [1, 2, 3]); Debug: [1, 2, 3] {:#?} 在调试模式下将
rust 格式化输出
qq_35435999的博客
06-29 2265
rust print 格式化
Rust格式化输出
klt2006116357的博客
12-05 857
Rust格式化输出
将浮点数四舍五入，取小数点后2位
wangygang的专栏
01-15 2081
function changeTwoDecimal(x) {             var f_x = parseFloat(x);             if (isNaN(f_x)) {                               return false;             }             f_x = Math.round(f_x * 10
【Rust每周一知】神奇的 parse
Rust语言学习交流
12-12 2365
Rust 中，有一个神奇的函数 parse。它定义在 std:str 下面。因为字符串中可以存放各种信息（如果加上序列化的话），对字符串的解析就显得特别重要，而且很通用。于是 Rust ...
格式化 Rust 代码
06-28
生锈快速开始在稳定工具链上在 Nightly 工具链上从源安装用法运行cargo fmt直接运行rustfmt验证码已格式化退出代码配置 Rustfmtrustfmt 版本的差异子模块的默认格式配置选项的构建Rust 的版本限制从你的编辑器运行 ...
Rust语言学习教程及示例代码
最新发布
03-06
Rust语言学习教程及示例代码
rustformat:Rust 源码格式化工具
06-09
PSA：我已经停止在这个项目上工作，专注... rustformat 代码使用 rustformat 进行格式化，但除此之外我不能保证保留语义。 例子： fn main() { let _immutable_binding = 1; let mut mutable_binding =1; println
Rust语言学习路径及各阶段实例
02-06
通过这些示例，你可以逐步了解和掌握Rust的...随着学习的深入，还可以探索更多的标准库和第三方库，以及Rust在系统编程、网络编程、Web开发等方面的实践应用。同时，关注官方文档以获取最新特性更新和最佳实践指南。
Rust声明宏println剖析
jiangjkd的专栏
12-01 1176
当我们用cargo new XXX创建一个rust项目时，默认都会生成main.rs文件，里面的代码就是println!("Hello, world!");用于向控制台打印Hello world。因此，我打算通过标准库源码对println宏的实现机制进行深入剖析。 ...
Rust格式化输出：println、format格式化参数详解
编程架构三分天下：分层、分治、分时序。
04-05 3306
println!("0b{:b}", 0b11_01); // 二进制 println!("0o{:o}", 10); // 八进制 println!("0x{:x}", 0xFF); // 十六进制(小写) println!("0x{:X}", 0xFF); // 十六进制(大写) println!("{:p}", &100); // 打印引用或者指针所指对象的内存地址 println!("{:e}", 1000f32); // 1e3，科学计数(小写)...
Rust之println!
yzpbright的博客
07-08 816
fn main() { println!("Hello, world!"); } 输出 Hello, world! 到终端（控制台）。 与java的 println 很像，有一点不同的是 println后面有一个叹号! 这在 rust 中叫做 宏（macro）。 每行 rust 语句和java类似，以 ; 分号结束。 ...
rust 格式化输出hashmap类型
02-06
可以使用 `format!` 或 `write!` 来格式化输出 `HashMap` 类型。 例如： ```rust use std::collections::HashMap; let mut map = HashMap::new(); map.insert("x", 1); map.insert("y", 2); // 使用 format! 宏 println!("{:?}", map); // 使用 write! 宏 let mut output = String::new(); write!(output, "{:?}", map).unwrap(); println!("{}", output); ``` 输出结果如下： ```text {"x": 1, "y": 2} {"x": 1, "y": 2} ``` 如果你想要按照某种特定的格式输出，可以自定义格式化输出的代码。 例如： ```rust use std::fmt; struct Pair(i32, i32); impl fmt::Display for Pair { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "({}, {})", self.0, self.1) } } let pair = Pair(1, 2); println!("{}", pair); ``` 输出结果如下： ```text (1, 2) ``` 关于格式化输出，你可以参考 Rust 官方文档中的 [格式化输出章节](https://doc.rust-lang.org/std/fmt/)。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值