Skip to content

02 - 基础语法

一、变量与可变性

1. 不可变 vs 可变

fn main() {
    // 默认不可变
    let x = 5;
    // x = 6; // ❌ 编译错误

    // 加 mut 关键字变可变
    let mut y = 10;
    y = 15; // ✅
}

2. 常量

// 常量必须显式标注类型,且全程不可变
const MAX_POINTS: u32 = 100_000;
const PI: f64 = 3.14159;

3. 变量遮蔽 (Shadowing)

fn main() {
    let x = 5;
    let x = x + 1;          // 6
    {
        let x = x * 2;      // 12(内部作用域)
        println!("inner: {}", x);
    }
    println!("outer: {}", x); // 6(外层仍为 6)
}

遮蔽 vs mut: - 遮蔽可以改变类型,mut 不行 - 遮蔽是创建新变量,mut 是修改

// 遮蔽可以改变类型
let spaces = "   ";          // &str
let spaces = spaces.len();   // usize,合法

// mut 改变类型报错
// let mut spaces = "   ";
// spaces = spaces.len(); // ❌ 类型不匹配

二、数据类型

1. 标量类型

整数:

长度 有符号 无符号
8-bit i8 u8
16-bit i16 u16
32-bit i32(默认) u32
64-bit i64 u64
128-bit i128 u128
arch isize usize
let a: i32 = 42;
let b = 42i64;          // 后缀标注类型
let c = 1_000_000;      // 下划线分隔,提高可读性
let d = 0xff;           // 十六进制
let e = 0o77;           // 八进制
let f = 0b1111_0000;    // 二进制
let g = b'A';           // 字节(仅限 u8)

整数溢出:debug 模式 panic,release 模式按补码环绕。

浮点数:f32 / f64(默认)

let x = 2.0;     // f64
let y: f32 = 3.0;

布尔:bool(true / false)

字符:char,4 字节,Unicode 标量值

let c = 'z';
let cat = '😻';

2. 复合类型

元组 (tuple):固定长度,可异构

fn main() {
    let tup: (i32, f64, &str) = (42, 3.14, "hi");

    // 解构
    let (x, y, z) = tup;
    println!("{} {} {}", x, y, z);

    // 按索引
    println!("first: {}", tup.0);

    // 单元类型 ()
    let unit: () = ();
}

数组 (array):固定长度,同构,栈分配

fn main() {
    let a: [i32; 5] = [1, 2, 3, 4, 5];
    let b = [3; 5]; // [3, 3, 3, 3, 3]

    // 访问
    println!("first: {}", a[0]);

    // 遍历
    for (i, v) in a.iter().enumerate() {
        println!("a[{}] = {}", i, v);
    }

    // 切片:指向数组一部分的视图
    let slice: &[i32] = &a[1..3]; // [2, 3]
}

Vec:动态数组,堆分配。详见 05-集合与字符串.md

3. 类型转换

// 显式转换(无隐式转换)
let a: i32 = 42;
let b: f64 = a as f64;
let c: u8 = a as u8; // 截断

// 字符串解析
let n: i32 = "42".parse().expect("not a number");

三、函数

1. 基本定义

// 无返回值
fn hello() {
    println!("hello");
}

// 有返回值:最后表达式(无分号)隐式返回
fn add(a: i32, b: i32) -> i32 {
    a + b
}

// 显式 return
fn abs(x: i32) -> i32 {
    if x < 0 { return -x; }
    x
}

// 永不返回:! 类型(发散函数)
fn forever() -> ! {
    loop {
        println!("永远");
    }
}

2. 参数

// 值传递
fn value(mut x: i32) {
    x = x * 2; // 局部修改不影响外部
}

// 不可变引用
fn borrow(x: &i32) {
    println!("{}", x);
}

// 可变引用
fn change(x: &mut i32) {
    *x = *x * 2;
}

fn main() {
    let mut n = 10;
    change(&mut n);
    println!("{}", n); // 20
}

3. 多值返回

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

// 推荐:用元组
fn divmod(a: i32, b: i32) -> (i32, i32) {
    (a / b, a % b)
}

四、注释

// 单行注释

