fn 函数定义
什么是函数
函数是 Rust 程序的基本组成单元,用 fn 关键字定义。每个 Rust 程序都有一个 main 函数作为入口点。函数把一段逻辑封装起来,通过名字调用,可以接收参数、返回值。Rust 的函数命名惯例是蛇形命名法(snake_case)。
// 最简单的函数定义
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);
}函数的基本结构
一个完整的函数由以下部分组成:
// 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 之前或之后,也可以定义在模块内部。只要在同一个作用域中能访问到,声明顺序不影响调用。
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!("这是辅助模块中的函数");
}
}函数体是代码块
函数体是一个代码块(用 {} 包围),代码块的最后一个表达式(不加分号)就是函数的返回值。
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。
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。
// 发散函数:永远不会正常返回
fn forever() -> ! {
loop {
// 无限循环
}
}
// panic 也是发散的
fn crash(message: &str) -> ! {
panic!("致命错误:{}", message);
}
fn main() {
let value: i32 = if true {
42
} else {
// crash 返回 !,! 可以被当作任意类型使用
crash("不可能到达这里")
};
println!("{}", value);
}基本示例
一个简单的温度转换工具:
// 摄氏度转华氏度
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),同名变量会遮蔽函数名,导致函数无法调用。
问题二:函数可以在另一个函数内部定义吗?
可以。内部函数是合法的,但它不能访问外部函数的局部变量(和闭包不同)。
fn main() {
// 内部函数
fn double(x: i32) -> i32 {
x * 2
}
println!("{}", double(21)); // 42
}问题三:函数的参数个数有限制吗?
语法上没有硬性限制,但参数太多会降低可读性。通常超过 5-6 个参数时应该考虑用结构体封装。
问题四:main 函数的返回值类型可以改吗?
可以。main 可以返回 ()(默认)或 Result<(), E>(E 实现了 std::process::Termination)。返回 Err 时程序以非零状态码退出。
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。函数是组织和复用代码的基本方式,每个函数应该只做一件事,保持简洁清晰。