🦀 Rust 入门基础

# Linux / macOS
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# 验证
rustc --version   # e.g. rustc 1.78.0
cargo --version   # e.g. cargo 1.78.0

cargo new hello_rust
cd hello_rust

# 生成的目录结构
# hello_rust/
# ├── Cargo.toml    # 项目配置（类似 package.json / go.mod）
# └── src/
#     └── main.rs   # 入口文件

cargo run
# → Hello, world!

fn main() {
    println!("Hello, world!");
}

fn main() {
    let name = "Rust";
    let year = 2015;
    
    // println! 格式化
    println!("Hello, {}!", name);                    // 位置参数
    println!("{0} was released in {1}, {0}!", name, year); // 命名索引
    println!("{name} {year}", name=name, year=year); // 命名参数
    println!("{:?}", (1, "two", 3.0));               // Debug 格式
    println!("{:#?}", vec![1, 2, 3]);                // 美化 Debug
    
    // 对比 Python:  f"Hello, {name}!"
    // 对比 Go:      fmt.Sprintf("Hello, %s!", name)
}

[package]
name = "hello_rust"
version = "0.1.0"
edition = "2021"   # Rust 版本（edition），不是编译器版本

[dependencies]
# serde = "1.0"    # 取消注释即可添加依赖

fn main() {
    let x = 5;
    // x = 6;  // ❌ 编译错误！cannot assign twice to immutable variable
    
    let mut y = 5;
    y = 6;      // ✅ 可变变量可以重新赋值
}

// 常量必须标注类型，命名全大写，编译期求值
const MAX_POINTS: u32 = 100_000;  // 下划线提高可读性

fn main() {
    println!("Max: {}", MAX_POINTS);
}

fn main() {
    let x = 5;
    let x = x + 1;       // shadowing：用同一个名字声明新变量
    let x = x * 2;       // 再 shadow 一次
    println!("x = {}", x); // x = 12
    
    // shadowing 可以改变类型！
    let spaces = "   ";           // &str
    let spaces = spaces.len();    // usize — 类型变了
    
    // mut 不行：
    // let mut y = "   ";
    // y = y.len();  // ❌ 类型不匹配！
}

// 整数字面量
let decimal = 98_222;        // 下划线分隔
let hex = 0xff;
let octal = 0o77;
let binary = 0b1111_0000;
let byte = b'A';             // u8 only

// 浮点
let x = 2.0;       // f64（默认）
let y: f32 = 3.0;  // f64

// 布尔
let t = true;
let f: bool = false;

// 字符 — Unicode，不是 ASCII byte
let c = 'z';
let z = 'ℤ';
let heart = '❤';
let emoji = '🦀';    // char 是 4 字节 Unicode 标量值

fn main() {
    let tup: (i32, f64, &str) = (500, 6.4, "hello");
    
    // 解构
    let (x, y, z) = tup;
    println!("y = {}", y);  // 6.4
    
    // 索引访问（用 . 不是 []）
    let first = tup.0;      // 500
    let second = tup.1;     // 6.4
    
    // 单元素元组
    let single = (42,);     // 注意逗号
    let not_tuple = (42);   // 这只是 42，括号表达式
}

fn main() {
    // 固定长度，栈上分配
    let arr = [1, 2, 3, 4, 5];
    let arr: [i32; 5] = [1, 2, 3, 4, 5];     // 显式类型
    let arr = [3; 5];                          // [3, 3, 3, 3, 3]
    
    // 访问
    let first = arr[0];
    // let out = arr[10];  // ❌ 编译错误 / 运行时 panic
    
    // 数组是固定大小的！
    // 需要动态大小？用 Vec
}

fn main() {
    let arr = [1, 2, 3, 4, 5];
    
    // 切片是对数组/Vec的引用视图
    let slice: &[i32] = &arr[1..3];  // [2, 3]
    let full: &[i32] = &arr[..];     // [1, 2, 3, 4, 5]
    let from_two: &[i32] = &arr[2..]; // [3, 4, 5]
    
    // 切片是胖指针 = (数据指针, 长度)
    // Python: arr[1:3]
    // Go:     arr[1:3]
}

