寫在前面

今天我們來學(xué)習(xí) Rust 中的函數(shù)，最后會(huì)捎帶介紹一下如何在 Rust 中寫注釋。也是比較輕量級(jí)的一節(jié)，大家快速過一下即可。

函數(shù)

函數(shù)本身是各個(gè)語言都支持的類型，我們此前已經(jīng)多次使用 fn main() 這個(gè)函數(shù)來承載業(yè)務(wù)邏輯，fn 可以用來聲明一個(gè)函數(shù)，而 main 函數(shù)跟其他語言一樣，可以理解為程序啟動(dòng)的【起點(diǎn)】，一切邏輯從這里開始。

Rust 本身的命名規(guī)范是【snake case】，即下劃線 + 小寫，這個(gè)其實(shí)各個(gè)語言都有自己規(guī)范，分清楚環(huán)境即可。

fn main() {
    println!("Hello, world!");
    another_function();
}
fn another_function() {
    println!("Another function.");
}

這里的 another_function 就是個(gè)沒有入?yún)?，沒有出參的函數(shù)，命名遵循 snake case，很好理解。

Rust 中的函數(shù)跟其他語言是一樣的，用 fn 來聲明，后面加上函數(shù)名，小括號(hào)里面可以放入?yún)ⅲ罂梢远x出參，最后用花括號(hào)來承載函數(shù)體。調(diào)用函數(shù)也不復(fù)雜，函數(shù)名后面跟上小括號(hào)+參數(shù)即可，注意 scope 就行，這里是因?yàn)槲覀兊?another_function 就在當(dāng)前包下，所以直接就那來調(diào)用。調(diào)用的時(shí)候要保證【函數(shù)所在的 scope 是對(duì) caller 可見】的即可。

我們?cè)?rust-learn 項(xiàng)目下通過 cargo new functions 新建一個(gè)項(xiàng)目，試一下上面的代碼：

$ cargo run
===============================
   Compiling functions v0.1.0 (/Users/ag9920/go/src/github.com/ag9920/rust-learn/functions)
    Finished dev [unoptimized + debuginfo] target(s) in 1.76s
     Running `target/debug/functions`
Hello, world!
Another function.

另外需要強(qiáng)調(diào)一點(diǎn)，Rust 文件內(nèi)函數(shù)定義并不要求順序，只要定義在 scope 內(nèi)就能解析，比如 main 函數(shù)先于 another_function 定義是沒問題的。

參數(shù)

還是基于我們此前的 another_function，我們嘗試加一下入?yún)?，看看?yīng)該怎么做：

fn main() {
    another_function(5);
}
fn another_function(x: i32) {
    println!("The value of x is: {x}");
}

執(zhí)行過后，結(jié)果如下：

$ cargo run
===============================
   Compiling functions v0.1.0 (/Users/ag9920/go/src/github.com/ag9920/rust-learn/functions)
    Finished dev [unoptimized + debuginfo] target(s) in 0.62s
     Running `target/debug/functions`
The value of x is: 5

此時(shí) another_function 增加了一個(gè)參數(shù) x，我們聲明其類型為 i32。在 main 函數(shù)中調(diào)用的時(shí)候，傳入我們的參數(shù) 5，最后被打印出來。

可能有的地方會(huì)特意提一下這兩個(gè)概念：

• 形參：是在定義函數(shù)時(shí)使用的參數(shù)，目的是用來接收調(diào)用該函數(shù)時(shí)傳進(jìn)來的實(shí)際參數(shù)，即 parameter；
• 實(shí)參：是在調(diào)用時(shí)傳遞給函數(shù)的參數(shù)，即 arguments。

但通常說起來的時(shí)候我們不太區(qū)分，對(duì)我們來說統(tǒng)一叫【參數(shù)】即可。

上面示例中，我們定義入?yún)⑹沁@樣的：fn another_function(x: i32)。

這里【冒號(hào) + 空格 + 類型】的寫法我們已經(jīng)見過很多次了，那能不能不帶類型呢？我直接寫個(gè) fn another_function(x)，具體格式留給編譯器來推斷 ok 不？

