[Rust]基础语法

3 阅读9分钟

Rust 基础语法

本章面向刚接触 Rust 的读者,只讲最基础的语法:怎么声明变量、有哪些数据类型、怎么写函数、怎么写条件判断和循环。不涉及所有权、生命周期等进阶话题(那些在后面的章节里)。

学完本章,你应该能看懂并写出简单的 Rust 程序,比如:用循环打印九九乘法表、用 if 判断成绩等级。

1. 第一个程序

一个最小的 Rust 程序长这样:

fn main() {
    println!("Hello, world!");
}

逐个拆解:

  • fn 是 function(函数)的关键字,main 是程序的入口,程序从这里开始执行。
  • println!("...") 是打印一行文字的宏(后面带 ! 的都是宏,可以先当成特殊的函数用)。
  • 每条语句以分号 ; 结尾。
  • 花括号 {} 包住函数体。

实际开发中我们用 cargo 管理项目:

cargo new hello    # 创建一个名为 hello 的新项目
cd hello
cargo run          # 编译并运行
cargo check        # 只检查代码能否编译,速度更快
cargo build        # 只编译不运行

2. 变量与 let

2.1 变量默认不可变

Rust 最"反直觉"的一点:用 let 声明的变量默认不可变(immutable) ,赋值后再改会报错。

fn main() {
    let x = 5;
    // x = 6;  // ❌ 编译错误:cannot assign twice to immutable variable
    println!("x = {}", x);
}

想修改变量,要加 mut(mutable 的缩写):

fn main() {
    let mut x = 5;
    println!("x = {}", x);  // x = 5
    x = 6;
    println!("x = {}", x);  // x = 6
}

为什么要默认不可变?这是 Rust 的设计哲学:默认值应该是最安全的选项。大部分变量其实不需要改,默认不可变能帮你避免很多意外的修改。需要改的时候显式写 mut,读代码的人一眼就知道"这个变量会变"。

2.2 声明时必须初始化

Rust 不允许使用未初始化的变量:

fn main() {
    let x: i32;
    // println!("{}", x);  // ❌ 编译错误:使用了可能未初始化的变量
    x = 10;                 // ✅ 先赋值后使用是可以的
    println!("{}", x);
}

2.3 遮蔽(Shadowing)

你可以用 let 重新声明一个同名变量,新变量会"遮蔽"旧变量:

fn main() {
    let x = 5;
    let x = x + 1;      // 遮蔽上一个 x,现在 x 是 6
    let x = x * 2;      // 再次遮蔽,现在是 12
    println!("x = {}", x);

    // 遮蔽甚至可以改变类型!
    let spaces = "   ";         // &str 类型
    let spaces = spaces.len();  // usize 类型,这是合法的
}

遮蔽和 mut 的区别:

mut遮蔽
能否改值✅ 直接赋值改✅ 重新 let 一次
能否改类型❌ 不能✅ 能
是否产生新变量❌ 还是同一个✅ 是新变量

遮蔽在转换场景很常用(比如把字符串解析成数字后还叫同一个名字),不用绞尽脑汁想 x_str、x_num 这种变量名。

3. 基本数据类型

Rust 是静态类型语言:每个变量的类型在编译期就确定了。

3.1 整数

类型位数范围
i8 / u88 位-128127 / 0255
i16 / u1616 位有符号 / 无符号
i32 / u3232 位i32 是默认整数类型
i64 / u6464 位大数场景
i128 / u128128 位极大数
isize / usize随平台索引、集合长度用 usize
  • i 开头是有符号(可正可负),u 开头是无符号(只有 ≥ 0)。
  • 不写类型注解时,整数默认是 i32。
fn main() {
    let a: i32 = 42;        // 显式指定类型
    let b = 42i64;          // 数字后缀指定类型
    let c = 1_000_000;      // 下划线分隔,提高可读性
    let hex = 0xff;         // 十六进制
    let bin = 0b1010;       // 二进制
    let byte = b'A';        // u8 字节
    println!("{} {} {} {} {} {}", a, b, c, hex, bin, byte);
}

整数溢出:debug 模式下溢出会直接 panic(程序崩溃),release 模式下会回绕。不确定就用 i32/i64,别抠位数。

3.2 浮点数

fn main() {
    let x = 2.5;        // 默认 f64(双精度,推荐)
    let y: f32 = 3.14;  // f32(单精度)
    println!("{} {}", x, y);
}

