三.商城

• list.txt

衣服0 0
衣服1 0
衣服2 0
衣服3 0
衣服4 0
衣服5 0
衣服6 0
衣服7 0
衣服8 0
衣服9 0
衣服10 0
衣服11 0
衣服12 0
衣服13 0
衣服14 0
衣服15 0
衣服16 0
衣服17 0
衣服18 0
衣服19 0
衣服20 0
衣服21 0
衣服22 0
衣服23 0
衣服24 0
衣服25 0
衣服26 0
衣服27 0
衣服28 0
衣服29 0
衣服30 0
衣服31 0
衣服32 0
衣服33 0
衣服34 0
衣服35 0
衣服36 0
衣服37 0
衣服38 0
衣服39 0
衣服40 0
衣服41 0
衣服42 0
衣服43 0
衣服44 0
衣服45 0
衣服46 0
衣服47 0
衣服48 0
衣服49 0
袜子0 1
袜子1 1
袜子2 1
袜子3 1
袜子4 1
袜子5 1
袜子6 1
袜子7 1
袜子8 1
袜子9 1
袜子10 1
袜子11 1
袜子12 1
袜子13 1
袜子14 1
袜子15 1
袜子16 1
袜子17 1
袜子18 1
袜子19 1
袜子20 1
袜子21 1
袜子22 1
袜子23 1
袜子24 1
袜子25 1
袜子26 1
袜子27 1
袜子28 1
袜子29 1
袜子30 1
袜子31 1
袜子32 1
袜子33 1
袜子34 1
袜子35 1
袜子36 1
袜子37 1
袜子38 1
袜子39 1
袜子40 1
袜子41 1
袜子42 1
袜子43 1
袜子44 1
袜子45 1
袜子46 1
袜子47 1
袜子48 1
袜子49 1
帽子0 2
帽子1 2
帽子2 2
帽子3 2
帽子4 2
帽子5 2
帽子6 2
帽子7 2
帽子8 2
帽子9 2
帽子10 2
帽子11 2
帽子12 2
帽子13 2
帽子14 2
帽子15 2
帽子16 2
帽子17 2
帽子18 2
帽子19 2
帽子20 2
帽子21 2
帽子22 2
帽子23 2
帽子24 2
帽子25 2
帽子26 2
帽子27 2
帽子28 2
帽子29 2
帽子30 2
帽子31 2
帽子32 2
帽子33 2
帽子34 2
帽子35 2
帽子36 2
帽子37 2
帽子38 2
帽子39 2
帽子40 2
帽子41 2
帽子42 2
帽子43 2
帽子44 2
帽子45 2
帽子46 2
帽子47 2
帽子48 2
帽子49 2
裤子0 3
裤子1 3
裤子2 3
裤子3 3
裤子4 3
裤子5 3
裤子6 3
裤子7 3
裤子8 3
裤子9 3
裤子10 3
裤子11 3
裤子12 3
裤子13 3
裤子14 3
裤子15 3
裤子16 3
裤子17 3
裤子18 3
裤子19 3
裤子20 3
裤子21 3
裤子22 3
裤子23 3
裤子24 3
裤子25 3
裤子26 3
裤子27 3
裤子28 3
裤子29 3
裤子30 3
裤子31 3
裤子32 3
裤子33 3
裤子34 3
裤子35 3
裤子36 3
裤子37 3
裤子38 3
裤子39 3
裤子40 3
裤子41 3
裤子42 3
裤子43 3
裤子44 3
裤子45 3
裤子46 3
裤子47 3
裤子48 3
裤子49 3
电脑0 4
电脑1 4
电脑2 4
电脑3 4
电脑4 4
电脑5 4
电脑6 4
电脑7 4
电脑8 4
电脑9 4
电脑10 4
电脑11 4
电脑12 4
电脑13 4
电脑14 4
电脑15 4
电脑16 4
电脑17 4
电脑18 4
电脑19 4
电脑20 4
电脑21 4
电脑22 4
电脑23 4
电脑24 4
电脑25 4
电脑26 4
电脑27 4
电脑28 4
电脑29 4
电脑30 4
电脑31 4
电脑32 4
电脑33 4
电脑34 4
电脑35 4
电脑36 4
电脑37 4
电脑38 4
电脑39 4
电脑40 4
电脑41 4
电脑42 4
电脑43 4
电脑44 4
电脑45 4
电脑46 4
电脑47 4
电脑48 4
电脑49 4
鼠标0 5
鼠标1 5
鼠标2 5
鼠标3 5
鼠标4 5
鼠标5 5
鼠标6 5
鼠标7 5
鼠标8 5
鼠标9 5
鼠标10 5
鼠标11 5
鼠标12 5
鼠标13 5
鼠标14 5
鼠标15 5
鼠标16 5
鼠标17 5
鼠标18 5
鼠标19 5
鼠标20 5
鼠标21 5
鼠标22 5
鼠标23 5
鼠标24 5
鼠标25 5
鼠标26 5
鼠标27 5
鼠标28 5
鼠标29 5
鼠标30 5
鼠标31 5
鼠标32 5
鼠标33 5
鼠标34 5
鼠标35 5
鼠标36 5
鼠标37 5
鼠标38 5
鼠标39 5
鼠标40 5
鼠标41 5
鼠标42 5
鼠标43 5
鼠标44 5
鼠标45 5
鼠标46 5
鼠标47 5
鼠标48 5
鼠标49 5
键盘0 6
键盘1 6
键盘2 6
键盘3 6
键盘4 6
键盘5 6
键盘6 6
键盘7 6
键盘8 6
键盘9 6
键盘10 6
键盘11 6
键盘12 6
键盘13 6
键盘14 6
键盘15 6
键盘16 6
键盘17 6
键盘18 6
键盘19 6
键盘20 6
键盘21 6
键盘22 6
键盘23 6
键盘24 6
键盘25 6
键盘26 6
键盘27 6
键盘28 6
键盘29 6
键盘30 6
键盘31 6
键盘32 6
键盘33 6
键盘34 6
键盘35 6
键盘36 6
键盘37 6
键盘38 6
键盘39 6
键盘40 6
键盘41 6
键盘42 6
键盘43 6
键盘44 6
键盘45 6
键盘46 6
键盘47 6
键盘48 6
键盘49 6

