零基础小白入门 Rust：从环境搭建到核心语法，一篇吃透

大家好！我是刚入门 Rust 的小白，最近花了两周时间梳理了 Rust 基础语法，发现它虽然以 “难学” 著称，但只要避开复杂概念，从 “能用” 到 “理解” 逐步推进，其实很容易上手。这篇博客会带大家从 0 开始，用最通俗的语言和最简单的代码，掌握 Rust 必备语法。

一、先搞定环境：3 步安装 Rust

学任何语言第一步都是搭环境，Rust 官方提供了超简单的安装工具，全程点击下一步就行。

1. 下载安装工具

• Windows：打开 Rust 官网，点击 “Download rustup-init.exe”，下载后双击运行。
• Mac**/Linux**：打开终端，执行命令：

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

2. 安装过程（关键一步）

运行安装程序后，会看到这样的界面：

1) Proceed with installation (default)
2) Customize installation
3) Cancel installation

直接按 Enter 选默认安装（1），等待 1-3 分钟（会自动下载 Rust 编译器和工具链）。

3. 验证是否安装成功

• 打开新的终端（旧终端可能不生效），输入以下命令：

rustc --version  # 查看 Rust 编译器版本

cargo --version  # 查看 Rust 包管理器版本

如果能看到类似 rustc 1.75.0 (82e1608df 2023-12-21) 的输出，说明安装成功！

二、第一个 Rust 程序：Hello World

和所有语言一样，先写个 Hello World 找找感觉。Rust 有个官方工具 cargo，能帮我们快速创建项目、编译和运行代码，不用手动管文件结构。

1. 用 cargo 创建项目

打开终端，执行命令（hello_rust 是项目名，可自定义）：

cargo new hello_rust

cd hello_rust  # 进入项目目录

此时会生成这样的文件结构：

hello_rust/
├─ src/          # 代码文件夹
│  └─ main.rs    # 主程序文件（我们主要写这里）
└─ Cargo.toml    # 项目配置文件（类似说明书）

2. 查看默认代码

打开 src/main.rs，会看到 Rust 自动生成的 Hello World 代码：

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

我们来拆解一下这几行代码：

• fn main()：定义一个函数，fn 是 “函数” 的关键字，main 是函数名（Rust 程序的入口函数，必须有），() 里表示没有参数，{} 是函数体。
• println!("Hello, world!");：打印内容到终端。注意两点：

1. println! 后面有个 !，表示这是 Rust 的 “宏”（可以理解为特殊的函数，后面会讲）；
2. 语句结尾必须加 ;（Rust 用 ; 表示语句结束，和 JavaScript、C++ 类似）。

3. 运行程序

在项目目录下（hello_rust 里），执行命令：

cargo run

第一次运行会编译代码，之后会直接运行，终端会输出：

Compiling hello_rust v0.1.0 (/xxx/hello_rust)
    Finished dev [unoptimized + debuginfo] target(s) in 0.5s
     Running `target/debug/hello_rust`
Hello, world!

看到 Hello, world! 就说明成功啦！

注意：这里小编上次的虚拟环境python没退，所以有（.venu）。不用在意这个 **<font style="background-color:rgb(247,105,100);">(.venv)</font>**，它只是 Python 虚拟环境的激活提示。

三、变量与数据类型：Rust 最基础的 “容器”

变量是用来存数据的 “容器”，Rust 对变量的要求比较严格，比如 “默认不可改”“必须有明确类型”，但这些规则其实是帮我们少踩坑。

1. 定义变量：let 关键字

先看一段代码，在 main.rs 里写：

fn main() {
    // 定义一个不可改的变量（默认）
    let a = 10;
    println!("a 的值：{}", a);  // 输出：a 的值：10

    // 定义一个可改的变量（加 mut 关键字）
    let mut b = 20;
    b = b + 5;  // 可以修改
    println!("b 的值：{}", b);  // 输出：b 的值：25

    // 定义时指定类型（推荐新手这么做，更清晰）
    let c: i32 = 30;  // i32 表示“32位整数”
    println!("c 的值：{}", c);  // 输出：c 的值：30
}

关键知识点：