/*
    多行注释
    可跨行
*/

/// 文档注释:支持 Markdown
///
/// # Examples
/// ```
/// let x = my_func(2);
/// ```
fn my_func(x: i32) -> i32 { x }

//! 模块级文档:放在文件顶部或模块顶部

五、语句与表达式

fn main() {
    // 语句:执行操作,不返回值
    let x = 5;

    // 表达式:计算并返回值
    let y = {
        let z = x + 1; // 语句
        z * 2          // 表达式,无分号 = 块的返回值
    };
    println!("{}", y); // 12

    // 函数体也是表达式
    let z = {
        1 + 2
    };
}

关键:表达式末尾加分号就变成语句(丢弃值)。

六、控制流

1. if / else if / else

fn main() {
    let n = 6;

    if n % 4 == 0 {
        println!("divisible by 4");
    } else if n % 3 == 0 {
        println!("divisible by 3");
    } else if n % 2 == 0 {
        println!("divisible by 2");
    } else {
        println!("not divisible");
    }

    // if 是表达式,可以赋值
    let desc = if n > 0 { "positive" } else { "non-positive" };
}

2. loop

fn main() {
    // 无限循环 + break 返回值
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2; // break 返回值
        }
    };
    println!("{}", result); // 20

    // 标签循环(嵌套跳出)
    'outer: for i in 0..3 {
        for j in 0..3 {
            if i == 1 && j == 1 {
                break 'outer;
            }
            println!("({}, {})", i, j);
        }
    }
}

3. while

fn main() {
    let mut n = 3;
    while n != 0 {
        println!("{}", n);
        n -= 1;
    }
    println!("LIFTOFF!");
}

4. for

fn main() {
    let a = [10, 20, 30];

    // 遍历数组
    for x in a {
        println!("{}", x);
    }

    // 范围
    for i in 0..5 {           // 0..5 = [0, 5)
        println!("{}", i);
    }

    for i in 0..=5 {          // 0..=5 = [0, 5]
        println!("{}", i);
    }

    // 反向 + 步进
    for i in (0..10).rev().step_by(2) {
        println!("{}", i);    // 8, 6, 4, 2, 0
    }

    // enumerate
    for (i, v) in a.iter().enumerate() {
        println!("a[{}] = {}", i, v);
    }
}

5. match

enum Direction {
    Up,
    Down,
    Left,
    Right,
}

fn describe(d: Direction) -> &'static str {
    match d {
        Direction::Up => "up",
        Direction::Down => "down",
        // 多模式
        Direction::Left | Direction::Right => "horizontal",
    }
}

fn main() {
    // match 必须穷尽(覆盖所有可能)
    let n = 5;
    match n {
        1 => println!("one"),
        2 | 3 | 5 | 7 | 11 => println!("prime"),
        13..=19 => println!("teen"),
        _ => println!("other"),
    }
}

if let(只关心一个分支时):

let some = Some(3);
if let Some(x) = some {
    println!("{}", x);
}

// let...else:不匹配时必须 return / panic
fn parse(s: &str) -> Option<i32> {
    let n = s.parse::<i32>().ok()?; // ? 直接返回 None
    Some(n)
}

fn must_parse(s: &str) -> i32 {
    let Ok(n) = s.parse() else {
        eprintln!("invalid");
        std::process::exit(1);
    };
    n
}

while let:循环直到模式不匹配

let mut stack = vec![1, 2, 3];
while let Some(top) = stack.pop() {
    println!("{}", top);
}

matches! 宏:返回 bool

let x = Some(3);
assert!(matches!(x, Some(3) | Some(5)));
assert!(!matches!(x, None));

七、格式化输出

1. println! / print! / eprintln!

fn main() {
    println!("Hello");                  // Hello
    println!("{}", 42);                  // 42
    println!("{:?}", vec![1, 2, 3]);     // [1, 2, 3]
    println!("{:#?}", vec![1, 2, 3]);    // 美化
    println!("{} {}", "a", "b");          // a b
    println!("{0} {1} {0}", "x", "y");    // x y x

    // 命名参数
    println!("{name} = {value}", name = "x", value = 42);

    // Debug
    println!("{:?}", (1, "two", vec![3])); // (1, "two", [3])
}

