Rust格式化输出宏

🕗 发布于 2024-09-26 02:39 rust 算法 开发语言

我们编写程序的目的就是对输入进行处理，然后将处理结果反馈给用户，对于初学者一般是将处理结果直接显示在屏幕上。

Rust语言的打印操作主要是通过在std::fmt中定义一系列宏来处理。主要包括：

format!：将格式化文本存入字符串。
print!：与format!类似，但是把文本输出到控制台（io::stdout）。
println!：与print!类似，但是输出结果末尾会追加换行符。
eprint!：与format!类似，但是把文本输出到标准错误（std::stderr）。
eprintln!：与eprint!类似，但是输出结果末尾会追加换行符。
write!：与format!类似，但是把文本输出到&mut io::Write。
writeln!：与write!类似，但是输出结果末尾会追加换行符。

Rust中的主要输出靠宏print!或println!，两者唯一不同的地方在于print!会将要输出的内容打印到控制台，println!会在输出的内容打印到控制台后进行换行。

print!接受的是可变参数，第一个参数是一个字符串常量，它表示最终输出的字符串的格式，第一个参数可以看到类似于{}的符号，它相当于占位符，可以在最终的结果中按照指定的规则进行替换。比如：

print!("{}{}",1,2);             //输出："12"

其实我们已经多次接触过输出print!了，已经知道了可以用它来输出字符串、数字等，其实还有很多格式化输出的方式。下面一起来了解一下。

4.2.1 默认输出

默认输出就是直接输出字符串常量。比如：

println("hello wolrd");  //输出字符串hello wolrd

4.2.2 通配符{}

在字符串字面量中使用{}通配符代指即将输出的值，后面依次对应输出的值。如果有多个值，则中间需使用英文逗号“,”分隔。示例代码如下：

println!("今天是 {} 年 {} 月 {} 日", 2022, 6, 18); //输出：今天是 2022 年 6 月 18 日

4.2.3 通配符和位置

输出时可以在通配符{}中添加要输出值的位置（从0开始），来代指当前要输出哪个位置的值。示例代码如下：

println!("{0} 的平方是 {0}, {0} 的相反数是 {1}", 1, -1);

输出结果如下：

1 的平方是 1, 1 的相反数是 -1

又比如：

fn main() {
    // 按照顺序进行格式化
    // 输出： 10 is a number, 'hello world' is a string
    println!("{} is a number, '{}' is a string", 10, "hello world");

    // 按照索引进行格式化
    // 输出：10 is a number, 'hello world' is a string
    println!("{1} is a number, '{0}' is a string", "hello world", 10);

    // 按照顺序与索引混合进行格式化
    // 没有索引的{}会按照迭代顺序进行格式化
    // 输出：2 1 1 2
    println!("{1} {} {0} {}", 1, 2)
}

输出结果如下：

10 is a number, 'hello world' is a string

10 is a number, 'hello world' is a string

2 1 1 2

又比如：

print!("{1}{0}",1,2);                 //输出：21

print!("{1}{}{0}{}",1,2);             //输出：2112

4.2.4 通配符和命名参数

输出时可以在通配符{}中添加要输出值的命名参数，来代指当前要输出哪个命名参数的值。示例代码如下：

println!("我的名字叫{name}, 今年{age}岁, 喜欢{hobby}", hobby = "打篮球", name = "张三", age = 18);

输出结果如下：

我的名字叫张三, 今年18岁, 喜欢打篮球

又比如：

print!("{arg}",arg = "tyest");      //=>"test"

print!("{name} {}",1, name =2);     //=>"2 1"

print!("{a} {c} {b}",a ="a",b ='b', c=3);       //=>"a 3 b"

需要注意的是，带名字的参数必须放在不带名字的参数的后面，以下例子无法通过编译：

print!("{abc} {1}", abc = "def", 2);

4.2.5 输出不同的进制数

可以在通配符{}中添加不同的符号来实现二进制、八进制、十六进制数的输出。常用符号如表4-5所示。

表4-5 常用符号

格式	说明
{:b}	输出结果转为二进制
{:o}	输出结果转为八进制
{:x}	输出结果转为十六进制（小写）
{:X}	输出结果转为十六进制（大写）
{:e}	科学记数（小写）
{:E}	科学记数（大写）
{:p}	输出指针

（续表）

格式	说明
{:?}	打印Debug
{:+}	如果数值类型是整数，则前置打印+号