fn main() {
    // &str — 字符串切片，借用的视图
    let s1: &str = "hello";        // 字符串字面量，存在二进制里
    let s2: &str = &String::from("world")[..];
    
    // String — 堆分配的可增长字符串
    let mut s3: String = String::from("hello");
    s3.push_str(", world");
    s3.push('!');
    
    // &str → String
    let s4 = s1.to_string();       // 方法1
    let s5 = String::from(s1);     // 方法2
    
    // String → &str（自动解引用）
    let s6: &str = &s3;            // Deref coercion
    take_str(s3.as_str());         // 显式转换
    
    // 函数参数：优先用 &str（更通用）
    fn take_str(s: &str) {
        println!("{}", s);
    }
    
    take_str("literal");           // ✅ &str
    take_str(&s3);                 // ✅ &String → &str (deref)
}

// 参数必须声明类型
fn add(x: i32, y: i32) -> i32 {
    x + y  // 没有分号！最后一个表达式就是返回值
}

fn main() {
    let result = add(3, 4);
    println!("3 + 4 = {}", result);
}

fn main() {
    // 语句（statement）— 执行操作，不返回值
    let x = 5;           // let 是语句
    
    // 表达式（expression）— 求值并返回结果
    let y = {
        let x = 3;
        x + 1            // 没有分号 → 表达式，返回 4
        // x + 1;        // 加了分号 → 语句，返回 ()
    };
    println!("y = {}", y); // y = 4
    
    // if 也是表达式！
    let condition = true;
    let number = if condition { 5 } else { 6 };
    println!("number = {}", number); // 5
}

// 返回单元类型 () — 可以省略
fn say_hello() {
    println!("Hello!");
}

// 等价于
fn say_hello() -> () {
    println!("Hello!");
}

// 提前返回用 return（通常只在提前返回时用）
fn abs(x: i32) -> i32 {
    if x < 0 {
        return -x;  // 提前返回
    }
    x              // 最后一行用表达式，不用 return
}

fn main() {
    let number = 6;
    
    // 不需要括号！
    if number % 4 == 0 {
        println!("divisible by 4");
    } else if number % 3 == 0 {
        println!("divisible by 3");
    } else if number % 2 == 0 {
        println!("divisible by 2");
    } else {
        println!("not divisible by 4, 3, or 2");
    }
    
    // if 作为表达式 — 两个分支类型必须一致
    let condition = true;
    let x = if condition { 5 } else { 6 };
    // let x = if condition { 5 } else { "six" }; // ❌ 类型不匹配
    
    // 对比 Python: x = 5 if condition else 6
    // 对比 Go:    没有 ternary，必须 if-else
}

fn main() {
    // 基本用法
    let mut count = 0;
    loop {
        count += 1;
        if count == 5 {
            break;  // 退出循环
        }
    }
    
    // loop 带返回值！
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2;  // break 带值 → loop 表达式的值
        }
    };
    println!("result = {}", result); // 20
    
    // 循环标签 — 嵌套循环中指定 break/continue 哪一层
    'outer: loop {
        println!("outer");
        loop {
            println!("inner");
            break 'outer;  // 跳出外层循环
        }
    }
}

fn main() {
    let mut number = 3;
    while number != 0 {
        println!("{}!", number);
        number -= 1;
    }
    println!("LIFTOFF!!!");
    
    // while 不带返回值（永远是 ()）
    // 需要返回值？用 loop + break
}

fn main() {
    // 遍历数组
    let arr = [10, 20, 30, 40, 50];
    for element in arr {
        println!("value: {}", element);
    }
    
    // Range
    for i in 0..5 {        // 0, 1, 2, 3, 4（不含5）
        println!("{}", i);
    }
    for i in 0..=5 {       // 0, 1, 2, 3, 4, 5（含5）
        println!("{}", i);
    }
    
    // 反向
    for i in (1..4).rev() {
        println!("{}!", i); // 3! 2! 1!
    }
    
    // 步长
    for i in (0..10).step_by(2) {
        println!("{}", i); // 0 2 4 6 8
    }
    
    // enumerate（类似 Python）
    for (i, val) in arr.iter().enumerate() {
        println!("{}: {}", i, val);
    }
}

