Rust基础语法¶

📚 章节概述¶

本章将介绍 Rust 的基础语法，包括变量、数据类型、函数和控制流。这些是编写 Rust 程序的基础，掌握它们将为后续学习打下坚实基础。

🎯 学习目标¶

理解 Rust 的变量和可变性
掌握基本数据类型
学会定义和使用函数
掌握控制流语句（if、loop、for、while）
理解注释的使用

📖 变量与可变性¶

1.1 变量声明¶

在 Rust 中，变量默认是不可变的：

Rust

fn main() {  // fn main() Rust程序入口函数
    let x = 5;
    println!("The value of x is: {}", x);
    x = 6; // 编译错误！不能给不可变变量赋值
}

1.2 可变变量¶

使用 mut 关键字声明可变变量：

Rust

fn main() {
    let mut x = 5;  // let mut 声明可变变量
    println!("The value of x is: {}", x);
    x = 6;
    println!("The value of x is: {}", x);
}

1.3 变量遮蔽¶

Rust 允许声明同名变量，这称为遮蔽：

Rust

fn main() {
    let x = 5;
    let x = x + 1;
    let x = x * 2;
    println!("The value of x is: {}", x); // 输出 12
}

遮蔽与 mut 的区别： - 遮蔽创建新变量，可以改变类型 - mut 修改同一变量，不能改变类型

Rust

fn main() {
    let spaces = "   ";
    let spaces = spaces.len(); // 遮蔽，改变类型
    println!("spaces: {}", spaces);

    // 不能这样做：
    // let mut spaces = "   ";
    // spaces = spaces.len(); // 编译错误！类型不匹配
}

🔢 数据类型¶

2.1 标量类型¶

整数类型¶

长度	有符号	无符号
8-bit	`i8`	`u8`
16-bit	`i16`	`u16`
32-bit	`i32`	`u32`
64-bit	`i64`	`u64`
128-bit	`i128`	`u128`
arch	`isize`	`usize`

Rust

fn main() {
    let decimal = 98_222;      // 十进制
    let hex = 0xff;            // 十六进制
    let octal = 0o77;          // 八进制
    let binary = 0b1111_0000;  // 二进制
    let byte = b'A';           // 字节（仅限 u8）

    println!("decimal: {}", decimal);
    println!("hex: {}", hex);
    println!("octal: {}", octal);
    println!("binary: {}", binary);
    println!("byte: {}", byte);
}

浮点类型¶

Rust

fn main() {
    let x = 2.0; // f64
    let y: f32 = 3.0; // f32

    println!("x: {}, y: {}", x, y);
}

布尔类型¶

Rust

fn main() {
    let t = true;
    let f: bool = false; // 显式类型注解

    println!("t: {}, f: {}", t, f);
}

字符类型¶

Rust

fn main() {
    let c = 'z';
    let z = 'ℤ';
    let heart_eyed_cat = '😻';

    println!("c: {}, z: {}, cat: {}", c, z, heart_eyed_cat);
}

2.2 复合类型¶

元组¶

元组可以将多个类型的值组合到一个复合类型中：

Rust

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);

    // 解构元组
    let (x, y, z) = tup;
    println!("The value of y is: {}", y);

    // 访问元组元素
    let five_hundred = tup.0;
    let six_point_four = tup.1;
    let one = tup.2;
    println!("tup.0: {}, tup.1: {}, tup.2: {}", five_hundred, six_point_four, one);
}

数组¶

数组中所有元素的类型必须相同：

Rust

fn main() {
    let a = [1, 2, 3, 4, 5];
    let months = ["January", "February", "March", "April", "May", "June",
                  "July", "August", "September", "October", "November", "December"];

    // 访问数组元素
    let first = a[0];
    let second = a[1];
    println!("first: {}, second: {}", first, second);
}

数组越界：

Rust

fn main() {
    let a = [1, 2, 3, 4, 5];
    let index = 10;
    let element = a[index]; // 运行时 panic！
}

📝 函数¶

3.1 函数定义¶

