Rust 基礎(chǔ)系列 #8：編寫(xiě)里程碑 Rust 程序

2023-06-23 14:15:09

這篇文章中，我使用了之前講解的 Rust 編程語(yǔ)言的所有主題來(lái)創(chuàng)建一個(gè)簡(jiǎn)單的程序，這個(gè)程序仍然在某種程度上展示了一個(gè)現(xiàn)實(shí)世界的問(wèn)題。

到目前為止，我們已經(jīng)講解了包括變量、可變性、常量、數(shù)據(jù)類型、函數(shù)、if-else 語(yǔ)句和循環(huán) 在內(nèi)的一些關(guān)于 Rust 編程的基礎(chǔ)知識(shí)。

在 Rust 基礎(chǔ)系列的最后一章里，讓我們現(xiàn)在用 Rust 編寫(xiě)一個(gè)程序，使用這些主題，以便更好地理解它們?cè)诂F(xiàn)實(shí)世界中的用途。讓我們來(lái)編寫(xiě)一個(gè)相對(duì)簡(jiǎn)單的程序，用來(lái)從水果市場(chǎng)訂購(gòu)水果。

我們程序的基本結(jié)構(gòu)

來(lái)讓我們首先向用戶問(wèn)好，并告訴他們?nèi)绾闻c程序交互。

fn main() {
    println!("歡迎來(lái)到水果市場(chǎng)！");
    println!("請(qǐng)選擇要購(gòu)買的水果。\n");
    println!("\n可以購(gòu)買的水果：蘋(píng)果、香蕉、橘子、芒果、葡萄");
    println!("購(gòu)買完成后，請(qǐng)輸入“quit”或“q”。\n");
}

獲取用戶輸入

上面的代碼非常簡(jiǎn)單。目前，你不知道接下來(lái)該做什么，因?yàn)槟悴恢烙脩艚酉聛?lái)想做什么。

所以讓我們添加一些代碼，接受用戶輸入并將其存儲(chǔ)在某個(gè)地方以便稍后解析，然后根據(jù)用戶輸入采取適當(dāng)?shù)牟僮鳌?/p>

use std::io;
fn main() {
    println!("歡迎來(lái)到水果市場(chǎng)！");
    println!("請(qǐng)選擇要購(gòu)買的水果。\n");
    println!("\n可以購(gòu)買的水果：蘋(píng)果、香蕉、橘子、芒果、葡萄");
    println!("購(gòu)買完成后，請(qǐng)輸入“quit”或“q”。\n");
    // 獲取用戶輸入
    let mut user_input = String::new();
    io::stdin()
        .read_line(&mut user_input)
        .expect("無(wú)法讀取用戶輸入。");
}

有三個(gè)新元素需要告訴你。所以讓我們對(duì)這些新元素進(jìn)行淺層次的探索。

1. 理解 use 關(guān)鍵字

在這個(gè)程序的第一行，你可能已經(jīng)注意到我們“使用”（哈哈！）了一個(gè)叫做 use 的新關(guān)鍵字。Rust 中的 use 關(guān)鍵字類似于 C/C++ 中的 #include 指令和 Python 中的 import 關(guān)鍵字。使用 use 關(guān)鍵字，我們從 Rust 標(biāo)準(zhǔn)庫(kù) std 中“導(dǎo)入”了 io（輸入輸出）模塊。

LCTT 譯注：“使用”在原文中為“use”，與新介紹的關(guān)鍵字一樣。

你可能會(huì)想知道為什么我們?cè)诳梢允褂?nbsp;println 宏來(lái)將某些內(nèi)容輸出到標(biāo)準(zhǔn)輸出時(shí)，導(dǎo)入 io 模塊是必要的。Rust 的標(biāo)準(zhǔn)庫(kù)有一個(gè)叫做 prelude 的模塊，它會(huì)自動(dòng)被包含。該模塊包含了 Rust 程序員可能需要使用的所有常用函數(shù)，比如 println 宏。（你可以在這里閱讀更多關(guān)于 std::prelude 模塊的內(nèi)容。）

