语法速通：给已经会编程的人

这一篇怎么读

runoob 那套 Rust 教程用七篇讲基础语法（「运算符」「注释」各占一篇）。 对你来说那七篇里有六篇是在复述你早就会的东西。

所以这里只列差异，按「你会下意识写错的顺序」排。 读完你应该能看懂任意一段 Rust 代码的骨架，剩下看不懂的一定是所有权， 那是下一章的事。

变量与类型

let a = 42;          // 不可变，类型推断成 i32
let mut b = 42;      // 可变
let c: f64 = 42.0;   // 显式标注
let d = 42u8;        // 后缀

三件事和你会的那门不一样：

1. 默认不可变。 要改就得写 mut，编译器还会在你写了 mut 却没改时警告。
2. 整数要选宽度：i8/i16/i32/i64/i128/isize 和对应的 u 系列。 不写就是 i32。
3. 不做隐式数值转换 —— 见《为什么是 Rust》。

类型推断很强，但推不出来时会明确要求你说：

let d = "42".parse::<i64>().unwrap();   // turbofish 指定
let d: i64 = "42".parse().unwrap();     // 或者标注左边

不给任何线索就编译不过： parse 能解析成任何实现了 FromStr 的类型，编译器没法替你挑一个。

error[E0284]: type annotations needed
  |     let d = "42".parse().unwrap();
  |         ^        ----- type must be known at this point

⇒ E0284 / E0282 这一类都是在说「这里我猜不出来，你说一个」。 ⚠️ 具体报哪个码取决于推断卡在哪一步 —— 这条实测报的是 E0284 （卡在关联类型 <_ as FromStr>::Err 上），而 let v = Vec::new(); 报的是 E0282。 记形状别记号。

基本类型速查：

🚨 分号是有语义的

这是最容易踩的一条，因为它看起来只是排版。

块是表达式，最后一行不带分号就是块的值：

let x = {
    let a = 3;
    let b = 4;
    a * a + b * b      // ← 没有分号
};

加上分号，x 就变成了 ()， 然后 println!("{x}") 报 E0277（() 不能打印）。

同一条规则解释了另外两件事：

• 函数体最后一行不写 return 也不写分号 —— 写了分号返回类型就对不上。
• return 只在提前返回时才需要。

控制流：全是表达式

let label = if n % 2 == 0 { "偶" } else { "奇" };

没有三元运算符。代价是两个分支类型必须一致 （见《为什么是 Rust》）。

三种循环各有分工：

loop 能 break 出值这一条值得单记：

let found = loop {
    n += 1;
    if n * n > 50 { break n; }      // ← 带值
};

「循环找第一个满足条件的东西」这个形状，在这里不需要临时变量加标志位。

🚨 for 的 & 加不加，差的是所有权：

for x in &v { }    // 借用，之后 v 还能用
for x in v  { }    // 移动，[之后 v 就没了](#ex-syntax-for-borrows-or-moves)

对照项去掉那个 & 之后，循环外面再用 v 就是 E0382。 这是从别的语言过来最容易撞的一下，因为那些语言里 for 从不夺走容器。

函数

fn add(a: i32, b: i32) -> i32 {
    a + b
}

签名里的类型一个都不能省 —— 参数和返回值都是。 函数内部的局部变量可以推，签名不行。

这是刻意的：签名是契约，改函数体不该悄悄改变调用方看到的东西。 （同样的理由也解释了生命周期那边 「编译器只看签名不看函数体」。）

📌 fn 可以嵌套定义在另一个 fn 里，但内层函数看不见外层的局部变量 —— 要捕获环境得用闭包。

注释与文档

// 普通注释
/* 块注释，可以嵌套 */

/// 文档注释，写在**它下面那个东西**上
/** 也是文档注释 */

//! 模块级文档注释，写在**文件开头**描述这个模块本身

⭐ /// 里的代码块会被 cargo test 真的编译并运行（文档测试）—— 这是 Rust 很特别的一点，测试那篇细说。

这一篇没讲什么

• 所有权、借用、生命周期 —— 那是下一章的全部内容， 也是这套教程真正花篇幅的地方。
• enum 与 match —— 它们在 Rust 里的分量远超「语法」，单独一章讲。
• trait、泛型、闭包、宏 —— 各有各的位置。

如果你现在去读一段真实的 Rust 代码，看不懂的地方应该集中在 &、&mut、'a 和 ? 上。那正好是接下来两章。

下一步

先补上最后一块地基 —— 见《可变性、shadowing 与常量》： mut 到底修饰谁、shadowing 为什么不是「改变量」、以及 const 和 static 的区别。

全部篇目见 Rust 教程首页。

fn main() {
    let a = 42;
    let b = 42u8;
    let c: f64 = 42.0;
    let d = "42".parse::<i64>().unwrap();
    println!("{a} {b} {c} {d}");
}

fn main() {
    let a = 42;
    let b = 42u8;
    let c: f64 = 42.0;
    let d = "42".parse().unwrap();
    println!("{a} {b} {c} {d}");
}

fn main() {
    let v = Vec::new();
    println!("{}", v.len());
}

error[E0282]: type annotations needed for `Vec<_>`
 --> syntax-e0282-vs-e0284.rs:2:9
  |
2 |     let v = Vec::new();
  |         ^   ---------- type must be known at this point
  |
help: consider giving `v` an explicit type, where the type for type parameter `T` is specified
  |
2 |     let v: Vec<T> = Vec::new();
  |          ++++++++

fn main() {
    let v: Vec<i32> = Vec::new();
    println!("{}", v.len());
}

fn main() {
    let x = {
        let a = 3;
        let b = 4;
        a * a + b * b
    };
    println!("{x}");
}

fn main() {
    let x = {
        let a = 3;
        let b = 4;
        a * a + b * b;
    };
    println!("{x}");
}

fn main() {
    let mut n = 0;
    let found = loop {
        n += 1;
        if n * n > 50 {
            break n;
        }
    };
    println!("{found}");
}

fn main() {
    let mut n = 0;
    let found = loop {
        n += 1;
        if n * n > 50 {
            break;
        }
    };
    println!("{found}");
}

fn main() {
    let v = vec![10, 20, 30];
    let mut total = 0;
    for x in &v {
        total += x;
    }
    for i in 0..3 {
        total += i;
    }
    for (i, x) in v.iter().enumerate() {
        total += i as i32 * x;
    }
    println!("{total}");
}

fn main() {
    let v = vec![10, 20, 30];
    let mut total = 0;
    for x in v {
        total += x;
    }
    for i in 0..3 {
        total += i;
    }
    for (i, x) in v.iter().enumerate() {
        total += i as i32 * x;
    }
    println!("{total}");
}

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    println!("{}", add(1, 2));
}

fn add(a: i32, b: i32) {
    a + b
}

fn main() {
    println!("{}", add(1, 2));
}

use std::mem::size_of;

fn main() {
    println!(
        "char={} String={} &str={} &i32={} Option<&i32>={} Option<i32>={}",
        size_of::<char>(),
        size_of::<String>(),
        size_of::<&str>(),
        size_of::<&i32>(),
        size_of::<Option<&i32>>(),
        size_of::<Option<i32>>(),
    );
}

use std::mem::size_of;

fn main() {
    println!(
        "char={} String={} &str={} &i32={} Option<&i32>={} Option<i32>={}",
        size_of::<char>(),
        size_of::<String>(),
        size_of::<&str>(),
        size_of::<i32>(),
        size_of::<Option<i32>>(),
        size_of::<Option<i32>>(),
    );
}