Merge pull request #147 from zonyitoo/master

修复语法高亮及部分审校

Author: zonyitoo

06-flow/06-01-comment.md

@@ -10,7 +10,7 @@ Rust 代码文件中，通常我们可以看到 3 种注释。
 
 使用 `//` 进行行注释。
 
-```
+```rust
 // 创建一个绑定
 let x = 5;
 
@@ -21,22 +21,23 @@ let y = 6; // 创建另一个绑定
 
 文档注释使用 ```///```，一般用于函数或结构体（字段）的说明，置于要说明的对象上方。文档注释内部可使用markdown格式的标记语法，可用于 rustdoc 工具的自动文档提取。
 
-    /// Adds one to the number given.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let five = 5;
-    ///
-    /// assert_eq!(6, add_one(5));
-    /// # fn add_one(x: i32) -> i32 {
-    /// #     x + 1
-    /// # }
-    /// ```
-    fn add_one(x: i32) -> i32 {
-        x + 1
-    }
-
+```rust
+/// Adds one to the number given.
+///
+/// # Examples
+///
+/// ```
+/// let five = 5;
+///
+/// assert_eq!(6, add_one(5));
+/// # fn add_one(x: i32) -> i32 {
+/// #     x + 1
+/// # }
+/// ```
+fn add_one(x: i32) -> i32 {
+    x + 1
+}
+```
 
 ## 模块注释
 

06-flow/06-02-condition.md

@@ -8,29 +8,29 @@
 
 Rust 中的 if 表达式基本就是如下几种形式：
 
-```
+```rust
 // 形式 1
 if expr1 {
 
 }
- 
+
 // 形式 2
 if expr1 {
 
 }
 else {
-    
+
 }
 
 // 形式 3
 if expr1 {
-    
+
 }
 else if expr2 {
     // else if 可多重
 }
 else {
-    
+
 }
 
 ```