Rust 標(biāo)準(zhǔn)庫(kù) std 中的 io 模塊是接受用戶輸入所必需的。因此，我們?cè)诔绦虻牡谝恍刑砑恿艘粋€(gè) use 語(yǔ)句。

2. 理解 Rust 中的 String 類型

在第 11 行，我創(chuàng)建了一個(gè)新的可變變量 user_input，正如它的名字所表示的那樣，它將被用來(lái)存儲(chǔ)用戶輸入。但是在同一行，你可能已經(jīng)注意到了一些“新的”東西（哈哈，又來(lái)了！）。

LCTT 譯注：“新的”在原文中為“new”，在第 11 行的代碼中，原作者使用了 String::new() 函數(shù)，所以此處的梗與“使用”一樣，原作者使用了一個(gè)在代碼中用到的單詞。

我沒(méi)有使用雙引號(hào)（""）聲明一個(gè)空字符串，而是使用 String::new() 函數(shù)來(lái)創(chuàng)建一個(gè)新的空字符串。

"" 與 String::new() 的區(qū)別是你將在 Rust 系列的后續(xù)文章中學(xué)習(xí)到的。現(xiàn)在，只需要知道，使用 String::new() 函數(shù)，你可以創(chuàng)建一個(gè)可變的，位于堆上的字符串。

如果我使用 "" 創(chuàng)建了一個(gè)字符串，我將得到一個(gè)叫做“字符串切片”的東西。字符串切片的內(nèi)容也位于堆上，但是字符串本身是不可變的。所以，即使變量本身是可變的，作為字符串存儲(chǔ)的實(shí)際數(shù)據(jù)是不可變的，需要被覆蓋而不是修改。

3. 接受用戶輸入

在第 12 行，我調(diào)用了 std::io 的 stdin() 函數(shù)。如果我在程序的開(kāi)頭沒(méi)有導(dǎo)入 std::io 模塊，那么這一行將是 std::io::stdin() 而不是 io::stdin()。

sdtin() 函數(shù)返回一個(gè)終端的輸入句柄。read_line() 函數(shù)抓住這個(gè)輸入句柄，然后，正如它的名字所暗示的那樣，讀取一行輸入。這個(gè)函數(shù)接受一個(gè)可變字符串的引用。所以，我傳入了 user_input 變量，通過(guò)在它前面加上 &mut，使它成為一個(gè)可變引用。

?? read_line() 函數(shù)有一個(gè) 怪癖。這個(gè)函數(shù)在用戶按下回車鍵之后停止讀取輸入。因此，這個(gè)函數(shù)也會(huì)記錄換行符（\n），并將一個(gè)換行符存儲(chǔ)在你傳入的可變字符串變量的結(jié)尾處。

所以，請(qǐng)?jiān)谔幚硭鼤r(shí)要么考慮到這個(gè)換行符，要么將它刪除。

Rust 中的錯(cuò)誤處理入門(mén)

最后，在這個(gè)鏈的末尾有一個(gè) expect() 函數(shù)。讓我們稍微偏題一下，來(lái)理解為什么要調(diào)用這個(gè)函數(shù)。

read_line() 函數(shù)返回一個(gè)叫做 Result 的枚舉。我會(huì)在后面的文章中講解 Rust 中的枚舉，但是現(xiàn)在只需要知道，枚舉在 Rust 中是非常強(qiáng)大的。這個(gè) Result 枚舉返回一個(gè)值，告訴程序員在讀取用戶輸入時(shí)是否發(fā)生了錯(cuò)誤。

expect() 函數(shù)接受這個(gè) Result 枚舉，并檢查結(jié)果是否正常。如果沒(méi)有發(fā)生錯(cuò)誤，什么都不會(huì)發(fā)生。但是如果發(fā)生了錯(cuò)誤，我傳入的消息（無(wú)法讀取用戶輸入。）將會(huì)被打印到 STDERR，程序?qū)?huì)退出。