在 Rust 中這件事是不 ok的，按照規(guī)范，對(duì)于每個(gè)入?yún)⒛愣急仨毲逦刂该鳌绢愋汀?，這樣編譯器也省事，報(bào)錯(cuò)時(shí)也能更精準(zhǔn)給出相關(guān)判斷。如果我們需要多個(gè)入?yún)ⅲ谩径禾?hào)】分隔即可：

fn main() {
    print_labeled_measurement(5, 'h');
}
fn print_labeled_measurement(value: i32, unit_label: char) {
    println!("The measurement is: {value}{unit_label}");
}

執(zhí)行結(jié)果如下：

$ cargo run
========================
  Compiling functions v0.1.0 (/Users/ag9920/go/src/github.com/ag9920/rust-learn/functions)
    Finished dev [unoptimized + debuginfo] target(s) in 0.87s
     Running `target/debug/functions`
The measurement is: 5h

語句和表達(dá)式

Rust 本身是一個(gè)基于表達(dá)式的語言，所以這兩個(gè)概念我們先區(qū)分一下，語句（statements)，表達(dá)式（expressions）是什么區(qū)別？

Statements are instructions that perform some action and do not return a value. Expressions evaluate to a resulting value.

簡(jiǎn)單說，就是看有沒有【返回值】，無返回值的是語句，有返回值的是表達(dá)式，表達(dá)式可以是一個(gè)語句的組成部分。

舉個(gè)例子：let y = 6; 這就是一個(gè)【語句】，而 6 就是一個(gè)【表達(dá)式】，在 Rust 中你是不能做 let x = (let y = 6); 這樣的操作的，因?yàn)槔ㄌ?hào)里面的部分是個(gè)語句，語句沒有返回值，那么該拿什么給 x 賦值呢？

所以，不像其他語言，可能允許類似 x = y = 6，這樣讓 x 和 y 都賦值了 6。Rust 是不允許這樣的。

fn main() {
    let y = {
        let x = 3;
        x + 1
    };
    println!("The value of y is: {y}");
}

比如上面這個(gè)案例，在花括號(hào)這個(gè) scope 中，我們定義了 x 變量，將其賦值為 3，然后將 x+1 這個(gè)表達(dá)式返回，所以 y 被賦值為 4。

花括號(hào)里面的部分就是一個(gè)表達(dá)式，返回了 4 。注意 x + 1 的結(jié)尾沒有分號(hào)，這也是表達(dá)式的特征。這里千萬不能加分號(hào)，要想清楚。如果你想用一個(gè)表達(dá)式返回，就不加分號(hào)。加了之后變成了語句，但也不會(huì)返回什么東西。

Rust 函數(shù)體則是由一系列【語句】+ 默認(rèn)可選的一個(gè)【表達(dá)式】組成。為什么是可選的？因?yàn)轭愃莆覀兦懊娴暮瘮?shù)，沒有返回值，不需要最后的這個(gè)【表達(dá)式】。

返回值

Rust 是不支持命名返回值的（這一點(diǎn)跟 Golang 有所不同），函數(shù)定義出參的部分需要用【箭頭符號(hào)】顯式地聲明。

不像很多函數(shù)要求顯式的 return 返回值，Rust 默認(rèn)會(huì)返回最后的表達(dá)式的值。當(dāng)然我們?nèi)绻?early return 也是 ok的，但大多數(shù)函數(shù)不會(huì)寫 return 這個(gè)關(guān)鍵字，而是隱式地返回最后一個(gè)表達(dá)式。我們來看一個(gè)例子：

fn five() -> i32 {
    5
}
fn main() {
    let x = five();
    println!("The value of x is: {x}");
}

這里的 five 函數(shù)非常簡(jiǎn)單，只有一個(gè) 5 作為表達(dá)式返回，不需要 return。

這是完全合法的 Rust 函數(shù)，出參只有一個(gè) i32。我們加上入?yún)ⅲ倏匆粋€(gè)例子：

fn main() {
    let x = plus_one(5);
    println!("The value of x is: {x}");
}
fn plus_one(x: i32) -> i32 {
    x + 1
}

