日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

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

創(chuàng)新互聯(lián)建站是網(wǎng)站建設(shè)技術(shù)企業(yè)，為成都企業(yè)提供專業(yè)的成都網(wǎng)站設(shè)計、成都做網(wǎng)站、外貿(mào)網(wǎng)站建設(shè)，網(wǎng)站設(shè)計，網(wǎng)站制作，網(wǎng)站改版等技術(shù)服務(wù)。擁有十多年豐富建站經(jīng)驗和眾多成功案例，為您定制適合企業(yè)的網(wǎng)站。十多年品質(zhì)，值得信賴！

在 Rust 基礎(chǔ)系列的最后一章里，讓我們現(xiàn)在用 Rust 編寫一個程序，使用這些主題，以便更好地理解它們在現(xiàn)實世界中的用途。讓我們來編寫一個相對簡單的程序，用來從水果市場訂購水果。

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

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

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

獲取用戶輸入

上面的代碼非常簡單。目前，你不知道接下來該做什么，因為你不知道用戶接下來想做什么。

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

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

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

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

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

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

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

Rust 標(biāo)準(zhǔn)庫 std 中的 io 模塊是接受用戶輸入所必需的。因此，我們在程序的第一行添加了一個 use 語句。

2. 理解 Rust 中的 String 類型

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

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

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

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

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

3. 接受用戶輸入

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

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

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

所以，請在處理它時要么考慮到這個換行符，要么將它刪除。

Rust 中的錯誤處理入門

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

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

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

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

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

驗證用戶輸入

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

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

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

use std::io;
fn main() {
    println!("歡迎來到水果市場！");
    println!("請選擇要購買的水果。\n");
    println!("\n可以購買的水果：蘋果、香蕉、橘子、芒果、葡萄");
    println!("購買完成后，請輸入“quit”或“q”。\n");
    // 獲取用戶輸入
    let mut user_input = String::new();
    io::stdin()
        .read_line(&mut user_input)
        .expect("無法讀取用戶輸入。");
    // 驗證用戶輸入
    let valid_inputs = ["蘋果", "香蕉", "橘子", "芒果", "葡萄", "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;
        }
    }
}

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

用戶可能不知道我們希望輸入是什么樣的。用戶可能會輸入“Apple”、“apple”或 “APPLE” 來表示他們想要購買蘋果。我們的工作是正確處理這些輸入。

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

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

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

處理無效輸入

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

use std::io;
fn main() {
    println!("歡迎來到水果市場！");
    println!("請選擇要購買的水果。\n");
    let valid_inputs = ["蘋果", "香蕉", "橘子", "芒果", "葡萄", "quit", "q"];
    'mart: loop {
        let mut user_input = String::new();
        println!("\n可以購買的水果：蘋果、香蕉、橘子、芒果、葡萄");
        println!("購買完成后，請輸入“quit”或“q”。\n");
        // 讀取用戶輸入
        io::stdin()
            .read_line(&mut user_input)
            .expect("無法讀取用戶輸入。");
        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;
            }
        }
        // 處理無效輸入
        if input_error {
            println!("錯誤: 請輸入有效的輸入");
            continue 'mart;
        }
    }
}

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

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

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

因為你也知道用戶選擇了哪種水果，所以讓我們問一下他們打算購買多少，并告訴他們輸入數(shù)量的格式。

use std::io;
fn main() {
    println!("歡迎來到水果市場！");
    println!("請選擇要購買的水果。\n");
    let valid_inputs = ["蘋果", "香蕉", "橘子", "芒果", "葡萄", "quit", "q"];
    'mart: loop {
        let mut user_input = String::new();
        let mut quantity = String::new();
        println!("\n可以購買的水果：蘋果、香蕉、橘子、芒果、葡萄");
        println!("購買完成后，請輸入“quit”或“q”。\n");
        // 讀取用戶輸入
        io::stdin()
            .read_line(&mut user_input)
            .expect("無法讀取用戶輸入。");
        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;
            }
        }
        // 處理無效輸入
        if input_error {
            println!("錯誤: 請輸入有效的輸入");
            continue 'mart;
        }
        // 如果用戶想要退出，就退出
        if user_input == "q" || user_input == "quit" {
            break 'mart;
        }
        // 獲取數(shù)量
        println!(
            "\n你選擇購買的水果是 \"{}\"。請輸入以千克為單位的數(shù)量。
（1 千克 500 克的數(shù)量應(yīng)該輸入為 '1.5'。）",
            user_input
        );
        io::stdin()
            .read_line(&mut quantity)
            .expect("無法讀取用戶輸入。");
    }
}

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