fn main() {
    for i in 0..10 {
        if i == 3 {
            continue;  // 跳过 3
        }
        if i == 7 {
            break;     // 到 7 停止
        }
        println!("{}", i); // 0 1 2 4 5 6
    }
}

fn main() {
    let number = 13;
    
    match number {
        1          => println!("one"),
        2 | 3 | 5  => println!("prime under 5"),
        13..=19    => println!("a teen"),       // 范围模式
        _          => println!("something else"), // _ 是通配符
    }
    
    // match 是表达式
    let text = match number {
        1     => "one",
        2     => "two",
        3..=9 => "single digit",
        _     => "big number",
    };
    println!("{}", text);
}

fn main() {
    // 解构元组
    let point = (3, -5);
    match point {
        (0, 0) => println!("origin"),
        (x, 0) => println!("on x-axis at {}", x),
        (0, y) => println!("on y-axis at {}", y),
        (x, y) => println!("at ({}, {})", x, y),
    }
    
    // 解构结构体
    struct Color { r: u8, g: u8, b: u8 }
    let c = Color { r: 255, g: 0, b: 128 };
    match c {
        Color { r: 255, g: 0, b } => println!("red-ish, blue={}", b),
        Color { r, g, b } => println!("r={}, g={}, b={}", r, g, b),
    }
    
    // 解构枚举
    enum Message {
        Quit,
        Move { x: i32, y: i32 },
        Write(String),
    }
    let msg = Message::Move { x: 10, y: 20 };
    match msg {
        Message::Quit => println!("quit"),
        Message::Move { x, y } => println!("move to ({}, {})", x, y),
        Message::Write(text) => println!("write: {}", text),
    }
}

fn main() {
    let pair = (2, -2);
    match pair {
        (x, y) if x == y     => println!("twin"),
        (x, y) if x + y == 0 => println!("opposites"),
        (x, _) if x > 0      => println!("positive x"),
        _                    => println!("no match"),
    }
}

fn main() {
    let value = Some(7);
    
    // 用 match 有点啰嗦
    match value {
        Some(v) => println!("got {}", v),
        _ => (),  // 不关心 None
    }
    
    // if let 更简洁
    if let Some(v) = value {
        println!("got {}", v);
    }
    
    // 也可以加 else
    if let Some(v) = value {
        println!("some: {}", v);
    } else {
        println!("none");
    }
    
    // while let — 持续匹配直到 None
    let mut stack = Vec::new();
    stack.push(1);
    stack.push(2);
    stack.push(3);
    
    while let Some(top) = stack.pop() {
        println!("{}", top); // 3 2 1
    }
}

fn main() {
    // panic 会展开栈并终止线程
    panic!("something went terribly wrong!");
    
    // 数组越界也会 panic
    let v = vec![1, 2, 3];
    // v[99];  // panic: index out of bounds
}

use std::fs;
use std::io;

// Result 的定义
// enum Result {
//     Ok(T),    // 成功，包含值
//     Err(E),   // 失败，包含错误
// }

fn read_file(path: &str) -> Result {
    fs::read_to_string(path)  // 返回 Result
}

fn main() {
    // 处理 Result：match
    match read_file("hello.txt") {
        Ok(content) => println!("content: {}", content),
        Err(e) => println!("error: {}", e),
    }
    
    // 处理 Result：if let
    if let Ok(content) = read_file("hello.txt") {
        println!("content: {}", content);
    }
}

use std::fs;
use std::io;

// 没有 ? 的写法
fn read_username_manual(path: &str) -> Result {
    let content = match fs::read_to_string(path) {
        Ok(c) => c,
        Err(e) => return Err(e),  // 手动传播
    };
    Ok(content.trim().to_string())
}

