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
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 |