diff --git a/src/chapter_3/chapter_3_2.md b/src/chapter_3/chapter_3_2.md
index ce87eb6..7c52538 100644
--- a/src/chapter_3/chapter_3_2.md
+++ b/src/chapter_3/chapter_3_2.md
@@ -1,7 +1,6 @@
 # 3.2 基本数据类型
 
-Rust是静态类型语言，编译时就必须知道所有变量的类型。根据值以及其使用方式，Rust编译器通常能自动推导出变量的类型。
-Rust有两种数据类型子集，分别是：标量（scalar）类型和复合（compound）类型。
+Rust是静态类型语言，编译时就必须知道所有变量的类型。根据值以及其使用方式，Rust编译器通常能自动推导出变量的类型。Rust有两种数据类型子集，分别是：标量（scalar）类型和复合（compound）类型。
 
 ## 3.2.1 标量类型
 
@@ -11,20 +10,20 @@ Rust有两种数据类型子集，分别是：标量（scalar）类型和复合
 
 Rust中的整型和浮点型如下：
 
-| 长度 | 有符号 | 无符号 | 浮点型|
-| ---- | ----- | ------ | ----- |
-|8 bit |  i8   |   u8   |       |
-|16 bit|  i16  |   u16  |       |
-|32 bit|  i32  |   u32  |  f32  |
-|64 bit|  i64  |   u64  |  f64  |
-|128 bit| i128 |   u128 |       |
-| arch | isize |  usize |       |
+| 长度    | 有符号 | 无符号 | 浮点型 |
+|---------|--------|--------|--------|
+| 8 bit   | i8     | u8     |        |
+| 16 bit  | i16    | u16    |        |
+| 32 bit  | i32    | u32    | f32    |
+| 64 bit  | i64    | u64    | f64    |
+| 128 bit | i128   | u128   |        |
+| arch    | isize  | usize  |        |
 
 说明：`isize`和`usize`的长度是和平台相关，如果CPU是32位的，则这两个类型是32位的，如果CPU是64位的，则这两个类型是64位的。
 
-上面的表格中，`f32`和`f64`为浮点型，其它为整型。浮点型和整型一起构成数值型。
+上面的表格中，`f32`和`f64`为浮点型，其它为整型。浮点型和整型一起构成数值类型。
 
-（1）可以在数值字面量后面加上类型表示该类型的数值，如下：
+（1）可以在数值字面量后面加上类型表示该数值的类型，如下：
 
 ```rust
 fn main(){
@@ -35,7 +34,7 @@ fn main(){
 }
 ```
 
-（2）可以数值的任意位置使用下划线分割来增强可读性，如下：
+（2）可以在数值的任意位置使用下划线分割来增强可读性，如下：
 
 ```rust
 fn main(){
@@ -45,12 +44,12 @@ fn main(){
 }
 ```
 
-（3）当不明确指定变量的类型，也不明确指定数值字面量的类型后缀时，Rust默认将整数当做`i32`类型，将浮点数当做`f64`类型，如下：
+（3）当既不明确指定变量的类型，也不明确指定数值字面量的类型后缀时，Rust默认将整数当做`i32`类型，将浮点数当做`f64`类型，如下：
 
 ```rust
 fn main(){
-  let _a = 33;     // 等价于 let _a: i32 = 33;    等价于 let _a = 33i32;
-  let _b = 64.123; // 等价于let _b: f64 = 64.123; 等价于 let _b = 64.123f64;
+  let _a = 33;     // 等价于 let _a: i32 = 33;     等价于 let _a = 33i32;
+  let _b = 64.123; // 等价于 let _b: f64 = 64.123; 等价于 let _b = 64.123f64;
 }
 ```
 
@@ -58,10 +57,10 @@ fn main(){
 
 ```rust
 fn main(){
-  let a: u32 = 0b101;      // 二进制整数
-  let b: i32 = 0o17;       // 八进制整数
-  let c: u8 = 1;           // 十进制
-  let d: i32 = 0xac;       // 十六进制整数
+  let a: u32 = 0b101; // 二进制整数
+  let b: i32 = 0o17;  // 八进制整数
+  let c: u8 = 1;      // 十进制
+  let d: i32 = 0xac;  // 十六进制整数
   println!("{}, {}, {}, {}", a, b, c, d);  // 5, 15, 1, 172
 }
 ```
@@ -106,7 +105,7 @@ fn main() {
 
 ### 3.2.1.3 字符类型
 
-char类型用于存放单个unicode字符，占用4个字节空间。当存储char类型数据时，Rust会将其转换为utf-8编码的数据存储。`char`字面量是单引号包含的任意单个字符，字符类型使用示例如下：
+Rust用`char`表示字符类型，用于存放单个unicode字符，占用4个字节空间。当存储`char`类型数据时，Rust会将其转换为utf-8编码的数据存储。`char`字面量是单引号包裹的任意单个字符，字符类型使用示例如下：
 
 ```rust
 fn main() {
@@ -116,7 +115,7 @@ fn main() {
 }
 ```
 
-## 3.2.2. 原生复合类型
+## 3.2.2 原生复合类型
 
 复合类型是将多个值组合成一个类型。Rust有两个原生复合类型：元组和数组。
 
@@ -130,13 +129,13 @@ fn main() {
 }
 ```
 
-可以将元组重新结构到变量上，如下：
+可以将元组重新解构到变量上，如下：
 
 ```rust
 fn main() {
     let tup = (500, 6.4, 1);
     let (x, y, z) = tup;
-    //接下来你可以使用x、y、z
+    // 接下来你可以使用x、y、z
 }
 ```
 
@@ -151,7 +150,7 @@ fn main() {
 }
 ```
 
-不带任何值的元组，称为unit类型（单元元组），可以代表空值或者空的返回类型，如下：
+不带任何值的元组，称为`unit`类型（单元元组），可以代表空值或者空的返回类型，如下：
 
 ```rust
 fn main() {
@@ -165,9 +164,9 @@ fn main() {
 
 ```rust
 fn main() {
-    let a = [1, 2, 3, 4, 5];           //直接写数组的值
-    let b: [i32; 5] = [1, 2, 3, 4, 5]; //显示指定数组的类型和长度
-    let c: [i32; 5] = [3; 5];          //数组每个元素为同样的值，等价于let a = [3, 3, 3, 3, 3];
+    let a = [1, 2, 3, 4, 5];           // 直接写数组的值
+    let b: [i32; 5] = [1, 2, 3, 4, 5]; // 显示指定数组的类型和长度
+    let c: [i32; 5] = [3; 5];          // 数组每个元素为同样的值，等价于 let a = [3, 3, 3, 3, 3];
 }
 ```
 
@@ -197,8 +196,8 @@ Rust中可以使用`as`进行类型转换。
 
 - 数值类型之间默认不会隐式转换，如果要转换，则需手动使用`as`进行转换。
 - bool类型可以转换为各种数值类型，`false`对应`0`，`true`对应`1`。
-- 可以通过`as`将`char`类型转换为各种整型，目标类型小于4字节时，会从高位截断。
-- 可以通过`as`将`u8`转换为`char`类型。
+- 可以使用`as`将`char`类型转换为各种整型，目标类型小于4字节时，会从高位截断。
+- 可以使用`as`将`u8`转换为`char`类型。
 - 可以使用`std::char::from_u32`将`u32`转换为`char`类型。
 - 可以使用`std::char::from_digit`将十进制整型转换为`char`类型。