跳到主要内容

Rust 函数

提示
  1. Rust函数定义：在Rust中，函数使用fn关键字定义，包括函数名、参数和函数体。函数可以执行特定任务，并通过参数接收外部值，使其具有更广泛的应用和重用性。
  2. 函数调用：通过函数名和括号()调用函数，可在程序的任何地方执行定义的任务。例如，greet()函数调用会执行其内部代码。
  3. 带返回值的函数：Rust函数可以返回值，使用->标记返回类型。使用return关键字或省略return且无分号的表达式作为返回值。例如，fn add(a: i32, b: i32) -> i32 { a + b }返回两个数的和。

函数是执行特定任务的可重用代码块。例如，如果我们想创建一个程序来加两个数，那么我们可以创建一个 Rust 函数来实现加法。现在，每当我们需要加两个数时，就可以重用这个函数。

在 Rust 中创建函数有助于将代码分割成更小的块，使代码看起来更整洁、更易于理解。

不仅在 Rust 中，函数也是任何编程语言的核心构建块之一。

在 Rust 中定义函数​

在 Rust 中，我们使用 fn 关键字来定义函数。函数的语法如下，

fn function_name(arguments) {
    // code
}

让我们来看一个例子。

fn greet() {
    // code
}

这里，

  • fn - 用于在 Rust 中创建函数的关键字
  • greet() - 函数名称
  • // code - 函数体
  • { } - 函数体的开始和结束

现在让我们完成 greet() 函数，以打印 "Hello, World!"。

// 定义一个函数
fn greet() {
    println!("Hello, World!");
}

fn main() {

}

当我们运行这段代码时，我们不会得到任何输出。这是因为我们只是在定义一个函数。要执行一个函数，我们需要调用它。

在 Rust 中调用函数​

我们使用函数名称和括号 () 来调用一个函数。

// 调用一个函数
greet();

让我们现在完成上面的示例。

// 定义一个函数
fn greet() {
    println!("Hello, World!");
}

fn main() {
    // 函数调用
    greet();
}

输出

Hello, World!

这里，我们创建了一个 greet() 函数，它在屏幕上打印 "Hello, World!"。请注意，我们是从 main() 函数内部调用这个函数的。

Rust 中的 main() 函数

如果你仔细观察，可以看到 main() 的语法与函数类似。

fn main() {
    // 函数调用
    greet();
}

在 Rust 中，main() 也是一个函数，被称为内置函数，具有特殊的含义。它是每个 Rust 程序的入口点（开始）。

注意： Rust 代码使用小写作为定义函数名称的惯例。带有多个单词的扩展函数名称之间会有下划线。

示例：在 Rust 中添加两个数字的函数​

// 一个用于加两个数字的函数
fn add() {
    let a = 5;
    let b = 10;

    let sum = a + b;

    println!("a 和 b 的和 = {}", sum);
}

fn main() {
    // 函数调用
    add();
}

输出

a 和 b 的和 = 15

在上面的示例中，我们创建了一个名为 add() 的函数。该函数加两个数字并打印和。

以下是程序的工作方式，

Rust 中函数的工作原理

Rust 中的函数参数​

从定义中我们知道，函数应该是可重用的。然而，我们之前示例中的 add() 函数只能用于计算 5 和 10 的和。

// 一个用于加两个数字的函数
fn add() {
    let a = 5;
    let b = 10;

    let sum = a + b;

    println!("a 和 b 的和 = {}", sum);
}

这个函数不够动态，无法被重用。

为了解决这个问题，并使我们的函数更具动态性，我们可以创建接受外部值的函数。这些外部值被称为函数参数。

以下是我们如何创建带参数的函数。

// 带参数的函数
fn add(a: i32, b:

 i32) {
    let sum = a + b;

    println!("a 和 b 的和 = {}", sum);
}

这里，

  • a 和 b 是函数参数
  • i32 是参数的数据类型

要调用这个函数，我们在函数调用时需要提供一些值。

add(2, 11);

这里，2 和 11 被称为传递给 add 函数的函数参数。

示例：带参数的函数​

// 定义一个带有两个参数的 add 函数
fn add(a: i32, b: i32) {
    let sum = a + b;

    println!("a 和 b 的和 = {}", sum);
}

fn main() {
    // 使用参数调用 add 函数
    add(2, 11);
}

输出

a 和 b 的和 = 13

以下是程序的工作方式，

Rust 中带参数的函数的工作原理

调用函数时，参数会被分配给函数参数。

  • 2 被分配给 a
  • 11 被分配给 b

结果，我们在屏幕上看到 2 和 11 的和等于 13。

在 Rust 中带返回值的函数​

在最后一个示例中，我们计算了两个数字的和，并在函数内部打印了结果。然而，我们也可以从函数中返回结果，并在我们的程序中的任何地方使用它。

以下是我们如何在 Rust 中创建一个返回值的函数。

// 定义一个带有两个参数和返回类型的 add 函数
fn add(a: i32, b: i32) -> i32 {
    let sum = a + b;

    // 从函数中返回一个值
    return sum;
}

这里，-> i32 出现在开大括号 { 前，表示函数的返回类型。在这种情况下，函数将返回一个 i32 值。

我们然后使用 return 关键字从函数中返回 sum 变量。

函数返回的值需要存储在某个地方，因为函数将值返回到它被调用的地方。

// 将返回的值存储在一个变量中
let sum = add(3, 5);

示例：带返回值的函数​

// 定义一个带有两个参数和返回类型的 add 函数
fn add(a: i32, b: i32) -> i32 {
    let sum = a + b;

    // 从函数中返回一个值
    return sum;
}

fn main() {
    // 函数调用
    let sum = add(3, 5);

    println!("a 和 b 的和 = {}", sum);
}

输出

a 和 b 的和 = 8

以下是程序的工作方式，

Rust 中带返回值的函数的工作原理

在上面的示例中，当我们到达 add 函数中的 return 语句时，它返回 sum 变量。返回的值存储在 main() 内的 sum 变量中。

常见问题​

如何使用 Rust 表达式从函数中返回一个值？

以表达式结尾的函数将返回表达式的值。这意味着我们不必使用 return 关键字就可以从函数中返回一个值。例如，

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    let sum = add(1, 2);

    println!("和 = {}", sum);
}

输出

和 = 3

注意： 请注意函数体中的 a + b 没有以分号结束。表达式不包括结束分号，但语句包括。

我们如何从 Rust 函数中返回多个值？

我们可以使用元组从函数中返回多个值。例如，

fn addsub(a: i32, b: i32) -> (i32, i32) {
    return (a + b, a - b);
}

fn main() {
    let (sum, diff) = addsub(4, 1);
    println!("和 = {}, 差 = {}", sum, diff);
}

输出

和 = 5, 差 = 3

这里，函数的返回类型是一个元组 (i32, i32)。

如何在 Rust 中通过引用传递？

我们可以通过引用传递来传递变量的指针，而不是实际的变量。例如，

fn main() {
    let word = String::from("hello");

    // 传递 word 变量的引用
    let len = calculate_length(&word);

    println!("'{}' 的长度是 {}。", word, len);
}

fn calculate_length(s: &String) -> usize {
    return s.len();
}

输出

'hello' 的长度是 5。

这里，我们用 &word 将 word 变量作为引用传递给 calculate_length() 函数。

Rust 函数的优势是什么？

函数是 Rust 编程语言的构建块，带来了许多优势。其中一些是：

  • 函数将我们的代码划分为更小、可重用的块。
  • 函数有助于使我们的程序更易于阅读和调试。
  • 函数使我们的程序模块化，更易于更改，并有助于减少代码重复。
最后于 更新