// 用 ? 的写法 — 遇到 Err 自动提前返回
fn read_username(path: &str) -> Result {
    let content = fs::read_to_string(path)?;  // Ok → 解包；Err → return Err
    Ok(content.trim().to_string())
}

// ? 可以链式调用！
fn read_and_parse(path: &str) -> Result> {
    let num: i32 = fs::read_to_string(path)?.trim().parse()?;
    Ok(num)
    // 两种不同的错误类型都自动转换成 Box
}

fn main() -> Result<(), Box> {
    let name = read_username("user.txt")?;
    println!("username: {}", name);
    Ok(())
}

// Option 的定义
// enum Option {
//     Some(T),  // 有值
//     None,     // 无值
// }

fn find_user(id: u32) -> Option {
    if id == 1 {
        Some("Alice".to_string())
    } else {
        None
    }
}

fn main() {
    // match 处理
    match find_user(1) {
        Some(name) => println!("found: {}", name),
        None => println!("not found"),
    }
    
    // ? 也能用于 Option！
    fn get_name(id: u32) -> Option {
        let name = find_user(id)?;  // None → return None
        Some(format!("User: {}", name))
    }
    
    // 常用方法
    let x: Option = Some(42);
    x.unwrap();          // 42 — None 时 panic
    x.expect("must have value"); // 同上但可自定义消息
    x.unwrap_or(0);      // 42 — None 时返回默认值 0
    x.unwrap_or_else(|| expensive_default()); // 惰性默认值
    x.map(|v| v * 2);    // Some(84) — 转换内部值
    x.and_then(|v| Some(v + 1)); // Some(43) — 链式操作
    x.filter(|v| *v > 40); // Some(42) — 过滤
}

// 默认私有，pub 才能外部访问
mod network {
    pub fn connect() {
        println!("connecting...");
    }
    
    fn check_status() {  // 私有，外部不可见
        println!("checking...");
    }
    
    pub mod server {     // 嵌套模块
        pub fn start() {
            println!("server started");
            super::check_status();  // super 访问父模块
        }
    }
}

fn main() {
    network::connect();         // ✅ pub
    // network::check_status(); // ❌ 私有
    network::server::start();   // ✅ pub → pub
}

use std::collections::HashMap;    // 引入类型
use std::fs::{self, File};         // 同时引入模块和类型
use std::io::Result as IoResult;   // 别名

fn main() {
    let mut map = HashMap::new();  // 不用写全路径
    map.insert("key", "value");
    
    let _result: IoResult<()> = Ok(());
}

myapp/
├── Cargo.toml
└── src/
    ├── main.rs       # binary crate 入口
    ├── lib.rs        # library crate 入口（可选）
    ├── network.rs    # mod network → 文件名=模块名
    │                 # 或 network/mod.rs（旧风格）
    └── network/
        ├── mod.rs    # 或 network.rs（新风格二选一）
        └── server.rs

// src/main.rs
mod network;          // 声明模块，编译器找 network.rs 或 network/mod.rs

use network::connect; // 使用模块中的项

fn main() {
    connect();
}

// src/network.rs（或 src/network/mod.rs）
pub fn connect() {
    println!("connected!");
}

pub mod server;  // 声明子模块 → 编译器找 network/server.rs

// src/network/server.rs
pub fn start() {
    println!("server started");
}

cargo new fsearch
cd fsearch
cargo add clap --features derive

use clap::Parser;
use std::fs;
use std::path::{Path, PathBuf};

/// 🦀 fsearch — 一个简单的文件搜索工具
#[derive(Parser, Debug)]
#[command(name = "fsearch")]
#[command(author, version, about)]
struct Args {
    /// 搜索目录
    #[arg(default_value = ".")]
    directory: String,

    /// 按文件名模式搜索（支持 * 和 ? 通配符）
    #[arg(short, long)]
    name: Option,

    /// 按文件内容搜索
    #[arg(short, long)]
    content: Option,

