基础语法

这一课你将能做到

1. 用 let / let mut / shadowing 管理变量，理解「默认不可变」的设计
2. 写函数、用 if / loop / while / for 组织控制流，把 if 当表达式用
3. 完成一个统计判题耗时的 CLI 小工具

为什么要学

语法是所有后续内容的载体。Rust 的语法表面像 C，骨子里偏函数式：几乎一切都是表达式，类型推导无处不在，编译器报错友好到近乎手把手。这节课把地基打平，后面所有权、错误处理这些硬菜才咽得下去。

和 Java 对照着学最快：变量声明像 var，常量像 final，但「默认不可变」这条设计，把 Java 里靠自觉的 best practice 变成了强制。

先建立图像

Java:   int total = 0;             final int MAX = 100;
Rust:   let mut total = 0;         const MAX: u32 = 100;

Java:   var name = "judge";        // 类型推断
Rust:   let name = "judge";        // 类型推断 + 默认不可变

核心心智模型：let 绑定的是「名字到值」的关系，绑定默认不可变——想改值，显式声明 mut；想换绑新值，直接再 let（shadowing）。

跟着做

步骤 1：变量、可变性与 shadowing

cargo new basic-demo
cd basic-demo

把 src/main.rs 换成：

fn main() {
    let submit_count = 10;          // 不可变绑定
    // submit_count = 11;           // 编译错误：不可变变量不能二次赋值

    let mut total_ms = 0u64;        // mut 声明可变
    total_ms += 150;

    let submit_count = submit_count * 2;  // shadowing：换绑新值，连类型都可以变
    println!("提交数 {submit_count}，总耗时 {total_ms} ms");
}

运行 cargo run。注意 shadowing 不是修改，是旧名字被新绑定遮蔽，编译器把它当两个变量。

步骤 2：基本类型与推导

fn main() {
    let a = 42;                 // 推导为 i32（整型默认）
    let b: u64 = 18_446_744_073_709_551_615;  // 显式标注，_ 是数字分隔符
    let pi = 3.14159;           // f64（浮点默认）
    let ok = true;              // bool
    let letter = '判';           // char 是 4 字节 Unicode 标量
    let pair = ("cpp", 1000);   // 元组：异构定长集合
    let arr = [3, 1, 4, 1, 5];  // 数组：定长，栈上

    let (lang, limit) = pair;   // 元组解构
    println!("{a} {b} {pi} {ok} {letter} {lang} {limit} {}", arr[2]);
}

整型家族：i8/i16/i32/i64/i128/isize 与对应 u 系列。判题内存计数、跨语言协议这类场景明确标 u64，其余交给推导。

步骤 3：函数与返回值

fn grade(score: u32) -> &'static str {
    if score >= 90 { "A" } else if score >= 60 { "P" } else { "F" }
}   // if 是表达式，不带分号的分支值直接作为返回值

fn add_time(total: &mut u32, delta: u32) {
    *total += delta;            // 不返回值时，隐式返回单元类型 ()
}

fn main() {
    let mut total = 0;
    add_time(&mut total, 120);
    add_time(&mut total, 80);
    println!("耗时 {total} ms，评级 {}", grade(95));
}