?? 所有我簡(jiǎn)要提及的新概念將會(huì)在后續(xù)的新 Rust 系列文章中講解。

現(xiàn)在我希望你應(yīng)該已經(jīng)理解了這些新概念，讓我們添加更多的代碼來(lái)增加程序的功能。

驗(yàn)證用戶輸入

我接受了用戶的輸入，但是我沒(méi)有對(duì)其進(jìn)行驗(yàn)證。在當(dāng)前的上下文中，驗(yàn)證意味著用戶輸入了一些“命令”，我們希望能夠處理這些命令。目前，這些命令有兩個(gè)“類別”。

第一類用戶可以輸入的命令是用戶希望購(gòu)買的水果的名稱。第二個(gè)命令表示用戶想要退出程序。

我們的任務(wù)現(xiàn)在是確保用戶輸入不會(huì)偏離 可接受的命令。

use std::io;
fn main() {
    println!("歡迎來(lái)到水果市場(chǎng)！");
    println!("請(qǐng)選擇要購(gòu)買的水果。\n");
    println!("\n可以購(gòu)買的水果：蘋(píng)果、香蕉、橘子、芒果、葡萄");
    println!("購(gòu)買完成后，請(qǐng)輸入“quit”或“q”。\n");
    // 獲取用戶輸入
    let mut user_input = String::new();
    io::stdin()
        .read_line(&mut user_input)
        .expect("無(wú)法讀取用戶輸入。");
    // 驗(yàn)證用戶輸入
    let valid_inputs = ["蘋(píng)果", "香蕉", "橘子", "芒果", "葡萄", "quit", "q"];
    user_input = user_input.trim().to_lowercase();
    let mut input_error = true;
    for input in valid_inputs {
        if input == user_input {
            input_error = false;
            break;
        }
    }
}

要使驗(yàn)證更容易，我創(chuàng)建了一個(gè)叫做 valid_inputs 的字符串切片數(shù)組（第 17 行）。這個(gè)數(shù)組包含了所有可以購(gòu)買的水果的名稱，以及字符串切片 q 和 quit，讓用戶可以傳達(dá)他們是否希望退出。

用戶可能不知道我們希望輸入是什么樣的。用戶可能會(huì)輸入“Apple”、“apple”或 “APPLE” 來(lái)表示他們想要購(gòu)買蘋(píng)果。我們的工作是正確處理這些輸入。

在第 18 行，我通過(guò)調(diào)用 trim() 函數(shù)從 user_input 字符串中刪除了尾部的換行符。為了處理上面提到的問(wèn)題，我使用 to_lowercase() 函數(shù)將所有字符轉(zhuǎn)換為小寫(xiě)，這樣 “Apple”、“apple” 和 “APPLE” 都會(huì)變成 “apple”。

現(xiàn)在，來(lái)看第 19 行，我創(chuàng)建了一個(gè)名為 input_error 的可變布爾變量，初始值為 true。稍后在第 20 行，我創(chuàng)建了一個(gè) for 循環(huán)，它遍歷了 valid_inputs 數(shù)組的所有元素（字符串切片），并將迭代的模式存儲(chǔ)在 input 變量中。

在循環(huán)內(nèi)部，我檢查用戶輸入是否等于其中一個(gè)有效字符串，如果是，我將 input_error 布爾值的值設(shè)置為 false，并跳出 for 循環(huán)。

處理無(wú)效輸入

現(xiàn)在是時(shí)候處理無(wú)效輸入了。這可以通過(guò)將一些代碼移動(dòng)到無(wú)限循環(huán)中來(lái)完成，如果用戶給出無(wú)效輸入，則 繼續(xù) 該無(wú)限循環(huán)。

