在上一篇中我们了解了变量与类型，本篇将深入函数、表达式与控制流的使用，让你的代码更具逻辑性。

一、函数定义与调用

函数是组织和复用代码的基本单元。在 Rust 中，使用 fn 关键字定义函数：

/// 计算两个数字的和
/// 
/// # 参数
/// * `a` - 第一个数字
/// * `b` - 第二个数字
/// 
/// # 返回值
/// 返回两个数字的和
fn add(a: i32, b: i32) -> i32 {
    a + b  // 最后一行表达式为函数返回值
}

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

• fn：定义函数
• add：函数名
• (a: i32, b: i32)：参数列表，格式为 名称: 类型
• -> i32：返回类型
• 函数体最后一个表达式不加分号，作为返回值

函数的所有权规则

fn main() {
    let s = String::from("hello");
    takes_ownership(s);    // s 的所有权被移动到函数中
    // println!("{}", s);  //  错误：s 已经被移动

    let x = 5;
    makes_copy(x);         // x 是 i32，实现了 Copy trait
    println!("{}", x);     //  正确：x 仍然可用
}

fn takes_ownership(some_string: String) {
    println!("{}", some_string);
} // some_string 在这里离开作用域并被丢弃

fn makes_copy(some_integer: i32) {
    println!("{}", some_integer);
} // some_integer 在这里离开作用域

函数返回值与所有权

fn main() {
    let s1 = gives_ownership();         // 函数返回值所有权移给 s1
    let s2 = String::from("hello");     // s2 进入作用域
    let s3 = takes_and_gives_back(s2);  // s2 被移动到函数中，返回值所有权移给 s3
} // s3 离开作用域并被丢弃，s2 已被移动，s1 离开作用域并被丢弃

fn gives_ownership() -> String {
    let some_string = String::from("hello");
    some_string  // 返回 some_string 并移出给调用者
}

fn takes_and_gives_back(a_string: String) -> String {
    a_string  // 返回 a_string 并移出给调用者
}

二、表达式（Expression）与语句（Statement）

o 表达式 会计算并返回值，如函数调用或算术运算：

let x = 5 + 6;         // 5 + 6 是表达式，返回 11
let y = {
    let z = 3;
    z + 2              // 块表达式，返回 5
};

o 语句 执行动作但不返回值，以分号结尾：

let x = 5;             // 这是语句

表达式的类型

1. 字面量表达式

let x = 42;              // 整数字面量
let y = 3.14;            // 浮点数字面量
let z = "hello";         // 字符串字面量

2. 运算符表达式

let sum = 1 + 2;         // 算术运算符
let eq = 1 == 2;         // 比较运算符
let and = true && false; // 逻辑运算符

3. 块表达式

let result = {
    let x = 10;
    let y = 20;
    x + y                // 块表达式的返回值
};

4. if 表达式

// a b 变量需自定义
let max = if a > b { a } else { b };

表达式优先级

Rust 中常见的运算符优先级（从高到低）：

1. 一元运算符：!, -, *, &, &mut

2. 算术运算符：*, /, %, +, -

3. 位移运算符：<<, >>

4. 位运算符：&, |, ^

5. 比较运算符：==, !=, <, >, <=, >=

6. 逻辑运算符：&&, ||

let result = 2 + 3 * 4;  // 等价于 2 + (3 * 4)

三、if条件表达式

if 在 Rust 中是表达式，可直接赋值：

let number = 7;
let kind = if number % 2 == 0 {
    "偶数"
} else {
    "奇数"
};
println!("{} 是 {}", number, kind);

注意：所有分支须返回相同类型。

四、loop无限循环

loop 用于创建无限循环，可用 break 退出，并可返回值：

let mut counter = 0;
let result = loop {
    counter += 1;
    if counter == 4 {
        break counter * 2;
    }
};
println!("结果是 {}", result);  // 结果是 8

循环标签

当有嵌套循环时，可以使用标签来指定 break 或 continue 的目标：

'outer: loop {
    println!("进入外层循环");
    'inner: loop {
        println!("进入内层循环");
        break 'outer;  // 直接跳出外层循环
    }
    println!("这行永远不会执行");
}

break 和 continue 的更多用法

// break 可以返回值
// some_condition 变量需自定义
let result = loop {
    if some_condition {
        break 42;  // 返回 42
    }
};

// continue 跳过当前迭代
for i in 0..5 {
    if i == 2 {
        continue;  // 跳过 2
    }
    println!("{}", i);  // 打印 0,1,3,4
}

五、while条件循环

当条件满足时重复执行：

let mut n = 3;
while n != 0 {
    println!("{}!", n);
    n -= 1;
}
println!("开始执行!");

六、for范围循环

遍历范围或集合：

for i in 0..5 {
    println!("i = {}", i);  // 0,1,2,3,4
}

// 倒序
for i in (1..=3).rev() {
    println!("{}", i);      // 3,2,1
}

七、练习题（动手最重要）

1. 定义函数 is_even(n: i32) -> bool，在 main 中测试。

2. 使用 if 表达式实现成绩评级：90+ A，>=60 B，否则 C。

3. 用 loop 计算 1 到 5 的累加和，并返回结果。

4. 用 while 实现倒计时，从 5 到 1。

5. 用 for 循环打印数组 ["rust", "by", "example"] 中的每个元素。

八、小结

本篇我们学习了：

• 函数的定义与调用
• 表达式与语句的区别
• 核心控制流关键字：if, loop, while, for

九、下一篇预告

下一篇我们将进入 所有权、借用与生命周期，探索 Rust 安全性的核心机制，敬请期待！

欢迎关注、收藏和转发，也可以留言你最想了解的内容，有任何问题可以留言或私信，我会尽力解答！

喜欢编程、区块链、Web3

可加好友