    /// 最大搜索深度
    #[arg(short, long, default_value_t = 10)]
    depth: usize,

    /// 显示文件大小
    #[arg(long)]
    size: bool,
}

fn main() {
    let args = Args::parse();

    let root = Path::new(&args.directory);
    if !root.exists() {
        eprintln!("❌ 目录不存在: {}", args.directory);
        std::process::exit(1);
    }

    println!("🔍 搜索目录: {}", root.display());

    let mut count = 0u64;
    let mut total_size = 0u64;

    if let Err(e) = walk_dir(root, &args, 0, &mut count, &mut total_size) {
        eprintln!("❌ 错误: {}", e);
        std::process::exit(1);
    }

    println!("\n📊 统计: 找到 {} 个文件", count);
    if args.size {
        println!("📦 总大小: {} bytes", total_size);
    }
}

fn walk_dir(
    dir: &Path,
    args: &Args,
    current_depth: usize,
    count: &mut u64,
    total_size: &mut u64,
) -> Result<(), Box> {
    if current_depth > args.depth {
        return Ok(());
    }

    for entry in fs::read_dir(dir)? {
        let entry = entry?;
        let path = entry.path();
        let metadata = entry.metadata()?;

        if metadata.is_dir() {
            walk_dir(&path, args, current_depth + 1, count, total_size)?;
            continue;
        }

        // 文件名过滤
        if let Some(pattern) = &args.name {
            let file_name = path.file_name()
                .and_then(|n| n.to_str())
                .unwrap_or("");
            if !match_pattern(file_name, pattern) {
                continue;
            }
        }

        // 内容过滤
        if let Some(search_content) = &args.content {
            match fs::read_to_string(&path) {
                Ok(content) => {
                    if !content.contains(search_content) {
                        continue;
                    }
                }
                Err(_) => continue, // 跳过二进制文件等
            }
        }

        // 输出匹配文件
        *count += 1;
        *total_size += metadata.len();

        let size_info = if args.size {
            format!(" ({} B)", metadata.len())
        } else {
            String::new()
        };

        println!("  📄 {}{}", path.display(), size_info);

        // 如果是内容搜索，显示匹配行
        if let Some(search_content) = &args.content {
            if let Ok(content) = fs::read_to_string(&path) {
                for (i, line) in content.lines().enumerate() {
                    if line.contains(search_content) {
                        let trimmed = if line.len() > 80 {
                            &line[..80]
                        } else {
                            line
                        };
                        println!("     {}: {}", i + 1, trimmed);
                    }
                }
            }
        }
    }

    Ok(())
}

/// 简单的通配符匹配（支持 * 和 ?）
fn match_pattern(text: &str, pattern: &str) -> bool {
    let t: Vec = text.chars().collect();
    let p: Vec = pattern.chars().collect();
    match_inner(&t, &p, 0, 0)
}

fn match_inner(text: &[char], pattern: &[char], ti: usize, pi: usize) -> bool {
    if pi == pattern.len() {
        return ti == text.len();
    }
    if pattern[pi] == '*' {
        // * 匹配 0 个或多个字符
        for i in ti..=text.len() {
            if match_inner(text, pattern, i, pi + 1) {
                return true;
            }
        }
        return false;
    }
    if ti >= text.len() {
        return false;
    }
    if pattern[pi] == '?' || pattern[pi] == text[ti] {
        return match_inner(text, pattern, ti + 1, pi + 1);
    }
    false
}

# 基本用法 — 列出当前目录所有文件
cargo run -- .

# 按文件名搜索
cargo run -- /tmp --name "*.rs"

# 按内容搜索
cargo run -- src --content "fn main"

# 组合搜索 + 显示大小
cargo run -- . --name "*.toml" --size

# 查看帮助
cargo run -- --help

$ cargo run -- src --name "*.rs" --content "fn main"

🔍 搜索目录: src
  📄 src/main.rs
     36: fn main() {

📊 统计: 找到 1 个文件