• 代码

use std::{
    cmp::Ordering,
    io::{self, Write},
};

use rand::Rng;

fn main() {
    #[derive(Debug, Clone)]
    struct ExamRecord {
        id: u64,
        name: String,
        classify: String,
        price: f32,
        stock: i32,
        buy: i32,
    }
    const NAMES_CONTENT: &'static str = include_str!("./list.txt");

    impl ExamRecord {
        fn gen_records() -> Vec<ExamRecord> {
            let mut id = 0u64;
            NAMES_CONTENT
                .split("\n")
                .filter(|s| !s.is_empty())
                .take(1000)
                .map(|s| {
                    let mut rng = rand::thread_rng();
                    let n = rng.gen_range(1..100);

                    let price = if (id + 1) % 10 == 0 && n % 7 == 0 {
                        0.6f32
                    } else {
                        let score: f32 = rng.gen();
                        let score = 10.0 + score * 60.0;
                        score
                    };

                    let stock = if (id + 1) % 10 == 0 && n % 7 == 0 {
                        0i32
                    } else {
                        let score: f32 = rng.gen();
                        let score = 0.0 + score * 60.0;
                        score as i32
                    };
                    id += 1;
                    let mut iter = s.split(" ");
                    ExamRecord {
                        id,
                        name: iter.next().unwrap().to_owned(),
                        classify: iter.next().unwrap().to_owned(),
                        price,
                        stock,
                        buy: 0,
                    }
                })
                .collect::<Vec<ExamRecord>>()
        }
    }

    impl std::fmt::Display for ExamRecord {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            write!(
                f,
                "   {:05}    {:08}    {:08}   {:.2}    {:>7}    {:>6}",
                self.id, &self.name, &self.classify, &self.price, &self.stock, &self.buy
            )
        }
    }
    let mut records = ExamRecord::gen_records();
    fn print_main_menu() {
        println!("\n----- 电商系统 ----");
        println!("   1. 打印商品列表");
        println!("   2. 查询商品分类");
        println!("   3. 根据名称查询商品");
        println!("   4. 下单");
        println!("   5. 支付");
        println!("   6. 退出");
    }
    fn print_table_header() {
        println!("#    商品编号  商品名称    商品分类     商品价格     库存数量   购买数量");
        println!("------------------------------------------------------------------------------");
    }
    fn print_records(records: &Vec<ExamRecord>) {
        print_table_header();
        let mut index = 0;
        records.iter().for_each(|r| {
            index += 1;
            println!("{:>3} {}", index, r);
        });
    }
    fn search_classify(records: &Vec<ExamRecord>) {
        print!("\n请输入商品类别[0-6] :");
        io::stdout().flush().unwrap();
        let mut classify = String::new();
        io::stdin().read_line(&mut classify).unwrap();
        let mut rest_goods: Vec<ExamRecord> = vec![];
        records.iter().for_each(|f| {
            if f.classify == classify.trim() {
                rest_goods.push(f.clone());
            }
        });
        if rest_goods.len() > 0 {
            print_records(&rest_goods);
        } else {
            println!("暂无搜索的商品类别")
        }
    }
    fn search_goods(records: &Vec<ExamRecord>, mut goods: &mut String) {
        print!("\n请输入名称 :");
        io::stdout().flush().unwrap();

        io::stdin().read_line(&mut goods).unwrap();
        for val in records.iter() {
            if val.name == goods.trim() {
                let target = vec![val.clone()];
                print_records(&target)
            }
        }
    }
    fn sum_buy(records: &mut Vec<ExamRecord>, goods: &String) {
        print!("\n请输入购买数量 :");
        io::stdout().flush().unwrap();
        let mut count = String::new();
        io::stdin().read_line(&mut count).expect("输入错误");
        let stock = records.iter().next().unwrap().stock;
        let count = count.trim().parse::<i32>().expect("输入数据有误");
        match count.cmp(&stock) {
            Ordering::Greater => {
                println!("库存不足，下单失败！库存：{},下单数量：{}", stock, count)
            }
            _ => {
                for i in 0..records.len() {
                    if records[i].name == goods.trim() {
                        records[i].stock = records[i].stock - count;
                        records[i].buy = records[i].buy + count;
                        let target = vec![records[i].clone()];
                        print_records(&target)
                    }
                }
                println!("下单成功")
            }
        }
    }
    fn payment(records: &mut Vec<ExamRecord>, money: f32) {
        let mut rest_goods: Vec<ExamRecord> = vec![];
        let mut total_price = 0f32;
        records.iter().for_each(|f| {
            if f.buy > 0 {
                rest_goods.push(f.clone());
                total_price += f.price * f.buy as f32;
            }
        });
        if money > total_price {
            print_records(&rest_goods);
            println!("支付成功，余额：{} 元", money - total_price)
        } else {
            println!(
                "余额不足，支付失败！商品价格：{} 元,余额：{} 元",
                total_price, money
            )
        }
    }
    let money: f32 = 1000.0;
    let mut goods: String = String::new();
    loop {
        print_main_menu();

        print!("\n请选择 [1 - 5]:");
        io::stdout().flush().unwrap();

        let mut choice = String::new();
        io::stdin().read_line(&mut choice).unwrap();

        match choice.trim() {
            "1" => print_records(&records),
            "2" => search_classify(&records),
            "3" => search_goods(&records, &mut goods),
            "4" => sum_buy(&mut records, &goods),
            "5" => payment(&mut records, money),
            "6" => break,
            _ => println!("Unkown option"),
        }
    }
}