Rust

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

    another_function();
}

fn another_function() {
    println!("Another function.");
}

3.2 参数¶

Rust

fn main() {
    another_function(5);
    print_labeled_measurement(5, 'h');
}

fn another_function(x: i32) {
    println!("The value of x is: {}", x);
}

fn print_labeled_measurement(value: i32, unit_label: char) {
    println!("The measurement is: {}{}", value, unit_label);
}

3.3 语句和表达式¶

Rust 是基于表达式的语言：

Rust

fn main() {
    // 语句（不返回值）
    let y = 6;

    // 表达式（返回值）
    let x = {
        let y = 3;
        y + 1 // 注意：没有分号
    };

    println!("The value of x is: {}", x);
}

3.4 返回值¶

Rust

fn main() {
    let x = plus_one(5);
    println!("The value of x is: {}", x);
}

fn plus_one(x: i32) -> i32 {
    x + 1 // 表达式，返回值
    // x + 1; // 语句，编译错误！
}

🔄 控制流¶

4.1 if 表达式¶

Rust

fn main() {
    let number = 6;

    if number < 5 {
        println!("condition was true");
    } else {
        println!("condition was false");
    }
}

if 是表达式：

Rust

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };

    println!("The value of number is: {}", number);
}

多重条件：

Rust

fn main() {
    let number = 6;

    if number % 4 == 0 {
        println!("number is divisible by 4");
    } else if number % 3 == 0 {
        println!("number is divisible by 3");
    } else if number % 2 == 0 {
        println!("number is divisible by 2");
    } else {
        println!("number is not divisible by 4, 3, or 2");
    }
}

4.2 循环¶

loop¶

Rust

fn main() {
    loop {
        println!("again!");
        // break; // 退出循环
    }
}

从循环返回值：

Rust

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;
        }
    };

    println!("The result is {}", result);
}

while¶

Rust

fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{}!", number);
        number -= 1;
    }

    println!("LIFTOFF!!!");
}

for¶

Rust

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

    for element in a {
        println!("the value is: {}", element);
    }
}

范围：

Rust

fn main() {
    for number in 1..4 {
        println!("{}!", number);
    }
    println!("LIFTOFF!!!");

    // 包含结束值
    for number in 1..=4 {
        println!("{}!", number);
    }
}

反向遍历：

Rust

fn main() {
    for number in (1..4).rev() {
        println!("{}!", number);
    }
    println!("LIFTOFF!!!");
}

💬 注释¶

5.1 普通注释¶

Rust

fn main() {
    // 这是一个单行注释

    /*
     * 这是一个多行注释
     * 可以跨越多行
     */

    let x = 5 + /* 90 + */ 5; // 行内注释
    println!("The value of x is: {}", x);
}

5.2 文档注释¶

Rust

/// 计算两个数的和
///
/// # 参数
/// * `a` - 第一个数
/// * `b` - 第二个数
///
/// # 返回值
/// 返回两个数的和
fn add(a: i32, b: i32) -> i32 {
    a + b
}

📝 练习题¶

练习 1：温度转换¶

编写一个函数，将摄氏温度转换为华氏温度：

Rust

fn celsius_to_fahrenheit(celsius: f64) -> f64 {
    // TODO: 实现转换公式
    // F = C × 9/5 + 32
    todo!()
}

fn main() {
    let celsius = 25.0;
    let fahrenheit = celsius_to_fahrenheit(celsius);
    println!("{}°C = {}°F", celsius, fahrenheit);
}

练习 2：斐波那契数列¶

使用循环生成前 n 个斐波那契数：

Rust

fn fibonacci(n: usize) -> Vec<u64> {
    // TODO: 实现斐波那契数列生成
    todo!()
}

fn main() {
    let n = 10;
    let fib = fibonacci(n);
    println!("前 {} 个斐波那契数: {:?}", n, fib);
}

练习 3：素数判断¶

编写函数判断一个数是否为素数：

Rust

fn is_prime(n: u32) -> bool {
    // TODO: 实现素数判断
    todo!()
}