• 默认不可变：Rust 变量默认不能修改（类似 Python 的 const），如果要修改，必须在变量名前加 mut（mut 是 mutable 的缩写，“可变的”）。
• 类型推断：Rust 能自动判断变量类型（比如 let a = 10 会推断为 i32），但新手建议显式写类型（let a: i32 = 10），避免 confusion。
• 打印变量：println!("a 的值：{}", a) 里的 {} 是 “占位符”，后面的 a 会替换占位符，和 Python 的 print(f"a 的值：{a}") 类似。

2. 常用数据类型：先学 4 种最常用的

Rust 数据类型分 “标量类型”（单个值）和 “复合类型”（多个值），新手先掌握这 4 种：

类型分类	具体类型	说明	示例
整数	i32	32 位有符号整数（最常用）	let a: i32 = -100;
浮点数	f64	64 位浮点数（精度高，最常用）	let b: f64 = 3.14;
布尔值	bool	只有 true/false 两个值	let c: bool = true;
字符串	&str	字符串切片（暂时理解为 “字符串”）	let d: &str = "hello";

代码示例：

fn main() {
    let age: i32 = 25;          // 整数
    let height: f64 = 1.75;     // 浮点数
    let is_student: bool = true;// 布尔值
    let name: &str = "xiaoming";     // 字符串
    println!("年龄：{}", age);
    println!("身高：{}", height);
    println!("是否学生：{}", is_student);
    println!("姓名：{}", name);
}

运行后会输出：

四、函数：把代码打包成 “工具”

函数是用来封装重复代码的，比如写一个 “计算两数之和” 的函数，之后每次用都不用重写逻辑。

1. 定义函数：fn 关键字

Rust 函数定义格式：

fn 函数名(参数1: 类型1, 参数2: 类型2) -> 返回值类型 {
// 函数体
返回值  // 不用写 return（最后一行表达式就是返回值）
}

示例：写一个 “计算两数之和” 的函数：

fn main() {
    // 调用函数，接收返回值
    let result = add(10, 20);
    println!("10 + 20 = {}", result);  // 输出：10 + 20 = 30
}

// 定义“加法函数”：参数是两个 i32，返回值是 i32
fn add(a: i32, b: i32) -> i32 {
    a + b  // 最后一行表达式是返回值，不用写 return
}

关键知识点：

• 参数必须写类型：Rust 不会推断函数参数的类型，必须显式写（比如 add(a: i32, b: i32)，不能只写 add(a, b)）。
• 返回值两种写法：

1. 简单返回：最后一行表达式直接写返回值（如 a + b），不用 ;（如果加了 ;，会变成 “语句”，没有返回值）；
2. 复杂返回：用 return 关键字（比如条件判断后返回），示例：

fn max(a: i32, b: i32) -> i32 {
    if a > b {
        return a;  // 条件满足时返回 a
    }
    b  // 条件不满足时返回 b
}

fn main() {
    let result = add(5, 10);
    println!("The sum is: {}", result);
    let max1 = max(5, 10);
    println!("The max is: {}", max1);
    fn add(a: i32, b: i32) -> i32 {
        a + b
    }
    fn max(a: i32, b: i32) -> i32 {
        if a > b {
            return a
        }
        b
    }
}

2. 调用函数：直接写函数名 + 参数

和其他语言一样，调用函数时直接写函数名，参数按定义顺序传：

fn main() {
    let m = max(15, 25);
    println!("最大值：{}", m);  // 输出：最大值：25
}

fn max(a: i32, b: i32) -> i32 {
    if a > b { a } else { b }  // 简化写法：if 表达式作为返回值
}

五、条件判断：让程序 “做选择”

条件判断就是让程序根据不同情况执行不同代码，比如 “如果年龄大于 18，输出成年，否则输出未成年”。

1. if-else 语句：最基础的判断

Rust 的 if-else 和其他语言类似，但有个特点：条件不用加括号（()），代码块必须加花括号（{}）。

示例：判断年龄是否成年：

fn main() {
    let age: i32 = 20;

    if age >= 18 {
        println!("成年了，可以独立生活啦！");
    } else {
        println!("未成年，要好好读书哦！");
    }
}

运行输出：成年了，可以独立生活啦！

如果有多个条件，用 else if：