use std::io;
fn main() {
    println!("歡迎來(lái)到水果市場(chǎng)！");
    println!("請(qǐng)選擇要購(gòu)買的水果。\n");
    let valid_inputs = ["蘋(píng)果", "香蕉", "橘子", "芒果", "葡萄", "quit", "q"];
    'mart: loop {
        let mut user_input = String::new();
        println!("\n可以購(gòu)買的水果：蘋(píng)果、香蕉、橘子、芒果、葡萄");
        println!("購(gòu)買完成后，請(qǐng)輸入“quit”或“q”。\n");
        // 讀取用戶輸入
        io::stdin()
            .read_line(&mut user_input)
            .expect("無(wú)法讀取用戶輸入。");
        user_input = user_input.trim().to_lowercase();
        // 驗(yàn)證用戶輸入
        let mut input_error = true;
        for input in valid_inputs {
            if input == user_input {
                input_error = false;
                break;
            }
        }
        // 處理無(wú)效輸入
        if input_error {
            println!("錯(cuò)誤: 請(qǐng)輸入有效的輸入");
            continue 'mart;
        }
    }
}

這里，我將一些代碼移動(dòng)到了循環(huán)內(nèi)部，并重新組織了一下代碼，以便更好地處理循環(huán)的引入。在循環(huán)內(nèi)部，第 31 行，如果用戶輸入了一個(gè)無(wú)效的字符串，我將 continue mart 循環(huán)。

對(duì)用戶輸入做出反應(yīng)

現(xiàn)在，所有其他的狀況都已經(jīng)處理好了，是時(shí)候?qū)懸恍┐a來(lái)讓用戶從水果市場(chǎng)購(gòu)買水果了，當(dāng)用戶希望退出時(shí)，程序也會(huì)退出。

因?yàn)槟阋仓烙脩暨x擇了哪種水果，所以讓我們問(wèn)一下他們打算購(gòu)買多少，并告訴他們輸入數(shù)量的格式。

use std::io;
fn main() {
    println!("歡迎來(lái)到水果市場(chǎng)！");
    println!("請(qǐng)選擇要購(gòu)買的水果。\n");
    let valid_inputs = ["蘋(píng)果", "香蕉", "橘子", "芒果", "葡萄", "quit", "q"];
    'mart: loop {
        let mut user_input = String::new();
        let mut quantity = String::new();
        println!("\n可以購(gòu)買的水果：蘋(píng)果、香蕉、橘子、芒果、葡萄");
        println!("購(gòu)買完成后，請(qǐng)輸入“quit”或“q”。\n");
        // 讀取用戶輸入
        io::stdin()
            .read_line(&mut user_input)
            .expect("無(wú)法讀取用戶輸入。");
        user_input = user_input.trim().to_lowercase();
        // 驗(yàn)證用戶輸入
        let mut input_error = true;
        for input in valid_inputs {
            if input == user_input {
                input_error = false;
                break;
            }
        }
        // 處理無(wú)效輸入
        if input_error {
            println!("錯(cuò)誤: 請(qǐng)輸入有效的輸入");
            continue 'mart;
        }
        // 如果用戶想要退出，就退出
        if user_input == "q" || user_input == "quit" {
            break 'mart;
        }
        // 獲取數(shù)量
        println!(
            "\n你選擇購(gòu)買的水果是 \"{}\"。請(qǐng)輸入以千克為單位的數(shù)量。
（1 千克 500 克的數(shù)量應(yīng)該輸入為 '1.5'。）",
            user_input
        );
        io::stdin()
            .read_line(&mut quantity)
            .expect("無(wú)法讀取用戶輸入。");
    }
}

在第 11 行，我聲明了另一個(gè)可變變量，它的值是一個(gè)空字符串，在第 48 行，我接受了用戶的輸入，但是這次是用戶打算購(gòu)買的水果的數(shù)量。

解析數(shù)量

我剛剛增加了一些代碼，以已知的格式接受數(shù)量，但是這些數(shù)據(jù)被存儲(chǔ)為字符串。我需要從中提取出浮點(diǎn)數(shù)。幸運(yùn)的是，這可以通過(guò) parse() 方法來(lái)完成。

