docs: 补充1-basics语言对比和常见错误诊断

- 03-变量基础：Rust vs Java/C++/Python 对比 + 常见错误（E0384/E0381/E0308）
- 05-函数基础：Rust vs Python/JS/Java 对比 + 常见错误（E0416/返回类型/分号错误）
- 06-模式匹配：match vs switch 对比 + 常见错误（E0004/类型不一致/if let方向）

强化"编译器是免费导师"理念

Author: baxiang

1-basics/03-variables/01-变量基础.md

@@ -143,9 +143,256 @@ fn main() {
 │                                                     │
 │  Rust 哲学：让正确的事情变得容易                     │
 │                                                     │
+└───────────────────────────────────────┘
+```
+
+---
+
+## 语言对比：变量可变性
+
+### Rust vs 其他语言
+
+```
+┌─────────────────────────────────────────────────────┐
+│              变量可变性对比                           │
+├─────────────────────────────────────────────────────┤
+│                                                     │
+│  Java/C++：                                          │
+│  ├── int x = 5;        // 默认可变                  │
+│  ├── x = 10;           // ✅ 允许                   │
+│  ├── final int y = 5;  // 需要显式标记不可变        │
+│  └── 设计：可变是默认，不可变需额外声明              │
+│                                                     │
+│  Python：                                            │
+│  ├── x = 5             // 可变                      │
+│  ├── x = 10            // ✅ 允许                   │
+│  ├── 无不可变变量语法                              │
+│  └── 设计：全部可变                                 │
+│                                                     │
+│  Rust：                                              │
+│  ├── let x = 5;        // 默认不可变                │
+│  ├── x = 10;           // ❌ 编译错误               │
+│  ├── let mut y = 5;    // 需要显式标记可变          │
+│  ├── y = 10;           // ✅ 允许                   │
+│  └── 设计：不可变是默认，可变需额外声明              │
+│                                                     │
+│  对比结论：                                          │
+│  ├── Java/C++：安全需主动追求                      │
+│  ├── Python：安全靠自觉                            │
+│  ├── Rust：安全是默认                              │
+│                                                     │
+└─────────────────────────────────────────────────────┘
+```
+
+### 实际代码对比
+
+```rust
+// Rust：默认安全
+fn main() {
+    let config = load_config();  // 不可变
+    // config = new_config();    // ❌ 编译器阻止修改
+    
+    let mut counter = 0;         // 显式声明需要修改
+    counter += 1;                // ✅ 允许
+}
+```
+
+```java
+// Java：需要主动保护
+public class Example {
+    void run() {
+        int config = loadConfig();  // 可被意外修改
+        config = newConfig();       // ✅ 允许（可能是 bug）
+        
+        final int safeConfig = loadConfig();  // 需要显式 final
+        // safeConfig = newConfig();          // ❌ 编译错误
+    }
+}
+```
+
+---
+
+## 常见错误诊断
+
+### 错误 1：修改不可变变量
+
+#### 错误代码
+
+```rust
+fn main() {
+    let x = 5;
+    x = 10;  // 尝试修改不可变变量
+}
+```
+
+#### 编译器错误
+
+```
+error[E0384]: cannot assign twice to immutable variable `x`
+ --> src/main.rs:3:5
+  |
+2 |     let x = 5;
+  |         - first assignment to `x`
+3 |     x = 10;
+  |     ^^^^^^ cannot assign twice to immutable variable
+  |
+help: make this binding mutable
+  |
+2 |     let mut x = 5;
+  |         +++
+```
+
+#### 解读错误信息
+
+```
+┌─────────────────────────────────────────────────────┐
+│              错误信息解读                             │
+├─────────────────────────────────────────────────────┤
+│                                                     │
+│  error[E0384]: cannot assign twice to immutable   │
+│                variable `x`                         │
+│  │                                                  │
+│  │  错误码 E0384 = "不能给不可变变量赋值两次"       │
+│  │  x 是不可变的，不能再次赋值                      │
+│                                                     │
+│  first assignment to `x`                           │
+│  │                                                  │
+│  │  说明：第一次赋值位置（let x = 5）              │
+│                                                     │
+│  cannot assign twice to immutable variable         │
+│  │                                                  │
+│  │  说明：尝试第二次赋值                            │
+│  │  原因：变量不可变                                │
+│                                                     │
+│  help: make this binding mutable                   │
+│  │                                                  │
+│  │  建议：添加 mut 使变量可变                       │
+│  │  解决方案：let mut x = 5;                        │
+│                                                     │
+│  关键：编译器告诉你原因和解决方案                   │
+│                                                     │
 └─────────────────────────────────────────────────────┘
 ```
 
+#### 修复方案
+
+```rust
+// 方案 1：添加 mut（如果确实需要修改）
+fn main() {
+    let mut x = 5;  // 显式声明可变
+    x = 10;         // ✅ 正确
+}
+
+// 方案 2：保持不可变（如果不需要修改）
+fn main() {
+    let x = 5;
+    let x = 10;     // 使用变量遮蔽（shadowing）
+    println!("{}", x);
+}
+```
+
+---
+
+### 错误 2：未初始化变量
+
+#### 错误代码
+
+```rust
+fn main() {
+    let x: i32;
+    println!("{}", x);  // 使用未初始化变量
+}
+```
+
+#### 编译器错误
+
+```
+error[E0381]: used assignment is required but `x` is not assigned
+ --> src/main.rs:3:20
+  |
+2 |     let x: i32;
+  |         - help: consider assigning a value: `let x: i32 = <value>;`
+3 |     println!("{}", x);
+  |                    ^ used assignment is required but `x` is not assigned
+```
+
+#### 解读与修复
+
+```
+错误码 E0381：使用了未赋值的变量
+
+修复：
+├── 方案 1：初始化变量
+│   let x: i32 = 0;
+│
+├── 方案 2：使用类型推断（自动推断为 0）
+│   let x = 0;
+```
+
+---
+
+### 错误 3：类型不匹配
+
+#### 错误代码
+
+```rust
+fn main() {
+    let x: i32 = "hello";
+}
+```
+
+#### 编译器错误
+
+```
+error[E0308]: mismatched types
+ --> src/main.rs:2:18
+  |
+2 |     let x: i32 = "hello";
+  |                  ^^^^^^^ expected `i32`, found `&str`
+  |
+  = note: expected type `i32`
+          found reference `&str`
+```
+
+#### 解读与修复
+
+```
+错误码 E0308：类型不匹配
+
+原因：
+├── 声明类型：i32（整数）
+├── 实际类型：&str（字符串）
+├── 类型不兼容
+
+修复：
+├── 方案 1：修改值类型
+│   let x: i32 = 42;
+│
+├── 方案 2：修改声明类型
+│   let x: &str = "hello";
+```
+
+---
+
+### 错误诊断速查
+
+| 错误码 | 错误类型 | 原因 | 快速解决 |
+|--------|---------|------|---------|
+| E0384 | 修改不可变变量 | 尝试给 `let` 变量赋值两次 | 添加 `mut` |
+| E0381 | 未初始化变量 | 使用未赋值的变量 | 初始化变量 |
+| E0308 | 类型不匹配 | 值与声明类型不符 | 修正类型 |
+
+---
+
+## 小结
+
+本章核心：
+
+- `let` 声明变量，默认不可变
+- `let mut` 声明可变变量
+- Rust 默认不可变，主动追求安全
+- 编译器错误是最好的学习线索
+