fn main() {
    let score: i32 = 85;

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

运行输出：良好

2. if 表达式：可以当值用

Rust 的 if 不仅是 “语句”，还能当 “表达式”（有返回值），比如用 if 给变量赋值：

fn main() {
    let age: i32 = 17;
// 用 if 表达式给变量赋值
let status = if age >= 18 { "成年" } else { "未成年" };

println!("状态：{}", status);  // 输出：状态：未成年
}

注意：if 和 else 分支的返回值类型必须一致（比如上面都是字符串 &str），否则会报错。

六、循环：让程序 “重复做”

循环用来重复执行一段代码，Rust 有 3 种循环：loop（无限循环）、while（条件循环）、for（遍历循环），新手先学最常用的 while 和 for。

1. while 循环：条件满足就循环

while 循环格式：while 条件 { 循环体 }，条件为 true 时执行循环体，为 false 时退出。

示例：从 1 数到 5：

fn main() {
    let mut num: i32 = 1;  // 可变变量，初始值 1

    while num <= 5 {
        println!("num：{}", num);
        num = num + 1;  // 每次加 1，避免无限循环
    }
}

运行输出：

注意：一定要让条件最终变为 false（比如 num 每次加 1），否则会无限循环，按 Ctrl+C 可以终止。

2. for 循环：遍历集合（最常用）

for 循环用来遍历 “集合”（比如范围、数组），比 while 更简洁，还不用担心无限循环。

最常用的场景：遍历一个范围（用 a..b 表示从 a 到 b-1 的所有数）：

fn main() {
    // 遍历 1 到 5（包括 1，不包括 6，所以是 1-5）
    for num in 1..6 {
        println!("num：{}", num);
    }
}

运行输出和上面的 while 示例一样。

如果要包含最后一个数，用 a..=b（比如 1..=5 表示 1-5）：

fn main() {
    for num in 1..=5 {
        println!("当前数字：{}", num);
    }
}

七、数组：存多个相同类型的值

数组是用来存多个 “相同类型” 数据的集合，比如存 5 个学生的成绩、3 个颜色名称。

1. 定义数组：[类型；长度]

Rust 数组定义格式：let 数组名: [类型; 长度] = [值1, 值2, ...];，长度必须是固定的（不能动态增加或减少）。

示例：定义一个 “成绩数组”：

fn main() {
    // 定义数组：类型是 i32，长度是 5，值是 5 个成绩
    let scores: [i32; 5] = [90, 85, 95, 88, 92];

    // 访问数组元素：用索引（从 0 开始）
    println!("第一个成绩：{}", scores[0]);  // 输出：90
    println!("第三个成绩：{}", scores[2]);  // 输出：95

    // 遍历数组（用 for 循环）
    println!("所有成绩：");
    for score in scores {
        println!("{}", score);
    }
}

运行输出：

2. 注意：数组索引不能越界

Rust 会严格检查数组索引，如果访问不存在的索引（比如数组长度是 5，访问索引 5），会直接报错：

fn main() {
    let scores: [i32; 5] = [90, 85, 95, 88, 92];
    println!("第六个成绩：{}", scores[5]);  // 错误：索引 5 不存在（最大是 4）
}

运行后会报错：thread 'main' panicked at 'index out of bounds: the len is 5 but the index is 5'，这是 Rust 安全特性的体现，避免了其他语言中常见的 “数组越界” 漏洞。

八、总结：新手入门的 3 个关键建议

1. 先 “跑通” 再 “理解”：Rust 有很多复杂概念（比如所有权），新手不用一开始就死磕，先把变量、函数、循环这些基础语法用起来，写几个小例子（比如计算平均数、打印乘法表），再逐步深入。
2. 善用 cargo 工具：用 cargo new 创建项目，cargo run 运行代码，cargo check 检查语法错误（比 cargo run 快），这些工具能帮你少走很多弯路。
3. 别怕报错，认真看错误信息：Rust 编译器的错误信息非常友好，会告诉你哪里错了、怎么改，比如 “变量不可改，加 mut”

想了解更多关于Rust语言的知识及应用，可前往华为开放原子旋武开源社区（https://xuanwu.openatom.cn/），了解更多资讯～