就像 read_line() 方法一樣，parse() 方法返回一個(gè) Result 枚舉。parse() 方法返回 Result 枚舉的原因可以通過(guò)我們?cè)噲D實(shí)現(xiàn)的內(nèi)容來(lái)輕松理解。

我正在接受用戶的字符串，并嘗試將其轉(zhuǎn)換為浮點(diǎn)數(shù)。浮點(diǎn)數(shù)有兩個(gè)可能的值。一個(gè)是浮點(diǎn)數(shù)本身，另一個(gè)是小數(shù)。

字符串可以包含字母，但是浮點(diǎn)數(shù)不行。所以，如果用戶輸入的不是浮點(diǎn)數(shù)和小數(shù)，parse() 函數(shù)將會(huì)返回一個(gè)錯(cuò)誤。

因此，這個(gè)錯(cuò)誤也需要處理。我們將使用 expect() 函數(shù)來(lái)處理這個(gè)錯(cuò)誤。

use std::io;
fn main() {
    println!("歡迎來(lái)到水果市場(chǎng)！");
    println!("請(qǐng)選擇要購(gòu)買的水果。\n");
    let valid_inputs = ["蘋(píng)果", "香蕉", "橘子", "芒果", "葡萄", "quit", "q"];
    'mart: loop {
        let mut user_input = String::new();
        let mut quantity = String::new();
        println!("\n可以購(gòu)買的水果：蘋(píng)果、香蕉、橘子、芒果、葡萄");
        println!("購(gòu)買完成后，請(qǐng)輸入“quit”或“q”。\n");
        // 讀取用戶輸入
        io::stdin()
            .read_line(&mut user_input)
            .expect("無(wú)法讀取用戶輸入。");
        user_input = user_input.trim().to_lowercase();
        // 驗(yàn)證用戶輸入
        let mut input_error = true;
        for input in valid_inputs {
            if input == user_input {
                input_error = false;
                break;
            }
        }

        // 處理無(wú)效輸入
        if input_error {
            println!("錯(cuò)誤: 請(qǐng)輸入有效的輸入");
            continue 'mart;
        }
        // 如果用戶想要退出，就退出
        if user_input == "q" || user_input == "quit" {
            break 'mart;
        }
        // 獲取數(shù)量
        println!(
            "\n你選擇購(gòu)買的水果是 \"{}\"。請(qǐng)輸入以千克為單位的數(shù)量。
（1 千克 500 克的數(shù)量應(yīng)該輸入為 '1.5'。）",
            user_input
        );
        io::stdin()
            .read_line(&mut quantity)
            .expect("無(wú)法讀取用戶輸入。");

        let quantity: f64 = quantity
            .trim()
            .parse()
            .expect("請(qǐng)輸入有效的數(shù)量。");
    }
}

如你所見(jiàn)，我通過(guò)變量遮蔽將解析后的浮點(diǎn)數(shù)存儲(chǔ)在變量 quantity 中。為了告訴 parse() 函數(shù)，我的意圖是將字符串解析為 f64，我手動(dòng)將變量 quantity 的類型注釋為 f64。

現(xiàn)在，parse() 函數(shù)將會(huì)解析字符串并返回一個(gè) f64 或者一個(gè)錯(cuò)誤，expect() 函數(shù)將會(huì)處理這個(gè)錯(cuò)誤。

計(jì)算價(jià)格 + 最后的修飾

現(xiàn)在我們知道了用戶想要購(gòu)買的水果及其數(shù)量，現(xiàn)在是時(shí)候進(jìn)行計(jì)算了，并讓用戶知道結(jié)果/總價(jià)了。

為了真實(shí)起見(jiàn)，我將為每種水果設(shè)置兩個(gè)價(jià)格。第一個(gè)價(jià)格是零售價(jià)，我們?cè)谫?gòu)買少量水果時(shí)向水果供應(yīng)商支付的價(jià)格。水果的第二個(gè)價(jià)格是當(dāng)有人批量購(gòu)買水果時(shí)支付的批發(fā)價(jià)。

