掌握 Rust 函数：从入门到进阶

不吃草的牛德

发布于 2026-04-23 11:36:58

790

文章被收录于专栏：RustRust

在 Rust 编程中，函数是构建模块化、可维护代码的核心。Rust 作为一门注重性能和安全的语言，其函数设计既简洁又强大。本文将带你深入了解 Rust 函数的定义、参数、返回值以及一些实用技巧，帮助你写出更优雅的 Rust 代码。

什么是 Rust 函数？在 Rust 中，函数是执行特定任务的代码块，可以接收输入（参数）、执行逻辑并返回结果。Rust 的函数以关键字 fn 定义，具有类型安全和明确语义的特点。函数不仅能提高代码复用性，还能让程序结构更清晰。定义一个简单的函数让我们从一个简单的函数开始，看看 Rust 函数的基本语法：

fn main() {
    println!("Hello, Rust!");
    greet("Alice");
}
fn greet(name: &str) {
    println!("Hello, {}!", name);
}

在这个例子中：

使用 fn 关键字定义函数 greet。
函数接收一个参数 name，类型为 &str（字符串切片）。
函数体使用 println! 宏打印问候语。
main 函数是程序的入口，调用了 greet 函数。

运行这段代码，输出：

Hello, Rust!
Hello, Alice!

Rust 的函数默认没有返回值（隐式返回 ()，即单元类型）。接下来，我们看看如何处理参数和返回值。

函数参数：传递和借用Rust 的函数参数需要显式声明类型，这体现了 Rust 的类型安全特性。参数可以是基本类型、复合类型，甚至是借用（引用）。示例：计算两数之和

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

输出：

5 + 3 = 8

这里：

add 函数接收两个 i32 类型的参数 a 和 b。
使用 -> i32 指定返回值类型。
函数体直接返回 a + b，Rust 允许省略 return 关键字（表达式最后的值会自动返回）。

使用借用传递参数在 Rust 中，为了避免所有权转移，常用引用（&）作为参数。例如：

fn print_length(s: &str) {
    println!("Length of '{}': {}", s, s.len());
}
fn main() {
    let text = String::from("Rust");
    print_length(&text);
    println!("Still have text: {}", text);
}

输出：

Length of 'Rust': 4
Still have text: Rust

通过 &str 借用字符串，函数可以在不获取所有权的情况下访问数据，体现了 Rust 的内存安全。返回值：单一返回与多值返回Rust 函数可以返回任意类型，但一次只能返回一个值。如果需要返回多个值，通常使用元组（tuple）。示例：计算面积和周长

fn rectangle_stats(width: f64, height: f64) -> (f64, f64) {
    let area = width * height;
    let perimeter = 2.0 * (width + height);
    (area, perimeter)
}
fn main() {
    let (area, perimeter) = rectangle_stats(4.0, 5.0);
    println!("Area: {}, Perimeter: {}", area, perimeter);
}

输出：

Area: 20, Perimeter: 18

函数返回一个元组 (f64, f64)，包含面积和周长。
在 main 中通过解构（destructuring）获取返回值。

提前返回Rust 支持使用 return 关键字提前返回：

fn check_positive(num: i32) -> bool {
    if num < 0 {
        return false;
    }
    true
}

表达式 vs 语句Rust 的函数体由语句（statements）和表达式（expressions）组成：

语句：执行操作但不返回值，例如 let x = 5;。
表达式：计算并产生值，例如 5 + 3 或函数调用。

Rust 的函数返回值通常来自最后一个表达式。例如：

fn five() -> i32 {
    5 // 表达式，无需分号
}

等价于：

fn five() -> i32 {
    return 5; // 语句，需要分号
}

注意：在 Rust 中，代码块（{}）的最后一行如果没有分号，会被视为返回值表达式。进阶技巧：函数中的所有权与借用Rust 的所有权机制对函数设计有重要影响。以下是一些常见场景：1. 传递所有权如果函数需要获取参数的所有权，可以直接传递值：

fn take_ownership(s: String) {
    println!("Got: {}", s);
}
fn main() {
    let s = String::from("Rust");
    take_ownership(s);
    // println!("Still have: {}", s); // 错误！s 已移动
}

2. 返回所有权函数可以返回拥有所有权的值：

fn give_ownership() -> String {
    String::from("Rust")
}
fn main() {
    let s = give_ownership();
    println!("Got: {}", s);
}

3. 借用与可变借用如果需要修改参数，可以使用可变引用（&mut）：

fn append_exclamation(s: &mut String) {
    s.push_str("!");
}
fn main() {
    let mut s = String::from("Rust");
    append_exclamation(&mut s);
    println!("Modified: {}", s);
}

输出：

Modified: Rust!

最佳实践

显式类型声明：始终为参数和返回值指定类型，增强代码可读性和安全性。
最小化所有权转移：优先使用借用（& 或 &mut），减少不必要的内存拷贝。
单一职责：让每个函数专注于单一任务，避免过于复杂的逻辑。
文档与测试：为函数添加文档注释（///）并编写单元测试：

/// Adds two numbers and returns their sum.
/// # Examples
/// ```
/// assert_eq!(add(2, 3), 5);
/// ```
fn add(a: i32, b: i32) -> i32 {
    a + b
}
#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
    }
}

5. 错误处理：结合 Result 或 Option 处理可能的错误。例如：

fn divide(a: f64, b: f64) -> Option<f64> {
    if b == 0.0 {
        None
    } else {
        Some(a / b)
    }
}

总结Rust 的函数设计简洁而强大，结合所有权和借用机制，既保证了性能，又提升了安全性。通过本文，你学习了如何定义函数、处理参数和返回值，以及在实际开发中的一些最佳实践。无论是构建简单的命令行工具，还是复杂的高性能系统，Rust 的函数都是不可或缺的基石。

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2025-10-13，如有侵权请联系 cloudcommunity@tencent.com 删除

设计

本文分享自 Rust火箭工坊微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度

掌握 Rust 函数：从入门到进阶

掌握 Rust 函数：从入门到进阶

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