还可以添加0，用来在整数格式化时填充宽度，格式说明如表4-6所示。

表4-6 添加0，用来在整数格式化时填充宽度

格式	说明
{:08b}	输出8位二进制数，不足8位使用0填充
{:08o}	输出8位八进制数，不足8位使用0填充
{:016x}	输出8位十六进制数，不足16位使用0填充

还有个#要注意一下，这应该算是一个补充标记符，常与其他字符连用，格式说明如表4-7所示。

表4-7 #与其他字符连用格式说明

格式	说明
{:#b}	在输出的二进制数前添加0b
{:#o}	在输出的八进制数前添加0o
{:#x}	在输出的十六进制数前添加0x（x是小写）
{:#X}	在输出的十六进制数前添加0x（x是小写）
{:#?}	带换行和缩进的Debug打印

示例代码如下：

fn main() { 
     println!("{},{}", 1, 2);  //输出十进制数
     //输出二进制数
     println!("{:b},{:b},{:b}", 0b11_01,0b1100,0b111111111000000001);  
     println!("{:b},{:b}", 8,16); 
     println!("{:b},{:b}", 0xF,0xe);  
     //输出八进制数
     println!("0o{:o}", 10); // 0o12
     println!("{:#o}", 10); // 0o12
     //十六进制小写
     println!("0x{:x}", 0xFF); //0xff
     println!("{:#x}", 0xFF); //0xff
     //十六进制大写
     println!("0x{:X}", 0xFF); // 0xFF
     println!("{:#X}", 0xFF); // 0xFF
}

二进制常数需要以0b开头，十六进制常数需要以0x开头。输出结果如下：

1,2
1101,1100,111111111000000001
1000,10000
1111,1110
0o12
0o12
0xff
0xff
0xFF
0xFF

又比如：

fn main() { 
    let a = 31;
    println!("二进制 {:b}", a);
    println!("八进制 {:o}", a);
    println!("十六进制（小写）{:x}", a);
    println!("十六进制（大写）{:X}", a);

    println!("输出标点 {:+}", 5);

    println!("前置符二进制 {:#b}", a);
    println!("前置符八进制 {:#o}", a);
    println!("前置符十六进制（小写）{:#x}", a);
    println!("前置符十六进制（大写）{:#X}", a);

    println!("二进制8位补零 {:08b}", a);
    println!("八进制8位补零 {:08o}", a);
    println!("十六进制16位补零 {:016b}", a);
}

输出结果如下：

二进制 11111
八进制 37
十六进制(小写) 1f
十六进制(大写) 1F
输出标点 +5
前置符二进制 0b11111
前置符八进制 0o37
前置符十六进制(小写) 0x1f
前置符十六进制(大写) 0x1F
二进制8位补零 00011111
八进制8位补零 00000037
十六进制16位补零 0000000000011111

4.2.6 指定宽度

指定宽度的形式如下。

{:n}：通过数字直接指定宽度，比如{:5}。
{:n$}：通过参数索引指定宽度，比如{:1$}。
{:name$}：通过具名参数指定宽度，比如{:width$}。

需要注意的是，这里指定的是最小宽度，如果字符串不足宽度会进行填充，如果超出并不会截断。示例代码如下：

fn main() {
    // 不足长度5，填充空格
    // 输出: Hello a    !
    println!("Hello {:5}!", "a");

    // 超出长度1，仍然完整输出
    // 输出: Hello abc!
    println!("Hello {:1}!", "abc");

    // 因为未指定索引，所以按照顺序位置引用的是"abc"
    // 通过$符指定了宽度的索引为1，即宽度为5
    // 输出: Hello abc  !
    println!("Hello {:1$}!", "abc", 5);
    // 指定了位置索引为1，使用$符指定了宽度的索引为0，即宽度为5
    // 输出: Hello abc  !
    println!("Hello {1:0$}!", 5, "abc");

    // 通过具名参数指定宽度为5
    // 输出：Hello abc  !
    println!("Hello {:width$}!", "abc", width = 5);
    let width = 5;
    println!("Hello {:width$}!", "abc");
}

输出结果如下：

Hello a    !
Hello abc!
Hello abc  !
Hello abc  !
Hello abc  !
Hello abc  !

4.2.7 填充与对齐

如果不指定对齐方式，Rust会用默认的方式进行填充和对齐。对于非数字，采用的是空格填充左对齐，数字采用的是空格填充右对齐。在格式化字符串内，一般按照“:XF”来排列，其中X表示要填充的字符，F表示对齐方式，有三种对齐方式：<表示左对齐，^表示居中对齐，>表示右对齐。比如“:-<7”，-表示填充字符，<表示左对齐，7表示总宽度是7。

特别要注意的是，有些类型可能不会实现对齐。特别是对于Debug trait，通常不会实现该功能。确保应用填充的一种好方法是格式化输入，再填充此结果字符串以获得输出。示例代码如下：

fn main() {
    // 非数字默认左对齐，空格填充
    assert_eq!(format!("Hello {:7}!", "abc"), "Hello abc    !");
    println!("Hello {:7}!", "abc");

    // 左对齐
    assert_eq!(format!("Hello {:<7}!", "abc"), "Hello abc    !");
    println!("Hello {:<7}!", "abc");

    // 左对齐，使用-填充
    assert_eq!(format!("Hello {:-<7}!", "abc"), "Hello abc----!");
    println!("Hello {:-<7}!", "abc");

    // 右对齐，使用-填充
    assert_eq!(format!("Hello {:->7}!", "abc"), "Hello ----abc!");
    println!("Hello {:->7}!", "abc");

    // 中间对齐，使用-填充
    assert_eq!(format!("Hello {:-^7}!", "abc"), "Hello --abc--!");
    println!("Hello {:-^7}!", "abc");

    // 数字默认右对齐，使用空格填充
    assert_eq!(format!("Hello {:7}!", 7), "Hello       7!");
    println!("Hello {:7}!", 7);

    // 左对齐
    assert_eq!(format!("Hello {:<7}!", 7), "Hello 7      !");
    println!("Hello {:<7}!", 7);

    // 居中对齐
    assert_eq!(format!("Hello {:^7}!", 7), "Hello    7   !");
    println!("Hello {:^7}!", 7);

    // 填充0
    assert_eq!(format!("Hello {:07}!", 7), "Hello 0000007!");
    println!("Hello {:07}!", 7);

    // 负数填充0，负号会占用一位
    assert_eq!(format!("Hello {:07}!", -7), "Hello -000007!");
    println!("Hello {:07}!", -7);
}

assert_eq!用于判断两者是否相等。如果没有报错输出，则说明全部正确。输出结果如下：

Hello abc    !
Hello abc    !
Hello abc----!
Hello ----abc!
Hello --abc--!
Hello       7!
Hello 7      !
Hello    7   !
Hello 0000007!
Hello -000007!

4.2.8 指定小数的精确值

常用的3种指定小数精确值的方式如表4-8所示。

表4-8 常用的3种指定小数精确值的方式

格式	说明
{:.3}	小数点后精确度保留3位（不足补零，多余截断），这种方式精度写死了，不灵活
{1:.0$}	“1”和“.0”分别对应两个数字，一个是精度（小数位数），另一个是要显示的小数。其中，“1”相当于一个占位符，其对应的数字用来指定小数的位数（不足补零，多余截断）。“.0”所对应的数字就是要显示的小数，比如println!("小数保留位数 {1:.0$} ", 3, 0.01);。这种方式比上一种方式灵活，精度值相当于一个变量，可以自由控制
{:.*}	这种格式也对应两个数字，一个是精度（小数位数，不足补零，多余截断），另一个是具体小数。这种格式书写更加简洁

示例代码如下：

fn main() {
    println!("科学记数（小写）{:e}", 100000_f32);
    println!("科学记数（大写）{:E}", 100000_f32);
    println!("小数保留位数 {:.3} ", 0.01);
    println!("小数保留位数 {1:.0$} ", 3, 0.01);
    println!("{}小数保留3位数 {:.*} --- 保留4位数 {:.*} ", 0.01, 3, 0.01, 4, 0.10);//3和0.01是一对

}

输出结果如下：

科学记数（小写）1e5
科学记数（大写）1E5
小数保留位数 0.010
小数保留位数 0.010
0.01小数保留3位数 0.010 --- 保留4位数 0.1000

4.2.9 输出{和}

有时可能在字符串中包含{和}，这里可以通过{{输出{，}}输出}。示例代码如下：

fn main() {
    println!("左边的括号  {{");
    println!("右边的括号  }}");
    println!("全括号  {{}}");
}

输出结果如下：

左边的括号  {
右边的括号  }
全括号  {}

4.2.10 格式化宏format!

格式化的用法和输出的用法基本相同，它的用途是写格式化文本到字符串。上一小节代码的所有println!都可以换成format!，使用format!常用于格式化多个变量为字符串，println则会直接输出到屏幕。比如：

fn main() {
    let mut s = format!("左边的括号  {{");
    println!("{}",s);
    s = format!("右边的括号  }}");
    println!("{}",s);
    println!("{}",format!("全括号  {{}}"));  //把format!写在println!中，更加简洁
}

输出结果如下：

左边的括号  {
右边的括号  }
全括号  {}

又比如：

fn main() {
    let s1="I";
    let s2="love";
    let s3="China";
    let s = format!("{}-{}-{}",s1,s2,s3);
    println!("{}",s);
    println!("{}",format!("{}-{}-{}","I","love","you"));
}

输出结果如下：

I-love-China
I-love-you

原文地址：https://blog.csdn.net/brucexia/article/details/142491881

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：python/爬虫技术/lxml工具介绍/XML和HTML解析
下一篇：三子棋小游戏

@Autowired 和 @Resource思考（注入redisTemplate时发现一些奇怪的现象）
@Autowired 和 @Resource思考（注入redisTemplate时发现一些奇怪的现象）
阅读更多2024-11-16
25浙江省考-28天学行测-Day5 & Day6-判断推理（中）
1、另有他因2、因果倒置3、否定此因4、根本原因5、三圈质疑1、排除他因2、四圈支持1、无论据有结论2、有论据有结论3、质疑论证过程4、严谨逻辑关系5、比例类论证1、解释说明2、增加论据3、断点
阅读更多2024-11-16
Rust 入门指南（零）：安装及 Cargo 管理器
系列第 0 篇，简单介绍了 Rust 的基本安装和配置流程，以及如何通过 Cargo 创建和管理项目。
阅读更多2024-11-16
Centos使用人大金仓ksql
Centos使用人大金仓ksql
阅读更多2024-11-16
多模态大模型简介
多模态大模型是机器学习领域的一个新兴趋势，它结合了文本、图像、音频等多种数据模态，以实现更全面和深入的信息理解和处理。这种模型能够处理跨模态任务，如图像标注、视觉问答、文本到图像的生成等，是人工智能领
阅读更多2024-11-16
javaScript交互补充2（动画函数封装）
如果多个元素都使用这个动画函数，每次都要var 声明定时器，我们可以给不同元素使用不同的定时器（自己用自己的定时器）核心原理：利用js是一门动态语言，可以很方便的给当前对象添加属性。缓动动画就是让元素
阅读更多2024-11-16
【鸿蒙开发】第十五章 H5与端侧交互、Cookies以及Web调试
Web组件支持在应用拦截到页面请求后自定义响应请求能力。开发者通过接口来实现自定义资源请求响应。自定义请求能力可以用于开发者自定义Web页面响应、自定义文件资源响应等场景。Web网页上发起资源加载请求
阅读更多2024-11-16
javaScript交互补充（元素的三大系列）
使用client系列的相关属性来获取元素可视区的相关信息，可以动态的得到该元素的边框大小，元素大小等。返回自身包括padding，内容区宽度，不含边框，返回数值不带单位。返回自身包括padding，内
阅读更多2024-11-16
django 过滤器的执行
默认情况下，会执行，特别是如果在中配置了它，或者没有禁用它。禁用过滤器：可以通过在APIView中设置来禁用过滤器，避免执行。手动调用过滤器：如果需要，你可以在视图中手动调用来过滤查询集。自定义过滤器
阅读更多2024-11-16
在Ubuntu 24.04 LTS上安装飞桨PaddleX
首先，请运行“ubuntu-drivers devices”命令列出当前可用的硬件设备，确保Ubuntu 24.04.1 LTS已发现安装在桌面计算机中的英伟达显卡，如下图所示。是基于飞桨框架构建的一
阅读更多2024-11-16

Rust格式化输出宏

4.2.1 默认输出

4.2.2 通配符{}

4.2.3 通配符和位置

4.2.4 通配符和命名参数

4.2.5 输出不同的进制数

4.2.6 指定宽度

4.2.7 填充与对齐

4.2.8 指定小数的精确值

4.2.9 输出{和}

4.2.10 格式化宏format!

相关文章