fn 函数定义 ​

什么是函数 ​

函数是 Rust 程序的基本组成单元,用 fn 关键字定义。每个 Rust 程序都有一个 main 函数作为入口点。函数把一段逻辑封装起来,通过名字调用,可以接收参数、返回值。Rust 的函数命名惯例是蛇形命名法(snake_case)。

rust
// 最简单的函数定义
fn say_hello() {
    println!("你好,Rust!");
}

// 带参数和返回值的函数
fn add(a: i32, b: i32) -> i32 {
    a + b  // 最后一行表达式作为返回值,不加分号
}

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

函数的基本结构 ​

一个完整的函数由以下部分组成:

rust
// fn  函数名(参数列表) -> 返回类型 { 函数体 }
fn calculate_area(width: f64, height: f64) -> f64 {
    width * height
}

// 没有参数、没有返回值(隐式返回 ())
fn print_separator() {
    println!("-------------------");
}

// 没有参数、有返回值
fn get_default_name() -> &'static str {
    "未命名"
}

// 有参数、没有显式返回值
fn greet(name: &str) {
    println!("你好,{}!", name);
}

fn main() {
    print_separator();
    greet(get_default_name());
    println!("面积:{}", calculate_area(10.0, 5.5));
    print_separator();
}

函数的声明位置 ​

Rust 的函数可以定义在 main 之前或之后,也可以定义在模块内部。只要在同一个作用域中能访问到,声明顺序不影响调用。

rust
fn main() {
    // 调用定义在 main 之后的函数
    let result = multiply(6, 7);
    println!("6 * 7 = {}", result);

    // 调用嵌套模块中的函数
    helpers::print_info();
}

// 定义在 main 之后,完全没问题
fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

// 函数可以定义在模块中
mod helpers {
    pub fn print_info() {
        println!("这是辅助模块中的函数");
    }
}

函数体是代码块 ​

函数体是一个代码块(用 {} 包围),代码块的最后一个表达式(不加分号)就是函数的返回值。

rust
fn max_of_three(a: i32, b: i32, c: i32) -> i32 {
    // 函数体可以包含多条语句
    let mut result = a;

    if b > result {
        result = b;
    }

    if c > result {
        result = c;
    }

    // 最后一行是表达式(不加分号),作为返回值
    result
}

fn describe_number(n: i32) -> String {
    // if 表达式可以直接作为返回值
    if n > 0 {
        format!("{} 是正数", n)
    } else if n < 0 {
        format!("{} 是负数", n)
    } else {
        String::from("零")
    }
}

fn main() {
    println!("最大值:{}", max_of_three(10, 25, 18));
    println!("{}", describe_number(-7));
    println!("{}", describe_number(0));
}

提前返回 ​

用 return 关键字可以在函数中间提前返回。Rust 的惯例是在函数末尾用尾部表达式返回值,只在需要提前退出时使用 return。

rust
fn find_first_negative(numbers: &[i32]) -> Option<i32> {
    for &num in numbers {
        if num < 0 {
            return Some(num);  // 找到就提前返回
        }
    }
    None  // 没找到,尾部表达式返回
}

fn validate_age(age: i32) -> Result<i32, String> {
    if age < 0 {
        return Err(String::from("年龄不能为负数"));
    }
    if age > 150 {
        return Err(String::from("年龄不合理"));
    }
    Ok(age)  // 验证通过
}

fn main() {
    let nums = [5, 12, -3, 8, -7];
    println!("第一个负数:{:?}", find_first_negative(&nums));
    println!("验证 25:{:?}", validate_age(25));
    println!("验证 -5:{:?}", validate_age(-5));
}

发散函数 ​

返回类型为 !(never 类型)的函数叫做发散函数——它永远不会正常返回。常见的发散函数包括 panic!、无限循环、std::process::exit。

rust
// 发散函数:永远不会正常返回
fn forever() -> ! {
    loop {
        // 无限循环
    }
}

// panic 也是发散的
fn crash(message: &str) -> ! {
    panic!("致命错误:{}", message);
}