2. format!

let s = format!("{}-{}-{}", "tic", "tac", "toe");

3. 进制与宽度

println!("{:b}", 10);      // 1010
println!("{:o}", 10);      // 12
println!("{:x}", 255);     // ff
println!("{:X}", 255);     // FF
println!("{:>10}", "hi");  // 右对齐宽度 10
println!("{:<10}", "hi");  // 左对齐
println!("{:^10}", "hi");  // 居中
println!("{:0>5}", 42);    // 00042 填充 0
println!("{:.2}", 3.14159); // 3.14 保留 2 位小数

八、关键字速查

类别 关键字
控制流 if else loop while for match break continue return
定义 fn let const static struct enum trait impl mod use pub
类型 type as where
模式 Some None
错误 panic!
其他 self Self super crate as ref move mut dyn async await

九、要点速记

  • 变量默认不可变,加 mut 才可变
  • const 必须显式标注类型,运行时不可改
  • 遮蔽可改变类型,mut 不可
  • 整数默认 i32,浮点默认 f64
  • char 是 Unicode 4 字节,&str 是 UTF-8 字节序列
  • 数组 [T; N] 栈分配,长度固定;Vec<T> 堆分配,可变长
  • Rust 无隐式类型转换,必须 as 或 From/Into
  • 函数最后表达式(无分号)是返回值
  • 表达式 ≠ 语句:加 ; 变成语句,值被丢弃
  • loop 可带 break value 返回值,while/let 直到模式不匹配
  • if 是表达式,可赋值
  • match 必须穷尽,_ 通配
  • if let / while let / let...else 是 match 简化
  • println!("{:?}") Debug 格式,{} Display 格式

九、综合实战:命令行计算器 (calc_cli)

多文件项目,综合运用变量、类型、控制流、函数。

1. 项目结构

calc_cli/
├── Cargo.toml
└── src/
    ├── main.rs        # 入口(CLI 解析)
    ├── lib.rs         # 库入口
    ├── ops.rs         # 运算逻辑
    ├── parser.rs      # 表达式解析
    └── error.rs       # 错误类型

2. Cargo.toml

[package]
name = "calc_cli"
version = "0.1.0"
edition = "2021"

3. src/error.rs

use thiserror::Error;

#[derive(Error, Debug)]
pub enum CalcError {
    #[error("无效 token: {0}")]
    InvalidToken(String),

    #[error("语法错误: {0}")]
    Syntax(String),

    #[error("除数为零")]
    DivideByZero,
}

pub type Result<T> = std::result::Result<T, CalcError>;

4. src/ops.rs - 基本运算

use crate::error::{CalcError, Result};

pub fn add(a: f64, b: f64) -> f64 { a + b }
pub fn sub(a: f64, b: f64) -> f64 { a - b }
pub fn mul(a: f64, b: f64) -> f64 { a * b }

