Merge pull request #16 from geometryolife/fix-typo

src/chapter_2.md

@@ -25,7 +25,7 @@ Rust的设计理念是将系统编程的性能与安全性相结合。它的核
 
 随着Rust的发展，其社区和生态系统也在不断壮大。Rust编程语言被广泛应用于各种领域，如网络编程、游戏开发、操作系统、嵌入式系统、区块链等。此外，Rust已经连续多年被Stack Overflow开发者调查评为最受欢迎的编程语言。
 
-Rust的成功和流行归功于其活跃的社区和丰富的第三方库。社区不断努力改进和扩展Rust的功能，使其成为一个更加实用和强大的编程语言。总的来说，Rust的历史与背景显示了一个充满创新、活力和潜力的编程语言，它将继续为现代软件开发带来更多的机会。
+Rust的成功和流行归功于其活跃的社区和丰富的第三方库。社区不断努力改进和扩展Rust的功能，使其成为一个更加实用和强大的编程语言。总的来说，Rust的历史与背景显示了Rust是一个充满创新、活力和潜力的编程语言，它将继续为现代软件开发带来更多的机会。
 
 ### 2.1.2 Rust的主要优势
 
@@ -145,7 +145,7 @@ rustc --version
 
 ## 2.3 第一个Rust程序
 
-本节将编写和运行本书的第一个Rust程序：`Hello, World!`
+本节将编写和运行本书的第一个Rust程序：`hello_world`
 
 ### 2.3.1 创建一个新的Rust项目
 
@@ -163,7 +163,7 @@ cargo new hello_world
 
 ### 2.3.2 编写程序
 
-默认情况下，main.rs文件中已经包含了一个简单的`Hello, World`程序，代码如下：
+默认情况下，main.rs文件中已经包含了一个简单的`hello_world`程序，代码如下：
 
 ```rust
 fn main() {
@@ -192,8 +192,8 @@ cargo run
 
 #### 1. main函数
 
-main函数是程序的入口。当运行程序时，main函数将首先被调用。Rust中函数的定义以关键字fn开始，后跟函数名和参数列表，函数体则由一对花括号包围。main函数没有参数，也没有返回值。
+`main`函数是程序的入口。当运行程序时，`main`函数将首先被调用。Rust中函数的定义以关键字`fn`开始，后跟函数名和参数列表，函数体则由一对花括号包围。`main`函数没有参数，也没有返回值。
 
 #### 2. println!宏
 
-`println!`是一个用于向控制台输出一行文本的Rust宏。在例子中，我们向`println!`宏传递了一个字符串字面量`"Hello, World!"`作为参数。`println!`宏会将这个字符串作为控制台输出。
+`println!`是一个用于向控制台输出一行文本的Rust宏。在例子中，我们向`println!`宏传递了一个字符串字面量`"Hello, World!"`作为参数。`println!`宏会将这个字符串作为控制台的输出。

src/chapter_3/chapter_3_1.md

@@ -17,31 +17,31 @@ Rust中变量分为不可变变量和可变变量。不可变变量不能对其
 - 不可变变量定义方式如下：
 
     ```rust
-    let a: u32 = 1;   //将1绑定到a这个变量
+    let a: u32 = 1; // 将1绑定到a这个变量
     let b = 0u32;
-    let c = 1;        //定义时不指定类型，可以自动类型推导
+    let c = 1;      // 定义时不指定类型，可以自动类型推导
     ```
 
     对不可变变量二次绑定一个值会报错：
 
     ```rust
-    let a: u32 = 1; //将1绑定到变量a，a为不可变变量，
-    a = 2;          //编译错误，a是不可变的变量，不能进行二次绑定
+    let a: u32 = 1; // 将1绑定到变量a，a为不可变变量，
+    a = 2;          // 编译错误，a是不可变的变量，不能进行二次绑定
     ```
 
 - 可变变量定义方式如下：
 
     ```rust
-    let mut a: u32 = 1;  //通过mut关键字定义可变变量
-    a = 2;               //将2绑定到变量a，编译正确，因为a是可变变量，可以进行二次绑定
+    let mut a: u32 = 1; // 通过mut关键字定义可变变量
+    a = 2;              // 将2绑定到变量a，编译正确，因为a是可变变量，可以进行二次绑定
     let mut b = 2;
     b = 3;
     ```
 
 > 设计思考：
-> 从编译器的角度，如果一个值定义为不可变变量，那它就不会改变，更易于推导。想想一下如果代码非常多，如果变量不会变化，但是允许它可变，其实会更容易滋生bug。
+> 从编译器的角度，如果一个值定义为不可变变量，那它就不会改变，更易于推导。想一下如果代码非常多，如果变量不会变化，但是允许它可变，其实会更容易滋生bug。
 
-## 3.1.3常量
+## 3.1.3 常量
 
 常量是绑定到一个名称不允许改变的值，定义方式如下：
 
@@ -50,36 +50,36 @@ const HOUR_IN_SECONDS: u32 = 60 * 60;
 ```
 
 常量和不可变变量的区别：
-- 不允许对常量使用mut关键字，它总是不可变的，定义时必须显式的标注类型；
+- 不允许对常量使用`mut`关键字，它总是不可变的，定义时必须显式地标注类型；
 
     ```rust
-    let a = 1u32;    //编译正确
-    let a = 1;       //编译正确
+    let a = 1u32;     // 编译正确
+    let a = 1;        // 编译正确
 
-    const A: u32 = 1; //编译正确
-    const B = 2u32;   //编译错误
-    const C = 2;      //编译错误
+    const A: u32 = 1; // 编译正确
+    const B = 2u32;   // 编译错误
+    const C = 2;      // 编译错误
     ```
 - 常量可以在任何作用域声明，包括全局作用域；
 - 常量只能被设置为常量表达式，不能是在运行时计算出来的值。
     ```rust
     let a: u32 = 1;
     let b: u32 = 2;
-    const A: u32 = a + b;    //编译错误
+    const A: u32 = a + b; // 编译错误
     ```
 
 ## 3.1.4 隐藏
 
-Rust中可以定义一个与之前的变量同名的变量，这称之为第一个变量被第二个变量隐藏。隐藏和`mut`的区别：隐藏是定义了一个新的变量，而使用mut是修改原来的变量。
+Rust中可以定义一个与之前的变量同名的变量，这称之为第一个变量被第二个变量隐藏。隐藏和`mut`的区别：隐藏是定义了一个新的变量，而使用`mut`是修改原来的变量。
 
 ```rust
 fn main() {
-    let a: u32 = 1;         //这个变量a被下面的a隐藏掉了
-    let a: u32 = 2;         //定义了一个新的变量，这个变量也叫作a
-    println!("a: {:?}", a); //输出结果为2
+    let a: u32 = 1;         // 这个变量a被下面的a隐藏掉了
+    let a: u32 = 2;         // 定义了一个新的变量，这个变量也叫作a
+    println!("a: {:?}", a); // 输出结果为2
 
-    let mut b: u32 = 1;     //定义可变变量b
-    b = 2;                  //对b的值进行的修改
-    println!("b: {:?}", b); //输出结果为2
+    let mut b: u32 = 1;     // 定义可变变量b
+    b = 2;                  // 对b的值进行的修改
+    println!("b: {:?}", b); // 输出结果为2
 }
 ```