Rust 函数

函数是可重用的代码块，用于执行特定任务。例如，如果我们想创建一个程序来对两个数字进行相加，那么我们可以创建一个 Rust 函数来对数字进行相加。现在，每当我们对两个数字进行相加时，都可以重用同一个函数。

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

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

在 Rust 中定义函数

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

fn function_name(arguments) {
    // code
}

让我们看一个例子。

fn greet() {
    // code
}

这里，

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

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

// define a function
fn greet() {
    println!("Hello, World!");
}

fn main() {

}

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

在 Rust 中调用函数

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

// call a function
greet();

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

// define a function
fn greet() {
    println!("Hello, World!");
}

fn main() {
    // function call
    greet();
}

输出

Hello, World!

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

Rust 中的 main() 函数

如果你仔细观察，你会发现 main() 的语法看起来和函数很相似。

fn main() {
    // function call
    greet();
}

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

注意: Rust 代码在定义函数名时遵循小写约定。一个扩展的函数名，包含多个单词，单词之间将用下划线分隔。

示例：Rust 中用于对两个数字进行相加的函数

// function to add two numbers
fn add() {
    let a = 5;
    let b = 10;

    let sum = a + b;

    println!("Sum of a and b = {}", sum);
}

fn main() {
    // function call
    add();
}

输出

Sum of a and b = 15

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

程序的工作原理如下：

Rust 中的函数参数

根据定义，我们知道函数应该是可重用的。然而，我们上一个示例中的 add() 函数只能用于对 **5** 和 **10** 进行相加。

// function to add two numbers
fn add() {
    let a = 5;
    let b = 10;

    let sum = a + b;

    println!("Sum of a and b = {}", sum);
}

这个函数不是动态的，无法重用。

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

下面是我们如何创建一个带参数的函数。

// function with parameters
fn add(a: i32, b: i32) {
    let sum = a + b;

    println!("Sum of a and b = {}", sum);
}

这里，

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

要调用此函数，我们应该在函数调用期间提供一些值。

add(2, 11);

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

示例：函数参数

// define an add function that takes in two parameters
fn add(a: i32, b: i32) {
    let sum = a + b;
    
    println!("Sum of a and b = {}", sum);
}

fn main() {
    // call add function with arguments
    add(2, 11);
}

输出

Sum of a and b = 13

程序的工作原理如下：

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

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

因此，我们在屏幕上看到 2 和 11 的总和 13。

Rust 中带返回值的函数

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

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

// define an add function that takes in two parameters with a return type
fn add(a: i32, b: i32) -> i32 {
    let sum = a + b;

    // return a value from the function
    return sum;
}

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

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

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

// store the returned value in a variable
let sum = add(3, 5);

示例：带返回值的函数

// define an add function that takes in two parameters with a return type
fn add(a: i32, b: i32) -> i32 {
    let sum = a + b;

    // return a value from the function
    return sum;
}

fn main() {
    // function call
    let sum = add(3, 5);

    println!("Sum of a and b = {}", sum);
}

输出

Sum of a and b = 8

程序的工作原理如下：

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

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

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

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

Sum = 3

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

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

Sum = 5, Difference = 3

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

    // passing reference of word variable
    let len = calculate_length(&word);

    println!("The length of '{}' is {}.", word, len);
}

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

The length of 'hello' is 5.