此時(shí)我們有一個(gè) i32 入?yún)?，也有一個(gè) i32 出參，函數(shù)體是一個(gè)簡(jiǎn)單的表達(dá)式 x + 1。運(yùn)行上面代碼打印的結(jié)果是 The value of x is: 6，符合預(yù)期。

我們?cè)囋嚱o x + 1 后面加上個(gè)分號(hào)看看：

fn main() {
    let x = plus_one(5);
    println!("The value of x is: {x}");
}
fn plus_one(x: i32) -> i32 {
    x + 1;
}

此時(shí)運(yùn)行結(jié)果果然報(bào)錯(cuò)（這個(gè)不是運(yùn)行時(shí)報(bào)錯(cuò)，是編譯階段識(shí)別的）

$ cargo run
====================
   Compiling functions v0.1.0 (/Users/ag9920/go/src/github.com/ag9920/rust-learn/functions)
error[E0308]: mismatched types
 --> src/main.rs:7:24
  |
7 | fn plus_one(x: i32) -> i32 {
  |    --------            ^^^ expected `i32`, found `()`
  |    |
  |    implicitly returns `()` as its body has no tail or `return` expression
8 |     x + 1;
  |          - help: remove this semicolon
For more information about this error, try `rustc --explain E0308`.
error: could not compile `functions` due to previous error

問題在于，plus_one 說了會(huì)有返回值 i32，但到最后也沒發(fā)現(xiàn)【表達(dá)式】，此時(shí) Rust 默認(rèn)會(huì)返回 () 一個(gè)空的 tuple（我們上一節(jié)講過，這個(gè)叫 unit），所以報(bào)錯(cuò)叫做【 mismatched types】，而不是類似【no return value】，這里是不是就理解了？

沒有返回值的函數(shù)，本質(zhì)上是返回了一個(gè) unit：

// Functions that "don't" return a value, actually return the unit type `()`
fn fizzbuzz(n: u32) -> () {
    if is_divisible_by(n, 15) {
        println!("fizzbuzz");
    } else if is_divisible_by(n, 3) {
        println!("fizz");
    } else if is_divisible_by(n, 5) {
        println!("buzz");
    } else {
        println!("{}", n);
    }
}

問題又來了，那 Rust 能不能支持多個(gè)出參呢？類似 Golang 中的：

func addsub(x, y int) (int, int) {
    return x + y, x - y
}

其實(shí) Rust 對(duì)這個(gè)事情的解決方案就是我們已經(jīng)見過多次的 tuple：

fn addsub(x: isize, y: isize) -> (isize, isize) {
    (x + y, x - y)
}
fn my_func() -> (u8, bool) {
    (1, true)
}

圓括號(hào)千萬不能少，記住我們 return 的是個(gè) tuple，不是多個(gè)單獨(dú)的值。

這里有一個(gè)可運(yùn)行的 online 示例，大家可以復(fù)習(xí)一下 tuple，結(jié)合多個(gè)返回值體會(huì)一下：

fn swap(x: i32, y: i32) -> (i32, i32) {
    return (y, x);
}
fn main() {
    // return a tuple of return values
    let result = swap(123, 321);
    println!("{} {}", result.0, result.1);
    // destructure the tuple into two variables names
    let (a, b) = swap(result.0, result.1);
    println!("{} {}", a, b);
}

注釋

注釋其實(shí)比較簡(jiǎn)單，我們快速提一下。

Rust 的行注釋就是常見的 // 雙斜杠，如果一行放不下，需要多行的話，也需要在每一行前面加.

fn main() {
    // I'm feeling lucky today
    let lucky_number = 7;
}

文檔注釋有些許的區(qū)別，這里需要用 /// 三斜杠，這樣能夠輔助生成 HTML 文檔。

/// Adds one to the number given.
///
/// # Examples
///
/// ```
/// let arg = 5;
/// let answer = my_crate::add_one(arg);
///
/// assert_eq!(6, answer);
/// ```
pub fn add_one(x: i32) -> i32 {
    x + 1
}

以上就是Rust 入門之函數(shù)和注釋實(shí)例詳解的詳細(xì)內(nèi)容，更多關(guān)于Rust 函數(shù)注釋的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！

最新評(píng)論