fn main() {
    let numbers = [2, 3, 4, 5, 6, 7, 8, 9, 10];
    for &num in &numbers {
        println!("{} is prime: {}", num, is_prime(num));
    }
}

练习 4：猜数字游戏¶

实现一个简单的猜数字游戏：

Rust

use std::io;
use std::cmp::Ordering;
use rand::Rng;

fn main() {
    println!("猜数字游戏！");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    // TODO: 实现游戏逻辑
    // 1. 提示用户输入猜测
    // 2. 读取用户输入
    // 3. 比较猜测和秘密数字
    // 4. 给出提示（太大、太小或正确）
    // 5. 循环直到猜对
}

💡 最佳实践¶

1. 使用有意义的变量名¶

Rust

// 好的变量名
let user_name = "Alice";
let total_price = 100.50;

// 不好的变量名
let x = "Alice";
let y = 100.50;

2. 使用适当的数据类型¶

Rust

// 使用 usize 表示索引
let index: usize = 0;

// 使用 f64 进行浮点运算
let pi: f64 = 3.14159265359;

// 使用 bool 表示布尔值
let is_active: bool = true;

3. 避免魔法数字¶

Rust

// 不好
let area = 3.14159 * radius * radius;

// 好
const PI: f64 = 3.14159265359;
let area = PI * radius * radius;

4. 使用表达式而不是语句¶

Rust

// 不好
fn get_status(code: i32) -> &'static str {
    if code == 200 {
        return "OK";
    } else {
        return "Error";
    }
}

// 好
fn get_status(code: i32) -> &'static str {
    if code == 200 {
        "OK"
    } else {
        "Error"
    }
}

⚠️ 常见错误¶

1. 忘记使用 `mut`¶

Rust

// 错误
let x = 5;
x = 6; // 编译错误

// 正确
let mut x = 5;
x = 6;

2. 数组越界¶

Rust

// 错误（运行时 panic）
let a = [1, 2, 3];
let x = a[3];

// 正确
let a = [1, 2, 3];
if let Some(&x) = a.get(3) {
    println!("{}", x);
} else {
    println!("Index out of bounds");
}

3. 类型不匹配¶

Rust

// 错误
let x: i32 = 5;
let y: i64 = x; // 编译错误

// 正确
let x: i32 = 5;
let y: i64 = x as i64;

📚 扩展阅读¶

🎯 本章小结¶

本章介绍了 Rust 的基础语法，包括：

✅ 变量和可变性
✅ 基本数据类型（整数、浮点数、布尔、字符）
✅ 复合类型（元组、数组）
✅ 函数定义和使用
✅ 控制流（if、loop、while、for）
✅ 注释的使用

下一章： 我们将学习 Rust 最核心的概念——所有权与借用系统。

Rust基础语法¶

📚 章节概述¶

🎯 学习目标¶

📖 变量与可变性¶

1.1 变量声明¶

1.2 可变变量¶

1.3 变量遮蔽¶

🔢 数据类型¶

2.1 标量类型¶

整数类型¶

浮点类型¶

布尔类型¶

字符类型¶

2.2 复合类型¶

元组¶

数组¶

📝 函数¶

3.1 函数定义¶

3.2 参数¶

3.3 语句和表达式¶

3.4 返回值¶

🔄 控制流¶

4.1 if 表达式¶

4.2 循环¶

loop¶

while¶

for¶

💬 注释¶

5.1 普通注释¶

5.2 文档注释¶

📝 练习题¶

练习 1：温度转换¶

练习 2：斐波那契数列¶

练习 3：素数判断¶

练习 4：猜数字游戏¶

💡 最佳实践¶

1. 使用有意义的变量名¶

2. 使用适当的数据类型¶

3. 避免魔法数字¶

4. 使用表达式而不是语句¶

⚠️ 常见错误¶

1. 忘记使用 mut¶

2. 数组越界¶

3. 类型不匹配¶

📚 扩展阅读¶

🎯 本章小结¶

1. 忘记使用 `mut`¶