批發(fā)價(jià)將會(huì)在訂單數(shù)量大于被認(rèn)為是批發(fā)購(gòu)買的最低訂單數(shù)量時(shí)確定。這個(gè)最低訂單數(shù)量對(duì)于每種水果都是不同的。每種水果的價(jià)格都是每千克多少盧比。

想好了邏輯，下面是最終的程序。

use std::io;
const APPLE_RETAIL_PER_KG: f64 = 60.0;
const APPLE_WHOLESALE_PER_KG: f64 = 45.0;
const BANANA_RETAIL_PER_KG: f64 = 20.0;
const BANANA_WHOLESALE_PER_KG: f64 = 15.0;
const ORANGE_RETAIL_PER_KG: f64 = 100.0;
const ORANGE_WHOLESALE_PER_KG: f64 = 80.0;
const MANGO_RETAIL_PER_KG: f64 = 60.0;
const MANGO_WHOLESALE_PER_KG: f64 = 55.0;
const GRAPES_RETAIL_PER_KG: f64 = 120.0;
const GRAPES_WHOLESALE_PER_KG: f64 = 100.0;
fn main() {
    println!("歡迎來(lái)到水果市場(chǎng)！");
    println!("請(qǐng)選擇要購(gòu)買的水果。\n");
    let valid_inputs = ["蘋(píng)果", "香蕉", "橘子", "芒果", "葡萄", "quit", "q"];
    'mart: loop {
        let mut user_input = String::new();
        let mut quantity = String::new();
        println!("\n可以購(gòu)買的水果：蘋(píng)果、香蕉、橘子、芒果、葡萄");
        println!("購(gòu)買完成后，請(qǐng)輸入“quit”或“q”。\n");
        // 讀取用戶輸入
        io::stdin()
            .read_line(&mut user_input)
            .expect("無(wú)法讀取用戶輸入。");
        user_input = user_input.trim().to_lowercase();
        // 驗(yàn)證用戶輸入
        let mut input_error = true;
        for input in valid_inputs {
            if input == user_input {
                input_error = false;
                break;
            }
        }
        // 處理無(wú)效輸入
        if input_error {
            println!("錯(cuò)誤: 請(qǐng)輸入有效的輸入");
            continue 'mart;
        }
        // 如果用戶想要退出，就退出
        if user_input == "q" || user_input == "quit" {
            break 'mart;
        }
        // 獲取數(shù)量
        println!(
            "\n你選擇購(gòu)買的水果是 \"{}\"。請(qǐng)輸入以千克為單位的數(shù)量。
（1 千克 500 克的數(shù)量應(yīng)該輸入為 '1.5'。）",
            user_input
        );
        io::stdin()
            .read_line(&mut quantity)
            .expect("無(wú)法讀取用戶輸入。");
        let quantity: f64 = quantity
            .trim()
            .parse()
            .expect("請(qǐng)輸入有效的數(shù)量。");
        total += calc_price(quantity, user_input);
    }
    println!("\n\n總價(jià)是 {} 盧比。", total);
}
fn calc_price(quantity: f64, fruit: String) -> f64 {
    if fruit == "apple" {
        price_apple(quantity)
    } else if fruit == "banana" {
        price_banana(quantity)
    } else if fruit == "orange" {
        price_orange(quantity)
    } else if fruit == "mango" {
        price_mango(quantity)
    } else {
        price_grapes(quantity)
    }
}
fn price_apple(quantity: f64) -> f64 {
    if quantity > 7.0 {
        quantity * APPLE_WHOLESALE_PER_KG
    } else {
        quantity * APPLE_RETAIL_PER_KG
    }
}
fn price_banana(quantity: f64) -> f64 {
    if quantity > 4.0 {
        quantity * BANANA_WHOLESALE_PER_KG
    } else {
        quantity * BANANA_RETAIL_PER_KG
    }
}
fn price_orange(quantity: f64) -> f64 {
    if quantity > 3.5 {
        quantity * ORANGE_WHOLESALE_PER_KG
    } else {
        quantity * ORANGE_RETAIL_PER_KG
    }
}
fn price_mango(quantity: f64) -> f64 {
    if quantity > 5.0 {
        quantity * MANGO_WHOLESALE_PER_KG
    } else {
        quantity * MANGO_RETAIL_PER_KG
    }
}
fn price_grapes(quantity: f64) -> f64 {
    if quantity > 2.0 {
        quantity * GRAPES_WHOLESALE_PER_KG
    } else {
        quantity * GRAPES_RETAIL_PER_KG
    }
}