3.3 布尔与字符

fn main() {
    let t = true;
    let f: bool = false;

    let c = 'z';          // char 用单引号
    let heart = '❤';      // char 是 4 字节 Unicode,能存中文和 emoji
    println!("{} {} {} {}", t, f, c, heart);
}

注意区分:字符 'a' 用单引号,字符串 "a" 用双引号。

3.4 字符串速览

基础阶段记住两种:

fn main() {
    let s1 = "hello";           // &str:字符串字面量(切片),不可变
    let s2 = String::from("hello"); // String:拥有所有权的字符串,可增长
    let s3 = String::new();     // 空字符串

    // 常用操作
    let s = String::from("你好");
    let len = s.len();                    // 字节数(中文一个字 3 字节)
    let upper = "abc".to_uppercase();     // 转大写
    let combined = format!("{}-{}", s1, s2); // 拼接推荐用 format!
    println!("{} {} {} {}", len, upper, combined, s3.is_empty());
}

字符串进阶(所有权、切片、生命周期)见第 01、07 章。

3.5 类型转换

Rust 不会自动做隐式类型转换,必须显式转换:

fn main() {
    let x: i32 = 10;
    let y: f64 = x as f64;      // as:基础类型间转换
    let z: i64 = i64::from(x);  // From/Into 转换
    let w: i32 = 100.into();

    // 字符串解析成数字,返回 Result
    let n: i32 = "42".parse().expect("不是合法数字");

    println!("{} {} {} {}", y, z, w, n);
}

4. 元组与数组(复合类型速览)

fn main() {
    // 元组:可以装不同类型的值,长度固定
    let person: (&str, i32) = ("小明", 18);
    let (name, age) = person;              // 解构
    println!("{} 今年 {} 岁", name, person.1); // 索引访问用 .1

    // 数组:同一类型,长度固定
    let arr = [1, 2, 3, 4, 5];
    let zeros = [0; 3];          // [0, 0, 0]
    let first = arr[0];          // 越界访问会 panic
    println!("{} {} {} {}", name, age, first, zeros[2]);
}

长度可变的集合用 Vec(向量)和 HashMap

5. 函数

fn main() {
    let sum = add(3, 5);
    println!("3 + 5 = {}", sum);

    greet("小明");

    // 函数的最后一行表达式就是返回值(不写分号!)
    let doubled = double(21);
    println!("21 翻倍 = {}", doubled);
}

// fn 函数名(参数: 类型) -> 返回类型
fn add(a: i32, b: i32) -> i32 {
    a + b          // 注意:没有分号,这是表达式,作为返回值
}

// 没有返回值的函数不用写 ->
fn greet(name: &str) {
    println!("你好,{}!", name);
}

fn double(x: i32) -> i32 {
    // return x * 2;  // 也可以用 return 提前返回
    x * 2
}

关键规则:

  • 参数必须标注类型,返回值用 -> 类型 标注。
  • 函数体最后一个不带分号的表达式就是返回值。如果加了分号,它就变成语句,返回值就是 ()(空元组,类似其他语言的 void)——这是新手最常见的编译错误来源:
fn add(a: i32, b: i32) -> i32 {
    a + b;   // ❌ 加了分号,返回 () 而不是 i32,编译报类型不匹配
}

6. 注释与打印

fn main() {
    // 这是行注释

    /* 这是
       块注释 */

    let x = 5;

    // println! 的占位符用法
    println!("普通打印:{}", x);
    println!("变量名内插:x = {x}");        // 直接把变量名写进 {}(Rust 2021+)
    println!("调试打印:{:?}", [1, 2, 3]);  // {:?} 打印数组和结构体的调试格式
    println!("保留两位小数:{:.2}", 3.14159);

    // print! 不换行,println! 换行
    print!("不换行");
    println!("换行");
}

7. 控制流

7.1 if / else if / else

条件不需要括号,但花括号必须有:

fn main() {
    let score = 85;

    if score >= 90 {
        println!("优秀");
    } else if score >= 60 {
        println!("及格");
    } else {
        println!("不及格");
    }

    // if 是表达式,可以用来赋值(类似三目运算符,但类型必须一致)
    let level = if score >= 60 { "及格" } else { "不及格" };
    println!("等级:{}", level);
}

注意:Rust 没有 if (score >= 60) { ... } 这种条件外带括号的写法——可以写但编译器会警告,而且 Rust 风格是不加括号。

