Rust 函数在 Rust 中，函数是组织和复用代码的重要方式，它可以将一段特定的功能封装起来，便于调用和维护 --

在 Rust 中，函数是组织和复用代码的重要方式，它可以将一段特定的功能封装起来，便于调用和维护。

1. 函数定义与基本语法

使用 fn 关键字来定义函数，函数名遵循蛇形命名法（小写字母加下划线），函数体包含在花括号 {} 内。函数可以有参数和返回值，也可以没有。

fn add(a: i32, b: i32) -> i32 { 
    a + b 
} 
fn print_hello() {
    println!("Hello!");
} 
fn main() {
    let result = add(3, 5);
    println!("The result of addition is: {}", result);
    print_hello();
}

在上述代码中，add 函数接受两个 i32 类型的参数 a 和 b，并返回它们的和，返回值类型为 i32；print_hello 函数没有参数和返回值，功能是打印字符串 "Hello!"。

2. 函数参数

函数可以接受零个或多个参数，每个参数都必须显式指定类型。参数在函数签名中以逗号分隔，形式为 参数名: 类型。

fn multiply(a: f64, b: f64) -> f64 {
    a * b 
} 
fn main() {
    let product = multiply(2.5, 3.0);
    println!("The product is: {}", product); 
}

这里 multiply 函数接受两个 f64 类型的参数 a 和 b，返回它们的乘积。

3. 函数返回值

函数可以通过 -> 符号指定返回值类型。函数体中的最后一个表达式的值就是函数的返回值，不需要使用 return 关键字（但也可以使用 return 提前返回）。

fn subtract(a: i32, b: i32) -> i32 {
    // 这里不需要显式的 return 语句 
    a - b 
} 
fn early_return(a: i32, b: i32) -> i32 {
    if a < b { 
        return 0; 
    }
    a - b 
} 
fn main() { 
    let diff = subtract(8, 3);
    println!("The difference is: {}", diff); 
    let early_result = early_return(2, 5); 
    println!("Early return result: {}", early_result); 
}

subtract 函数通过最后一个表达式 a - b 返回结果；early_return 函数在 a < b 的条件下使用 return 提前返回 0。

4. 函数调用

在其他函数中通过函数名和传递相应的参数来调用函数。函数调用的结果可以赋值给变量，也可以直接使用。

fn square(x: i32) -> i32 { 
    x * x 
} 
fn main() { 
    let num = 7;
    let squared_num = square(num); 
    println!("The square of {} is {}", num, squared_num); 
}

这里在 main 函数中调用了 square 函数，并将返回值赋值给 squared_num 变量。

5. 函数作为参数和返回值

Rust 支持函数作为参数传递给其他函数（高阶函数），也支持函数返回另一个函数。

fn add_one(x: i32) -> i32 { 
    x + 1 
} 
fn apply_twice(func: fn(i32) -> i32, num: i32) -> i32 {
    func(func(num)) 
} 
fn main() { 
    let result = apply_twice(add_one, 5); 
    println!("Applying add_one twice to 5 gives: {}", result); 
}

apply_twice 函数接受一个函数 func（类型为 fn(i32) -> i32）和一个 i32 类型的参数 num，将 func 函数应用两次到 num 上并返回结果。

6. 外部函数（`extern` 函数）

没用到过，用到再说

7. 闭包（Closure）

闭包是一种可以捕获其环境中变量的匿名函数。

fn main() { 
    let factor = 2; 
    let multiply_by_factor = |x| x * factor; 
    let result = multiply_by_factor(5); 
    println!("The result of multiplication is: {}", result); 
}

这里定义了一个闭包 multiply_by_factor，它捕获了外部变量 factor，并返回参数 x 与 factor 的乘积。

Rust 函数的这些特性使得代码组织更加清晰，提高了代码的复用性和可维护性。

Rust 函数