fn main() {
    let value: i32 = if true {
        42
    } else {
        // crash 返回 !,! 可以被当作任意类型使用
        crash("不可能到达这里")
    };
    println!("{}", value);
}

基本示例 ​

一个简单的温度转换工具:

rust
// 摄氏度转华氏度
fn celsius_to_fahrenheit(c: f64) -> f64 {
    c * 9.0 / 5.0 + 32.0
}

// 华氏度转摄氏度
fn fahrenheit_to_celsius(f: f64) -> f64 {
    (f - 32.0) * 5.0 / 9.0
}

// 格式化温度显示
fn format_temp(value: f64, unit: &str) -> String {
    format!("{:.1}°{}", value, unit)
}

// 温度分类
fn classify_celsius(c: f64) -> &'static str {
    if c < 0.0 {
        "严寒"
    } else if c < 10.0 {
        "寒冷"
    } else if c < 20.0 {
        "凉爽"
    } else if c < 30.0 {
        "舒适"
    } else if c < 40.0 {
        "炎热"
    } else {
        "酷热"
    }
}

fn main() {
    let temps_c = [0.0, 15.0, 25.0, 37.0, 100.0];

    println!("{:<12} {:<12} {}", "摄氏", "华氏", "体感");
    println!("{}", "-".repeat(36));

    for &c in &temps_c {
        let f = celsius_to_fahrenheit(c);
        println!("{:<12} {:<12} {}",
            format_temp(c, "C"),
            format_temp(f, "F"),
            classify_celsius(c));
    }

    println!("\n反向转换:100°F = {}", format_temp(fahrenheit_to_celsius(100.0), "C"));
}

常见问题 ​

问题一:函数名可以和变量名重复吗?

可以,但不建议。函数和变量在 Rust 中属于同一个命名空间(value namespace),同名变量会遮蔽函数名,导致函数无法调用。

问题二:函数可以在另一个函数内部定义吗?

可以。内部函数是合法的,但它不能访问外部函数的局部变量(和闭包不同)。

rust
fn main() {
    // 内部函数
    fn double(x: i32) -> i32 {
        x * 2
    }
    println!("{}", double(21));  // 42
}

问题三:函数的参数个数有限制吗?

语法上没有硬性限制,但参数太多会降低可读性。通常超过 5-6 个参数时应该考虑用结构体封装。

问题四:main 函数的返回值类型可以改吗?

可以。main 可以返回 ()(默认)或 Result<(), E>(E 实现了 std::process::Termination)。返回 Err 时程序以非零状态码退出。

rust
fn main() -> Result<(), Box<dyn std::error::Error>> {
    let number: i32 = "42".parse()?;
    println!("解析结果:{}", number);
    Ok(())
}

适用场景 ​

  • 代码复用:相同逻辑出现两次以上就应该提取成函数
  • 逻辑分层:把复杂的流程拆成多个小函数,每个函数做一件事
  • 接口抽象:函数签名(参数类型和返回类型)定义了清晰的接口
  • 测试:独立的函数更容易编写单元测试

注意事项 ​

  • 函数名使用 snake_case 命名,编译器会对非蛇形命名发出警告
  • 参数必须标注类型,Rust 不会推断函数参数的类型
  • 函数末尾表达式不加分号是返回值,加了分号变成 ()
  • return 主要用于提前返回,末尾返回用表达式
  • 函数定义的顺序不影响调用,可以先用后定义
  • 内部函数不能捕获外部变量,需要捕获时用闭包
  • 发散函数(返回 !)永远不会正常返回

总结 ​

fn 是 Rust 中定义函数的关键字。函数由名称、参数列表、返回类型和函数体组成。函数体是一个代码块,最后一行表达式(不加分号)作为返回值。参数必须显式标注类型,返回类型省略时默认为 ()。函数命名使用 snake_case 风格,定义顺序不影响调用。Rust 的惯例是用尾部表达式返回值,只在提前退出时使用 return。函数是组织和复用代码的基本方式,每个函数应该只做一件事,保持简洁清晰。