7.2 loop:无限循环

loop 创建一个死循环,用 break 跳出。它的特别之处:break 可以带返回值。

fn main() {
    let mut count = 0;

    let result = loop {
        count += 1;
        if count == 10 {
            break count * 2;   // break 带值,整个 loop 表达式的值就是 20
        }
    };
    println!("result = {}", result);  // 20
}

continue 跳过本轮循环,进入下一轮。

7.3 while:条件循环

fn main() {
    let mut n = 3;

    while n > 0 {
        println!("{}!", n);
        n -= 1;
    }
    println!("发射!");
}

7.4 for:遍历循环(最常用)

Rust 的 for 只用来遍历,不写 C 风格的 for (i = 0; i < 10; i++)。用区间(Range)代替:

fn main() {
    // 0..5 表示 0,1,2,3,4(不含 5)—— 左闭右开
    for i in 0..5 {
        print!("{} ", i);
    }
    println!();

    // 0..=5 表示 0,1,2,3,4,5(含 5)—— 闭区间
    for i in 0..=5 {
        print!("{} ", i);
    }
    println!();

    // 反向循环
    for i in (1..4).rev() {
        print!("{} ", i);
    }
    println!();

    // 遍历数组
    let arr = [10, 20, 30];
    for x in arr {
        print!("{} ", x);
    }
    println!();

    // 需要下标时用 .enumerate()
    for (i, x) in arr.iter().enumerate() {
        println!("第 {} 个元素是 {}", i, x);
    }
}

九九乘法表练手:

fn main() {
    for i in 1..=9 {
        for j in 1..=i {
            print!("{}x{}={}\t", j, i, i * j);
        }
        println!();
    }
}

7.5 标签:跳出多层循环

嵌套循环中想直接跳出外层,给循环打标签:

fn main() {
    'outer: for i in 1..4 {
        for j in 1..4 {
            if i * j > 4 {
                break 'outer;   // 直接终止外层循环
            }
            print!("({},{}) ", i, j);
        }
    }
    println!();
}

8. 一个综合小例子

猜数字游戏的雏形,串起本章所有知识点:

use std::cmp::Ordering;

fn main() {
    let secret = 42;                       // 不可变变量
    let mut attempts = 0;                  // 可变计数器

    let guesses = [50, 30, 42];            // 模拟三次猜测

    for guess in guesses {
        attempts += 1;
        println!("第 {} 次猜测:{}", attempts, guess);

        match guess.cmp(&secret) {
            Ordering::Less => println!("太小了"),
            Ordering::Greater => println!("太大了"),
            Ordering::Equal => {
                println!("猜对了!共用了 {} 次", attempts);
                break;
            }
        }
    }
}

这里的 match 是 Rust 强大的模式匹配

9. 易错点与陷阱

  1. 忘了分号 / 多了分号:语句要分号,函数最后一行的返回值表达式不要分号。
  2. 整数类型混算:i32 + u64 会编译报错,Rust 不做隐式转换,用 as 统一类型。
  3. .. 和 ..= 搞混:0..5 不含 5,0..=5 含 5。
  4. char 用单引号、字符串用双引号:写反了会报错。
  5. 不可变变量赋值:报 “cannot assign twice to immutable variable” 就加 mut。
  6. 整数溢出:u8 最大 255,255 + 1 在 debug 下 panic。
  7. 数组越界:arr[10] 编译可能通过,运行时 panic。

10. 最佳实践

  • 变量默认 let,确实需要修改才加 mut。
  • 整数拿不准就用 i32,集合索引用 usize。
  • 拼接字符串用 format!,不要手动 +(所有权问题,见第 01 章)。
  • 循环优先用 for + 区间;while 用于条件不明确的场景;loop 用于真正的死循环 + break 返回值。
  • 用 {x} 变量名内插代替 {} + 参数列表,更不容易对错位置。
  • 经常跑 cargo check 快速发现编译错误,比 cargo run 快。

11. 要点回顾

  • let 声明变量,默认不可变;mut 声明可变变量;同名 let 是遮蔽。
  • 类型系统:i32 默认整数,f64 默认浮点,转换必须显式(as)。
  • 函数参数必须标类型,最后一个表达式(无分号)是返回值。
  • if 是表达式可以赋值;条件不加括号。
  • 三种循环:loop(死循环,break 可带值)、while(条件循环)、for(遍历区间/集合,最常用)。
  • break '标签 跳出多层循环。