@@ -42,7 +42,7 @@ else {
 
 鉴于上述第二点，因为是表达式，所以我们可以写出如下代码：
 
-```
+```rust
 let x = 5;
 
 let y = if x == 5 {
@@ -54,17 +54,17 @@ let y = if x == 5 {
 
 或者压缩成一行：
 
-```
+```rust
 let x = 5;
 
 let y = if x == 5 { 10 } else { 15 }; // y: i32
 ```
 
-## if let 
+## if let
 
 我们在代码中常常会看到 `if let` 成对出现，这实际上是一个 match 的简化用法。直接举例来说明：
 
-```
+```rust
 let x = Some(5);
 
 if let Some(y) = x {
@@ -81,9 +81,9 @@ else {
 
 ```
 
-上面代码等价于 
+上面代码等价于
 
-```
+```rust
 let x = Some(5);
 match x {
     Some(y) => println!("{}", y),
@@ -104,7 +104,7 @@ Rust 中没有类似于 C 的 `switch` 关键字，但它有用于模式匹配
 
 match 的使用非常简单，举例如下：
 
-```
+```rust
 let x = 5;
 
 match x {
@@ -119,4 +119,3 @@ match x {
 }
 ```
 注意，match 也是一个表达式。match 后面会专门论述，请参见 **模式匹配** 这一章。
-

06-flow/06-03-repeatition.md

@@ -10,15 +10,15 @@
 ## for
 
 for 语句用于遍历一个迭代器。
-```
+```rust
 for var in iterator {
     code
 }
 ```
 Rust 迭代器返回一系列的元素，每个元素是循环中的一次重复。然后它的值与 var 绑定，它在循环体中有效。每当循环体执行完后，我们从迭代器中取出下一个值，然后我们再重复一遍。当迭代器中不再有值时，for 循环结束。
 
 比如：
-```
+```rust
 for x in 0..10 {
     println!("{}", x); // x: i32
 }
@@ -39,7 +39,7 @@ for x in 0..10 {
 
 不熟悉迭代器概念的同学可能傻眼了，下面不仿用 C 形式的 for 语句做下对比：
 
-```
+```rust
 // C 语言的 for 循环例子
 for (x = 0; x < 10; x++) {
     printf( "%d\n", x );
@@ -57,7 +57,7 @@ for 语句就是迭代器遍历的语法糖。
 
 上述迭代器的形式虽好，但是好像在循环过程中，少了索引信息。Rust 考虑到了这一点，当你需要记录你已经循环了多少次了的时候，你可以使用 `.enumerate()` 函数。比如：
 
-```
+```rust
 for (i,j) in (5..10).enumerate() {
     println!("i = {} and j = {}", i, j);
 }
@@ -73,7 +73,7 @@ i = 4 and j = 9
 ```
 再比如：
 
-```
+```rust
 let lines = "Content of line one\nContent of line two\nContent of line three\nContent of line four".lines();
 for (linenumber, line) in lines.enumerate() {
     println!("{}: {}", linenumber, line);
@@ -93,15 +93,15 @@ for (linenumber, line) in lines.enumerate() {
 
 Rust 提供了 while 语句，条件表达式为真时，执行语句体。当你不确定应该循环多少次时可选择 while。
 
-```
+```rust
 while expression {
     code
 }
 ```
 
 比如：
 
-```
+```rust
 let mut x = 5; // mut x: i32
 let mut done = false; // mut done: bool
 
@@ -120,15 +120,15 @@ while !done {
 
 有一种情况，我们经常会遇到，就是写一个无限循环：
 
-```
+```rust
 while true {
     // do something    
 }
 ```
 
 针对这种情况，Rust 专门优化提供了一个语句 loop。
 
-```
+```rust
 loop {
     // do something
 }
@@ -138,7 +138,7 @@ loop {
 
 比如说，如下代码：
 
-```
+```rust
 let mut a;
 loop {
      a = 1;
@@ -158,7 +158,7 @@ do_something(a)
 
 像上面那个 while 例子：
 
-```
+```rust
 let mut x = 5;
 let mut done = false;
 
@@ -174,7 +174,7 @@ while !done {
 ```
 可以优化成：
 
-```
+```rust
 let mut x = 5;
 
 loop {
@@ -189,7 +189,7 @@ loop {
 
 下面这个例子演示 continue 的用法：
 
-```
+```rust
 for x in 0..10 {
     if x % 2 == 0 { continue; }
 
@@ -212,7 +212,7 @@ for x in 0..10 {
 
 如下代码只会在 x 和 y 都为奇数时打印他们：
 
-```
+```rust
 'outer: for x in 0..10 {
     'inner: for y in 0..10 {
         if x % 2 == 0 { continue 'outer; } // continues the loop over x
@@ -221,4 +221,3 @@ for x in 0..10 {
     }
 }
 ```
-

07-type/07-01-types.md

@@ -6,7 +6,7 @@
 
 Rust自带了`bool`类型，其可能值为`true`或者`false`。
 我们可以通过这样的方式去声明它：
-```
+```rust
 let is_she_love_me = false;
 let mut is_he_love_me: bool = true;
 ```
@@ -17,7 +17,7 @@ let mut is_he_love_me: bool = true;
 在Rust中，一个`char`类型表示一个*Unicode*字符,这也就意味着，在某些语言里代表一个字符(8bit)的char，在Rust里实际上是四个字节(32bit)。
 同时，我们可以将各种奇怪的非中文字符随心所欲的赋值给一个char类型。需要注意的是，Rust中我们要用`'`来表示一个char，如果用`"`的话你得到的实际上是一个`&'static str`。
 
-```
+```rust
 let c = 'x';
 let cc = '王';
 ```
@@ -36,9 +36,9 @@ let cc = '王';
 
 有人说了，你看我整个`i128`行不。
 
-答，不行，谁家电脑是128位的啊……… 
+答，不行，谁家电脑是128位的啊………
 
-但是真的有人提议支持这个类型： https://github.com/rust-lang/rfcs/pull/1504 
+但是真的有人提议支持这个类型： https://github.com/rust-lang/rfcs/pull/1504
 
 ### 自适应类型
 
@@ -50,15 +50,15 @@ let cc = '王';
 
 Rust的数组是被表示为`[T;N]`。其中N表示数组大小，并且这个大小一定是个编译时就能获得的整数值，T表示`泛型`类型，即任意类型。我们可以这么来声明和使用一个数组:
 
-```
+```rust
 let a = [8, 9, 10];
-let b: [u8;3] = [8, 6, 5]; 
+let b: [u8;3] = [8, 6, 5];
 print!("{}", a[0]);
 ```
 
 和Golang一样，Rust的数组中的`N`（大小）也是类型的一部分，即`[u8; 3] != [u8; 4]`。这么设计是为了更安全和高效的使用内存，当然了，这会给第一次接触类似概念的人带来一点点困难，比如以下代码。
 
-```
+```rust
 fn show(arr: [u8;3]) {
     for i in &arr {
         print!("{} ", i);
@@ -98,7 +98,7 @@ error: aborting due to previous error
 这里`&`符号是一个难点，我们不妨放开这个符号，简单的把它看成是`Slice`的甲鱼臀部——规定。另外，同样的，`Slice`也是可以通过下标的方式访问其元素，下标也是从0开始的哟。
 你可以这么声明并使用一个`Slice`：
 
-```
+```rust
 let arr = [1, 2, 3, 4, 5, 6];
 let slice_complete = &arr[..]; // 获取全部元素
 let slice_middle = &arr[1..4]; // 获取中间元素，最后取得的Slice为 [2, 3, 4] 。切片遵循左闭右开原则。
@@ -109,7 +109,7 @@ let slice_left = &arr[..3]; // 最后获得的元素为[1, 2, 3]，长度为3。
 怎么样，了解了吧。
 那么接下来我们用`Slice`来改造一下上面的函数
 
-```
+```rust
 fn show(arr: &[u8]) {
     for i in arr {
         print!("{} ", i);
@@ -141,7 +141,7 @@ fn main() {
 
 下面介绍几种典型的`Vec`的用法:
 
-```
+```rust
 let mut v1: Vec<i32> = vec![1, 2, 3]; // 通过vec!宏来声明
 let v2 = vec![0; 10]; // 声明一个初始长度为10的值全为0的动态数组
 println!("{}", v1[0]); // 通过下标来访问数组元素
@@ -175,11 +175,10 @@ for i in &mut v1 {
 
 下面是一个小例子
 
-```
+```rust
 fn foo(x: i32) -> i32 { x+1 }
 
 let x: fn(i32) -> i32 = foo;
 
 assert_eq!(11, x(10));
-
 ```