pub fn div(a: f64, b: f64) -> Result<f64> {
    if b == 0.0 {
        Err(CalcError::DivideByZero)
    } else {
        Ok(a / b)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add() {
        assert_eq!(add(1.0, 2.0), 3.0);
    }

    #[test]
    fn test_div_by_zero() {
        assert!(matches!(div(1.0, 0.0), Err(CalcError::DivideByZero)));
    }
}

5. src/parser.rs - 表达式解析

use crate::error::{CalcError, Result};
use crate::ops;

/// Token 类型
#[derive(Debug, Clone, PartialEq)]
pub enum Token {
    Number(f64),
    Plus,
    Minus,
    Star,
    Slash,
    LParen,
    RParen,
}

/// 词法分析
pub fn tokenize(s: &str) -> Result<Vec<Token>> {
    let mut tokens = Vec::new();
    let mut chars = s.chars().peekable();

    while let Some(&c) = chars.peek() {
        match c {
            ' ' | '\t' => { chars.next(); }
            '+' => { chars.next(); tokens.push(Token::Plus); }
            '-' => { chars.next(); tokens.push(Token::Minus); }
            '*' => { chars.next(); tokens.push(Token::Star); }
            '/' => { chars.next(); tokens.push(Token::Slash); }
            '(' => { chars.next(); tokens.push(Token::LParen); }
            ')' => { chars.next(); tokens.push(Token::RParen); }
            '0'..='9' | '.' => {
                let mut num = String::new();
                while let Some(&c) = chars.peek() {
                    if c.is_ascii_digit() || c == '.' {
                        num.push(c);
                        chars.next();
                    } else {
                        break;
                    }
                }
                let n: f64 = num.parse()
                    .map_err(|_| CalcError::InvalidToken(num.clone()))?;
                tokens.push(Token::Number(n));
            }
            _ => return Err(CalcError::InvalidToken(c.to_string())),
        }
    }

    Ok(tokens)
}

/// 简单计算:支持两个操作数 + 一个运算符
pub fn eval_two_op(a: f64, op: char, b: f64) -> Result<f64> {
    match op {
        '+' => Ok(ops::add(a, b)),
        '-' => Ok(ops::sub(a, b)),
        '*' => Ok(ops::mul(a, b)),
        '/' => ops::div(a, b),
        _ => Err(CalcError::Syntax(format!("未知运算符 {}", op))),
    }
}

/// 解析 "1 + 2" 形式
pub fn parse_simple(expr: &str) -> Result<f64> {
    let tokens = tokenize(expr)?;

    if tokens.len() != 3 {
        return Err(CalcError::Syntax(format!("期望 3 个 token,得到 {}", tokens.len())));
    }

    let a = match &tokens[0] {
        Token::Number(n) => *n,
        _ => return Err(CalcError::Syntax("首个 token 应为数字".into())),
    };
    let op = match &tokens[1] {
        Token::Plus => '+',
        Token::Minus => '-',
        Token::Star => '*',
        Token::Slash => '/',
        _ => return Err(CalcError::Syntax("中间 token 应为运算符".into())),
    };
    let b = match &tokens[2] {
        Token::Number(n) => *n,
        _ => return Err(CalcError::Syntax("末尾 token 应为数字".into())),
    };

    eval_two_op(a, op, b)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_tokenize() {
        let tokens = tokenize("1 + 2").unwrap();
        assert_eq!(tokens, vec![Token::Number(1.0), Token::Plus, Token::Number(2.0)]);
    }

    #[test]
    fn test_parse_simple() {
        assert_eq!(parse_simple("3 + 4").unwrap(), 7.0);
        assert_eq!(parse_simple("10 / 2").unwrap(), 5.0);
    }
}

6. src/lib.rs

pub mod error;
pub mod ops;
pub mod parser;

pub use error::{CalcError, Result};
pub use parser::{parse_simple, tokenize, Token};

7. src/main.rs

use calc_cli::{parse_simple, CalcError};
use std::io::{self, Write};

fn main() {
    println!("简易计算器 (输入 'quit' 退出)");
    println!("支持格式: <num> <op> <num>,例如 3 + 4");

    loop {
        print!("> ");
        io::stdout().flush().unwrap();

        let mut input = String::new();
        match io::stdin().read_line(&mut input) {
            Ok(0) => break,
            Ok(_) => {}
            Err(_) => break,
        }

        let expr = input.trim();
        if expr == "quit" || expr == "exit" {
            break;
        }
        if expr.is_empty() {
            continue;
        }

        match parse_simple(expr) {
            Ok(v) => println!("= {}", v),
            Err(CalcError::DivideByZero) => println!("错误: 除数不能为零"),
            Err(e) => println!("错误: {}", e),
        }
    }
}

8. 运行

cargo run
# 简易计算器 (输入 'quit' 退出)
# 支持格式: <num> <op> <num>,例如 3 + 4
# > 3 + 4
# = 7
# > 10 / 0
# 错误: 除数不能为零
# > quit

9. 关键点

概念 用法
模块拆分 按职责分文件(error/ops/parser)
thiserror 库层自定义错误
Result<T> 库层类型别名
模式匹配 match c { '0'..='9' => ... } 范围匹配
字符串解析 s.parse::<f64>()
chars().peekable() 流式字符处理
模块测试 #[cfg(test)] mod tests