Merge pull request #341 from JesseAtSZ/patch-7

Update formatted-output.md

book/contents/advance/formatted-output.md

@@ -13,16 +13,16 @@ println!("{} {}", 1, 2);           // => "1 2"
 println!("{:04}", 42);             // => "0042" with leading zeros
 ```
 
-可以看到`println!`宏接受的是可变参数，第一个参数是一个字符串常量，它表示最终输出字符串的格式, 包含其中形如`{}`的符号是**占位符**, 会被`println!`后面的参数依次替换。
+可以看到 `println!` 宏接受的是可变参数，第一个参数是一个字符串常量，它表示最终输出字符串的格式，包含其中形如 `{}` 的符号是**占位符**，会被 `println!` 后面的参数依次替换。
 
-##  `print!`, `println!`, `format!`
+##  `print!`，`println!`，`format!`
 它们是 Rust 中用来格式化输出的三大金刚，用途如下：
 
-- `print!`, 将格式化文本输出到标准输出，不带换行符
-- `println!`, 同上，但是在行的末尾添加换行符
-- `format!`, 将格式化文本输出到`String`字符串
+- `print!` 将格式化文本输出到标准输出，不带换行符
+- `println!` 同上，但是在行的末尾添加换行符
+- `format!` 将格式化文本输出到 `String` 字符串
 
-在实际项目中，最常用的是`println!`及`format!`，前者常用来调试输出，后者用来生成格式化的字符串:
+在实际项目中，最常用的是 `println!` 及 `format!`，前者常用来调试输出，后者常用来生成格式化的字符串：
 ```rust
 fn main() {
     let s = "hello";
@@ -33,14 +33,14 @@ fn main() {
 }
 ```
 
-其中, `s1`是通过`format!`生成的`String`字符串，最终输出如下：
+其中，`s1` 是通过 `format!` 生成的 `String` 字符串，最终输出如下：
 ```console
 hello, wolrd
 hello, world!
 ```
 
-#### `eprint!`, `eprintln!`
-除了三大金刚外，还有两大护法，使用方式跟`print!`,`println!`很像，但是它们输出到标准错误输出:
+#### `eprint!`，`eprintln!`
+除了三大金刚外，还有两大护法，使用方式跟 `print!`，`println!` 很像，但是它们输出到标准错误输出：
 ```rust
 eprintln!("Error: Could not complete task")
 ```
@@ -48,17 +48,17 @@ eprintln!("Error: Could not complete task")
 它们仅应该被用于输出错误信息和进度信息，其它场景都应该使用 `print!` 系列。
 
 ## {} 与 {:?}
-与其它语言常用的`%d`,`%s`不同，Rust特立独行的选择了`{}`作为格式化占位符(说到这个，有点想吐槽下，Rust中自创的概念其实还挺多的，真不知道该夸奖还是该吐槽- , -)，事实证明，这种选择非常正确，它帮助用户减少了很多使用成本，你无需再为特定的类型选择特定的占位符，统一用`{}`来替代即可，剩下的类型推导等细节只要交给Rust去做。
+与其它语言常用的 `%d`，`%s` 不同，Rust 特立独行地选择了 `{}` 作为格式化占位符(说到这个，有点想吐槽下，Rust 中自创的概念其实还挺多的，真不知道该夸奖还是该吐槽-,-)，事实证明，这种选择非常正确，它帮助用户减少了很多使用成本，你无需再为特定的类型选择特定的占位符，统一用 `{}` 来替代即可，剩下的类型推导等细节只要交给 Rust 去做。
 
-与`{}`类似，`{:?}`也是占位符:
+与 `{}` 类似，`{:?}` 也是占位符：
 
-- `{}`适用于实现了`std::fmt::Display`特征的类型,用来以更优雅、更友好的方式格式化文本，例如展示给用户
+- `{}` 适用于实现了 `std::fmt::Display` 特征的类型，用来以更优雅、更友好的方式格式化文本，例如展示给用户
 - `{:?}` 适用于实现了 `std::fmt::Debug` 特征的类型，用于调试场景
 
 其实两者的选择很简单，当你在写代码需要调试时，使用 `{:?}`，剩下的场景，选择 `{}`。
 
 #### `Debug` 特征
-事实上，为了方便我们调试，大多数Rust类型都实现了`Debug`特征或者支持派生该特征:
+事实上，为了方便我们调试，大多数 Rust 类型都实现了 `Debug` 特征或者支持派生该特征：
 ```rust
 #[derive(Debug)]
 struct Person {
@@ -75,20 +75,23 @@ fn main() {
 }
 ```
 
-对于数值、字符串、数组，可以直接使用`{:?}`进行输出，但是对于结构体，需要[派生`Debug`](../appendix/derive.md)特征后，才能进行输出，总之很简单.
+对于数值、字符串、数组，可以直接使用 `{:?}` 进行输出，但是对于结构体，需要[派生`Debug`](../appendix/derive.md)特征后，才能进行输出，总之很简单。
 
 
 #### `Display` 特征
-与大部分类型实现了`Debug`不同，实现了`Display`特征的Rust类型并没有那么多，往往需要我们自定义想要的格式化方式:
+与大部分类型实现了 `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};
+let p = Person {
+    name: "sunface".to_string(),
+    age: 18,
+};
 println!("{}, {}, {},{}", i, s, v, p);
 ```
 
-运行后可以看到`v`和`p`都无法通过编译，因为没有实现`Display`特征，但是你又不能像派生`Debug`一般派生`Display`，只能另寻他法:
+运行后可以看到 `v` 和 `p` 都无法通过编译，因为没有实现 `Display` 特征，但是你又不能像派生 `Debug` 一般派生 `Display`，只能另寻他法：
 
 - 使用 `{:?}` 或 `{:#?}`
 - 为自定义类型实现 `Display` 特征
@@ -97,7 +100,7 @@ println!("{}, {}, {},{}",i,s,v,p);
 下面来一一看看这三种方式。
 
 #### {:#?}
-`{:#?}`与`{:?}`几乎一样，唯一的区别在于它能更优美的输出内容：
+`{:#?}` 与 `{:?}` 几乎一样，唯一的区别在于它能更优美地输出内容：
 ```console
 // {:?}
 [1, 2, 3],Person { name: "sunface", age: 18 }
@@ -115,21 +118,28 @@ println!("{}, {}, {},{}",i,s,v,p);
 因此对于 `Display` 不支持的类型，可以考虑使用 `{:#?}` 进行格式化，虽然理论上它更适合进行调试输出。
 
 #### 为自定义类型实现 `Display` 特征
-如果你的类型是定义在当前作用域中的，那么可以为其实现`Display`特征，即可用于格式化输出:
+如果你的类型是定义在当前作用域中的，那么可以为其实现 `Display` 特征，即可用于格式化输出：
 ```rust
 struct Person {
     name: String,
-    age: u8
+    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)
+        write!(
+            f,
+            "大佬在上，请受我一拜，小弟姓名{}，年芳{}，家里无田又无车，生活苦哈哈",
+            self.name, self.age
+        )
     }
 }
 fn main() {
-    let p = Person{name: "sunface".to_string(),age: 18};
+    let p = Person {
+        name: "sunface".to_string(),
+        age: 18,
+    };
     println!("{}", p);
 }
 ```
@@ -156,7 +166,7 @@ fn main() {
 }
 ```
 
-`Array`就是我们的`newtype`，它将想要格式化输出的`Vec`包裹在内，最后只要为`Arraw`实现`Display`特征，即可进行格式化输出:
+`Array` 就是我们的 `newtype`，它将想要格式化输出的 `Vec` 包裹在内，最后只要为 `Array` 实现 `Display` 特征，即可进行格式化输出：
 ```console
 数组是：[1, 2, 3]
 ```
@@ -164,7 +174,7 @@ fn main() {
 至此，关于 `{}` 与 `{:?}` 的内容已介绍完毕，下面让我们正式开始格式化输出的旅程。
 
 ## 指定位置参数
-除了按照依次顺序使用值去替换占位符之外，还能让指定位置的参数去替换某个占位符，例如`{1}`，表示用第二个参数替换该占位符(索引从0开始):
+除了按照依次顺序使用值去替换占位符之外，还能让指定位置的参数去替换某个占位符，例如 `{1}`，表示用第二个参数替换该占位符(索引从0开始)：
 ```rust
 fn main() {
     println!("{}{}",1,2); // =>"12"
@@ -191,7 +201,7 @@ println!("{abc} {1}", abc = "def", 2);
 ```
 
 ## 格式化参数
-格式化输出，意味着对输出格式会有更多的要求，例如只输出浮点数的小数点后两位:
+格式化输出，意味着对输出格式会有更多的要求，例如只输出浮点数的小数点后两位：
 ```rust
 fn main() {
     let v = 3.1415926;
@@ -207,10 +217,10 @@ fn main() {
 接下来，让我们一起来看看 Rust 中有哪些格式化参数。
 
 #### 宽度
-宽度用来指示输出目标的长度，如果长度不够，则进行填充和对齐:
+宽度用来指示输出目标的长度，如果长度不够，则进行填充和对齐：
 
 ##### 字符串填充
-字符串格式化默认使用空格进行填充，并且进行左对齐.
+字符串格式化默认使用空格进行填充，并且进行左对齐。
 ```rust
 fn main() {
     //-----------------------------------
@@ -225,7 +235,7 @@ fn main() {
     println!("Hello {:width$}!", "x", width = 5);
     //-----------------------------------
 
-    // 使用参数5为参数x指定宽度,同时在结尾输出参数5 => Hello x    !5
+    // 使用参数5为参数x指定宽度，同时在结尾输出参数5 => Hello x    !5
     println!("Hello {:1$}!{}", "x", 5);
 }
 ```
@@ -285,7 +295,7 @@ fn main() {
 ```
 
 #### 进制
-可以使用`#`号来控制数字的进制输出:
+可以使用 `#` 号来控制数字的进制输出：
 
 - `#b`, 二进制
 - `#o`, 八进制
@@ -329,7 +339,7 @@ println!("{:p}",v.as_ptr()) // => 0x600002324050
 ```
 
 #### 转义
-有时需要输出`{`和`}`，但这两个字符是特殊字符，需要进行转义: 
+有时需要输出 `{`和`}`，但这两个字符是特殊字符，需要进行转义：
 ```rust
 fn main() {
     // {使用{转义，}使用} => Hello {}