1. 基础语法篇¶

use std::io;
use std::cmp::Ordering;
use rand::RngExt;   // rand 0.10+ 中 random_range 等方法定义在 RngExt trait 中

fn main() {
    println!("猜数字游戏！");

    // rand 0.10+ 的 API：rand::rng() 替代旧版 rand::thread_rng()
    // random_range(1..=100)：生成闭区间 [1, 100] 的随机数（替代旧版 gen_range）
    let secret_number = rand::rng().random_range(1..=100);

    loop {
        println!("请输入你的猜测：");

        // 每次循环都要新建 String（read_line 是追加写入）
        let mut guess = String::new();
        io::stdin().read_line(&mut guess)
            .expect("读取失败");          // expect：失败直接 panic

        // 变量遮蔽：把 guess 从 String 重新绑定为 u32
        // 类型标注告诉 parse 解析成 u32
        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,   // 输入非数字则重来
        };

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("太小了！"),
            Ordering::Greater => println!("太大了！"),
            Ordering::Equal => {
                println!("你猜对了！");
                break;
            }
        }
    }
}

use std::env;

fn main() {
    // collect 收集所有命令行参数为 Vec<String>
    let args: Vec<String> = env::args().collect();

// args[0] 是程序名（路径），所以"数字 运算符 数字"共需 4 个参数
    if args.len() != 4 {
        println!("用法：cargo run -- <数字> <运算符> <数字>");
        return;   // return 提前结束 main，不 panic
    }

    // parse 返回 Result<f64, ParseFloatError>
    // 这里先用 unwrap：成功取出值，失败直接 panic（简化处理，见注意事项的改进练习）
    let a: f64 = args[1].parse().unwrap();
    let op = &args[2];   // 借用，不移动所有权
    let b: f64 = args[3].parse().unwrap();

    // match 表达式：每个分支都返回 f64，整个 match 赋给 result
    let result = match op.as_str() {
        "+" => a + b,
        "-" => a - b,
        "*" => a * b,
        "/" => {
            // 浮点除零不 panic 但会得到 inf，必须显式判断
            if b == 0.0 {
                println!("不能除以零！");
                return;
            }
            a / b
        }
        _ => { println!("不支持的运算符：{}", op); return; }
    };

    println!("{} {} {} = {}", a, op, b, result);
}

use std::env;
use std::fs;

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() != 2 {
        println!("用法：cargo run -- <文件名>");
        return;
    }

    let filename = &args[1];
    // read_to_string 返回 Result<String, io::Error>，expect 遇错 panic
    let content = fs::read_to_string(filename)
        .expect("读取文件失败");

    // 这三处都是对 content 的借用迭代（lines/split_whitespace/chars 都返回借用）
    // content 全程活着，所以可以连续调用
    let line_count = content.lines().count();
    let word_count = content.split_whitespace().count();
    let char_count = content.chars().count();

    println!("文件：{}", filename);
    println!("行数：{}", line_count);
    println!("单词数：{}", word_count);
    println!("字符数：{}", char_count);
}

use std::env;
use std::fs;

fn main() {
    let args: Vec<String> = env::args().collect();
    let path = &args[1];

    let content = fs::read_to_string(path);

    match content {
        Ok(text) => {
            let line_count = text.lines().count();
            let char_count = text.chars().count();
            let word_count = text.split_whitespace().count();
            println!("行数：{}", line_count);
            println!("字符数：{}", char_count);
            println!("单词数：{}", word_count);
        }
        Err(e) => {
            println!("无法读取文件 {}: {}", path, e);
        }
    }
}