解析數(shù)量

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

就像 read_line() 方法一樣，parse() 方法返回一個 Result 枚舉。parse() 方法返回 Result 枚舉的原因可以通過我們試圖實現(xiàn)的內(nèi)容來輕松理解。

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

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

因此，這個錯誤也需要處理。我們將使用 expect() 函數(shù)來處理這個錯誤。

use std::io;
fn main() {
    println!("歡迎來到水果市場！");
    println!("請選擇要購買的水果。\n");
    let valid_inputs = ["蘋果", "香蕉", "橘子", "芒果", "葡萄", "quit", "q"];
    'mart: loop {
        let mut user_input = String::new();
        let mut quantity = String::new();
        println!("\n可以購買的水果：蘋果、香蕉、橘子、芒果、葡萄");
        println!("購買完成后，請輸入“quit”或“q”。\n");
        // 讀取用戶輸入
        io::stdin()
            .read_line(&mut user_input)
            .expect("無法讀取用戶輸入。");
        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;
            }
        }

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

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

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

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

計算價格 + 最后的修飾

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

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

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

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

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!("歡迎來到水果市場！");
    println!("請選擇要購買的水果。\n");
    let valid_inputs = ["蘋果", "香蕉", "橘子", "芒果", "葡萄", "quit", "q"];
    'mart: loop {
        let mut user_input = String::new();
        let mut quantity = String::new();
        println!("\n可以購買的水果：蘋果、香蕉、橘子、芒果、葡萄");
        println!("購買完成后，請輸入“quit”或“q”。\n");
        // 讀取用戶輸入
        io::stdin()
            .read_line(&mut user_input)
            .expect("無法讀取用戶輸入。");
        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;
            }
        }
        // 處理無效輸入
        if input_error {
            println!("錯誤: 請輸入有效的輸入");
            continue 'mart;
        }
        // 如果用戶想要退出，就退出
        if user_input == "q" || user_input == "quit" {
            break 'mart;
        }
        // 獲取數(shù)量
        println!(
            "\n你選擇購買的水果是 \"{}\"。請輸入以千克為單位的數(shù)量。
（1 千克 500 克的數(shù)量應(yīng)該輸入為 '1.5'。）",
            user_input
        );
        io::stdin()
            .read_line(&mut quantity)
            .expect("無法讀取用戶輸入。");
        let quantity: f64 = quantity
            .trim()
            .parse()
            .expect("請輸入有效的數(shù)量。");
        total += calc_price(quantity, user_input);
    }
    println!("\n\n總價是 {} 盧比。", 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
    }
}

對比之前的版本，我做了一些改動……

水果的價格可能會波動，但是在我們程序的生命周期內(nèi)，這些價格不會波動。所以我將每種水果的零售價和批發(fā)價存儲在常量中。我將這些常量定義在 main() 函數(shù)之外（即全局常量），因為我不會在 main() 函數(shù)內(nèi)計算每種水果的價格。這些常量被聲明為 f64，因為它們將與 quantity 相乘，而 quantity 是 f64。記住，Rust 沒有隱式類型轉(zhuǎn)換

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

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

因為每種水果都有不同的最低訂單數(shù)量，才能被認(rèn)為是批發(fā)購買，為了確保代碼在未來可以輕松維護(hù)，每種水果都有單獨的函數(shù)負(fù)責(zé)計算價格。

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

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

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

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

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

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

總結(jié)

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

現(xiàn)在，我寫的代碼肯定可以用一種更符合編程習(xí)慣的方式來寫，這種方式最好地使用了 Rust 的喜愛特性，但是我還沒有講到它們！

所以，敬請關(guān)注后續(xù)的 將 Rust 帶入下一個層次 系列，并學(xué)習(xí)更多 Rust 編程語言的內(nèi)容！

Rust 基礎(chǔ)系列到此結(jié)束。歡迎你的反饋。