對(duì)比之前的版本，我做了一些改動(dòng)……

水果的價(jià)格可能會(huì)波動(dòng)，但是在我們程序的生命周期內(nèi)，這些價(jià)格不會(huì)波動(dòng)。所以我將每種水果的零售價(jià)和批發(fā)價(jià)存儲(chǔ)在常量中。我將這些常量定義在 main() 函數(shù)之外（即全局常量），因?yàn)槲也粫?huì)在 main() 函數(shù)內(nèi)計(jì)算每種水果的價(jià)格。這些常量被聲明為 f64，因?yàn)樗鼈儗⑴c quantity 相乘，而 quantity 是 f64。記住，Rust 沒(méi)有隱式類型轉(zhuǎn)換 ??

當(dāng)水果名稱和用戶想要購(gòu)買的數(shù)量被存下來(lái)之后，calc_price() 函數(shù)被調(diào)用來(lái)計(jì)算用戶指定數(shù)量的水果的價(jià)格。這個(gè)函數(shù)接受水果名稱和數(shù)量作為參數(shù)，并將價(jià)格作為 f64 返回。

當(dāng)你看到 calc_price() 函數(shù)的內(nèi)部時(shí)，你會(huì)發(fā)現(xiàn)它是許多人所說(shuō)的包裝函數(shù)。它被稱為包裝函數(shù)，因?yàn)樗{(diào)用其他函數(shù)來(lái)完成它的臟活。

因?yàn)槊糠N水果都有不同的最低訂單數(shù)量，才能被認(rèn)為是批發(fā)購(gòu)買，為了確保代碼在未來(lái)可以輕松維護(hù)，每種水果都有單獨(dú)的函數(shù)負(fù)責(zé)計(jì)算價(jià)格。

所以，calc_price() 函數(shù)所做的就是確定用戶選擇了哪種水果，并調(diào)用相應(yīng)的函數(shù)來(lái)計(jì)算所選水果的價(jià)格。這些水果特定的函數(shù)只接受一個(gè)參數(shù)：數(shù)量。這些水果特定的函數(shù)將價(jià)格作為 f64 返回。

現(xiàn)在，price_*() 函數(shù)只做一件事。它們檢查訂單數(shù)量是否大于被認(rèn)為是批發(fā)購(gòu)買的最低訂單數(shù)量。如果是這樣，quantity 將會(huì)乘以水果的每千克批發(fā)價(jià)格。否則，quantity 將會(huì)乘以水果的每千克零售價(jià)格。

由于乘法行末尾沒(méi)有分號(hào)，所以函數(shù)返回乘積。

如果你仔細(xì)看看 calc_price() 函數(shù)中水果特定函數(shù)的函數(shù)調(diào)用，這些函數(shù)調(diào)用在末尾沒(méi)有分號(hào)。這意味著，price_*() 函數(shù)返回的值將會(huì)被 calc_price() 函數(shù)返回給它的調(diào)用者。

而且 calc_price() 函數(shù)只有一個(gè)調(diào)用者。這個(gè)調(diào)用者在 mart 循環(huán)的末尾，這個(gè)調(diào)用者使用這個(gè)函數(shù)返回的值來(lái)增加 total 的值。

最終，當(dāng) mart 循環(huán)結(jié)束（當(dāng)用戶輸入 q 或 quit 時(shí)），存儲(chǔ)在變量 total 中的值將會(huì)被打印到屏幕上，并且用戶將會(huì)被告知他/她需要支付的價(jià)格。