Rust 常用库实战教程

# 现代方式（推荐）：用 cargo add，自动写入最新兼容版本
cargo add serde --features derive
cargo add tokio --features full
cargo add reqwest --features json

[dependencies]
serde = { version = "1", features = ["derive"] }
tokio = { version = "1", features = ["full"] }
reqwest = { version = "0.12", features = ["json"] }

cargo new my_app        # 新建二进制项目
cargo new my_lib --lib  # 新建库项目
cargo build             # 调试构建（快，无优化）
cargo build --release   # 发布构建（慢，有优化）
cargo run               # 构建并运行
cargo check             # 只检查不生成二进制，改代码时最快
cargo test              # 运行测试
cargo doc --open        # 生成并打开本项目（含依赖）的文档
cargo update            # 在语义化版本允许范围内升级依赖
cargo add / cargo rm    # 增删依赖
cargo tree              # 查看依赖树，排查版本冲突

[dependencies]
serde = { version = "1", features = ["derive"] }
serde_json = "1"

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug)]
struct User {
    name: String,
    age: u8,
    email: Option<String>, // 可空字段用 Option
}

fn main() -> serde_json::Result<()> {
    // 结构体 -> JSON 字符串
    let u = User { name: "小明".into(), age: 20, email: None };
    let s = serde_json::to_string(&u)?;
    println!("{s}"); // {"name":"小明","age":20,"email":null}

    // 美化输出
    println!("{}", serde_json::to_string_pretty(&u)?);

    // JSON 字符串 -> 结构体
    let raw = r#"{"name":"小红","age":18,"email":"a@b.com"}"#;
    let v: User = serde_json::from_str(raw)?;
    println!("{v:?}");
    Ok(())
}

#[derive(Serialize, Deserialize)]
struct Article {
    #[serde(rename = "id")]            // JSON 里的字段名与 Rust 字段名不同
    article_id: u64,

    #[serde(default)]                   // JSON 缺这个字段时用 Default 值而不是报错
    tags: Vec<String>,

    #[serde(default = "default_status")]// 缺省值用指定函数
    status: String,

    #[serde(skip_serializing)]          // 只反序列化，不序列化（如密码）
    password: String,

    #[serde(skip_serializing_if = "Option::is_none")] // None 时不输出该字段，而不是输出 null
    avatar: Option<String>,

    #[serde(flatten)]                   // 把内嵌结构体的字段拍平到本层
    extra: std::collections::HashMap<String, serde_json::Value>,
}

fn default_status() -> String { "draft".into() }

use serde_json::Value;

let raw = r#"{"code":0,"data":{"users":[{"name":"a"},{"name":"b"}]}}"#;
let v: Value = serde_json::from_str(raw)?;

// 用链式索引取值，类型不符返回 None 而不是 panic
if let Some(name) = v["data"]["users"][0]["name"].as_str() {
    println!("第一个用户：{name}");
}

// json! 宏快速构造 JSON
let payload = serde_json::json!({
    "title": "hello",
    "count": 3,
    "ok": true,
});

toml = "0.8"          # TOML
serde_yaml = "0.9"    # YAML

let toml_str = toml::to_string(&u).unwrap();
let back: User = toml::from_str(&toml_str).unwrap();

[dependencies]
anyhow = "1"

use anyhow::{Context, Result, bail, ensure};
use std::fs;

// 返回 anyhow::Result<T>，内部是 Box<dyn Error>，任何错误都能用 ? 自动转换
fn load_config(path: &str) -> Result<String> {
    // Context 给底层错误附上业务语义。这是 anyhow 最有价值的功能：
    // 没有它你只能看到 "No such file or directory"，不知道是哪个文件、在干嘛
    let content = fs::read_to_string(path)
        .with_context(|| format!("读取配置文件 {path} 失败"))?;
    Ok(content)
}

fn check_age(age: i32) -> Result<()> {
    ensure!(age >= 0, "年龄不能为负数: {age}");   // 条件不满足则提前返回错误
    if age > 150 {
        bail!("年龄不合理: {age}");              // 直接构造错误并返回，等价于 return Err(...)
    }
    Ok(())
}

fn main() -> Result<()> {
    // main 也可以返回 Result，出错时自动打印错误并退出码非 0
    let cfg = load_config("app.toml")?;
    println!("配置长度: {}", cfg.len());

    // 完整的错误链（含每一层 context）用 {:#} 打印
    if let Err(e) = check_age(-1) {
        eprintln!("错误链: {:#}", e);
        eprintln!("根因: {:?}", e.root_cause()); // 最底层那个错误
    }
    Ok(())
}

[dependencies]
thiserror = "2"

use thiserror::Error;

#[derive(Error, Debug)]
pub enum StoreError {
    #[error("记录 {0} 不存在")]                 // 错误信息模板，{0} 引用元组字段
    NotFound(u64),

    #[error("权限不足，需要 {need} 级，当前 {current} 级")] // 命名字段也可以
    PermissionDenied { need: u8, current: u8 },

    #[error("数据库错误")]                       // 展示给上层的文案
    #[from]                                     // 自动生成 From<sqlx::Error>，? 可自动转换
    Db(#[source] sqlx::Error),                  // #[source] 保留底层错误供溯源
}

fn find_user(id: u64) -> Result<String, StoreError> {
    if id == 0 { return Err(StoreError::NotFound(id)); }
    Ok("小明".into())
}

// 调用方可以精确匹配
fn handle() {
    match find_user(0) {
        Err(StoreError::NotFound(id)) => println!("404: {id}"),
        Err(StoreError::Db(e)) => println!("数据库挂了: {e}"),
        _ => {}
        Ok(name) => println!("{name}"),
    }
}

[dependencies]
tokio = { version = "1", features = ["full"] } # 学习中直接 full，生产再裁剪

// #[tokio::main] 宏把 main 变成运行时入口，等价于手动 Builder::new_multi_thread()...block_on
#[tokio::main]
async fn main() {
    let handle = tokio::spawn(async {
        // spawn 创建一个新的异步任务，由运行时并发调度
        // 类似线程，但成本极低：可以轻松起十万级任务
        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
        42
    });

    // JoinHandle 类似线程的 join，await 拿到任务返回值
    let answer = handle.await.unwrap();
    println!("{answer}");
}

use tokio::time::{sleep, Duration};

async fn fetch_user() -> Result<String, String> { sleep(Duration::from_millis(300)).await; Ok("user".into()) }
async fn fetch_orders() -> Result<Vec<String>, String> { sleep(Duration::from_millis(500)).await; Ok(vec!["o1".into()]) }

#[tokio::main]
async fn main() {
    // join!: 并发执行，全部完成后一起拿结果。总耗时取最长的那个（500ms 而非 800ms）
    let (u, o) = tokio::join!(fetch_user(), fetch_orders());

    // try_join!: 任何一个出错立即返回 Err，其余取消。适合「缺一不可」的聚合请求
    let r: Result<(String, Vec<String>), String> = tokio::try_join!(fetch_user(), fetch_orders());

    // select!: 谁先完成用谁，其余被 drop。适合超时、竞速备份请求
    tokio::select! {
        v = fetch_user() => println!("user 先到: {v:?}"),
        _ = sleep(Duration::from_secs(10)) => println!("超时了"),
    }
    let _ = (u, o, r);
}

use tokio::time::{timeout, Duration};

async fn slow() -> &'static str { tokio::time::sleep(Duration::from_secs(5)).await; "done" }

#[tokio::main]
async fn main() {
    // timeout 是 select! 的常见封装：到点未完成就返回 Err
    match timeout(Duration::from_secs(1), slow()).await {
        Ok(v) => println!("{v}"),
        Err(_) => println!("超时取消"), // 超时时 future 被 drop，任务自然取消
    }
}

use tokio::fs;
use tokio::io::{AsyncWriteExt, AsyncReadExt};

#[tokio::main]
async fn main() -> std::io::Result<()> {
    // 高层 API：一次性读写
    fs::write("a.txt", "你好").await?;
    let s = fs::read_to_string("a.txt").await?;

    // 低层 API：流式处理大文件
    let mut f = fs::File::create("b.txt").await?;
    f.write_all(s.as_bytes()).await?;  // 注意 trait 方法要 use AsyncWriteExt
    f.flush().await?;

    let mut buf = String::new();
    fs::File::open("b.txt").await?.read_to_string(&mut buf).await?;
    Ok(())
}

let hash = tokio::task::spawn_blocking(|| {
    // 这里跑同步的重计算，不会卡住异步调度器的工作线程
    expensive_hash()
}).await.unwrap();

use std::sync::Arc;
use tokio::sync::{Mutex, mpsc, oneshot, RwLock, Semaphore, Notify};

#[tokio::main]
async fn main() {
    // 1) tokio::sync::Mutex：跨 .await 持锁时必须用它（std::Mutex 的守卫不是 Send，且会阻塞线程）
    let counter = Arc::new(Mutex::new(0u64));
    let mut handles = vec![];
    for _ in 0..10 {
        let c = counter.clone();
        handles.push(tokio::spawn(async move {
            let mut n = c.lock().await; // 异步锁，拿不到时让出线程而不是阻塞
            *n += 1;
        }));
    }
    for h in handles { h.await.unwrap(); }
    println!("{}", *counter.lock().await); // 10

    // 2) mpsc 通道：多生产者单消费者，任务间通信的首选
    let (tx, mut rx) = mpsc::channel::<String>(100); // 100 是缓冲容量，满了 send 会 .await 背压
    tokio::spawn(async move {
        for i in 0..3 {
            tx.send(format!("消息{i}")).await.unwrap();
        }
    });
    while let Some(msg) = rx.recv().await { // 所有 tx 都 drop 后 recv 返回 None，循环结束
        println!("收到: {msg}");
    }

    // 3) oneshot：一次性应答，常用于「请求-响应」式取消通知
    let (tx, rx) = oneshot::channel::<&str>();
    tokio::spawn(async move { let _ = tx.send("pong"); });
    println!("{}", rx.await.unwrap());

    // 4) RwLock / Semaphore / Notify 与 std 对应物语义类似，但都是 async 版
    let sem = Arc::new(Semaphore::new(3)); // 限制并发度：最多 3 个任务同时进入临界区
    let permit = sem.acquire().await.unwrap();
    drop(permit); // 释放名额
    let _ = Notify::new(); // 事件通知：notify_one/notify_waiters + notified().await
    let _ = RwLock::new(0u8);
}

[dependencies]
reqwest = { version = "0.12", features = ["json"] }
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }

use serde::{Deserialize, Serialize};

#[derive(Deserialize, Debug)]
struct Post { id: u64, title: String }

#[derive(Serialize)]
struct NewPost { title: String, body: String }

#[tokio::main]
async fn main() -> reqwest::Result<()> {
    // 最简单的 GET
    let body = reqwest::get("https://jsonplaceholder.typicode.com/posts/1")
        .await?
        .text()          // .text() 拿字符串；.bytes() 拿字节；.json() 直接反序列化
        .await?;
    println!("原始响应: {}...", &body[..50.min(body.len())]);

    // GET + 反序列化为结构体（依赖 serde）
    let post: Post = reqwest::get("https://jsonplaceholder.typicode.com/posts/2")
        .await?
        .json()
        .await?;
    println!("{post:?}");
    Ok(())
}

use std::time::Duration;

#[tokio::main]
async fn main() -> reqwest::Result<()> {
    // 为什么要显式建 Client 而不是每次 reqwest::get？
    // Client 内部维护连接池（HTTP keep-alive），复用 TCP/TLS 连接，
    // 高频请求下性能差距巨大；还能统一配置超时、默认 header、代理。
    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(10))            // 总超时，防止请求永远挂起拖垮服务
        .connect_timeout(Duration::from_secs(3))     // 连接建立超时单独设置，更快失败
        .user_agent("my-app/1.0")                    // 很多 API 拒绝无 UA 的请求
        .build()?;

    // POST JSON
    let resp = client
        .post("https://jsonplaceholder.typicode.com/posts")
        .json(&NewPost { title: "t".into(), body: "b".into() }) // 自动序列化 + 设 Content-Type
        .send()
        .await?;
    println!("状态: {}", resp.status());

    // GET 带查询参数、自定义 header
    let resp = client
        .get("https://jsonplaceholder.typicode.com/posts")
        .query(&[("userId", "1")])                   // 自动做 URL 编码，别手拼字符串
        .header("Authorization", "Bearer token123")
        .send()
        .await?;

    // error_for_status：把 4xx/5xx 变成 Err，否则 reqwest 认为 HTTP 层成功就是成功
    let posts: Vec<serde_json::Value> = resp.error_for_status()?.json().await?;
    println!("拿到 {} 条", posts.len());
    Ok(())
}

use futures_util::StreamExt;
use tokio::io::AsyncWriteExt;

async fn download(client: &reqwest::Client, url: &str, path: &str) -> reqwest::Result<()> {
    let mut resp = client.get(url).send().await?.error_for_status()?;
    let mut file = tokio::fs::File::create(path).await.unwrap();

    // bytes_stream() 边下边写，内存占用恒定。如果把整个 body 读进内存，2GB 文件就占 2GB 内存
    while let Some(chunk) = resp.bytes_stream().next().await {
        file.write_all(&chunk?).await.unwrap();
    }
    Ok(())
}

async fn forms(client: &reqwest::Client) -> reqwest::Result<()> {
    // application/x-www-form-urlencoded 表单
    client.post("https://httpbin.org/post")
        .form(&[("username", "admin"), ("password", "123456")])
        .send().await?;

    // multipart 文件上传
    let part = reqwest::multipart::Part::bytes(std::fs::read("a.txt").unwrap())
        .file_name("a.txt");
    let form = reqwest::multipart::Form::new()
        .text("desc", "一个文件")
        .part("file", part);
    client.post("https://httpbin.org/post").multipart(form).send().await?;
    Ok(())
}

[dependencies]
axum = "0.8"
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"

use axum::{routing::{get, post}, Router, Json};
use serde::{Deserialize, Serialize};

#[derive(Serialize)]
struct Msg { message: String }

#[derive(Deserialize)]
struct CreateUser { name: String }

async fn hello() -> &'static str { "Hello, world" }       // 返回 &str 自动成为 text/plain
async fn hello_json() -> Json<Msg> {                       // 返回 Json<T> 自动序列化 + 设 Content-Type
    Json(Msg { message: "你好".into() })
}
async fn create_user(Json(payload): Json<CreateUser>) -> Json<Msg> {
    // Json<T> 既是提取器（请求）也是响应器：靠的是函数参数的「提取器模式」
    Json(Msg { message: format!("创建用户 {}", payload.name) })
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/", get(hello))
        .route("/json", get(hello_json))
        .route("/users", post(create_user));

    // 0.8 写法：TcpListener + serve
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    println!("监听 http://localhost:3000");
    axum::serve(listener, app).await.unwrap();
}

use axum::{
    extract::{Path, Query, State},
    http::{HeaderMap, StatusCode},
    Json, Router, routing::get,
};
use serde::{Deserialize, Serialize};
use std::{collections::HashMap, sync::{Arc, atomic::{AtomicU64, Ordering}}};

// 共享状态：Arc 包一层。原子计数器之外的可变数据用 Mutex/RwLock
#[derive(Clone)]
struct AppState {
    visit_count: Arc<AtomicU64>,
    app_name: String,
}

#[derive(Deserialize)]
struct PageQuery { page: Option<u32>, size: Option<u32> }

async fn get_user(Path(id): Path<u64>) -> String { format!("用户 {id}") }

async fn list_users(Query(q): Query<PageQuery>) -> String {
    format!("第 {} 页，每页 {} 条", q.page.unwrap_or(1), q.size.unwrap_or(20))
}

async fn visit(State(state): State<AppState>, headers: HeaderMap) -> String {
    let n = state.visit_count.fetch_add(1, Ordering::Relaxed) + 1;
    let ua = headers.get("user-agent")
        .and_then(|v| v.to_str().ok()).unwrap_or("unknown");
    format!("[{}] 第 {n} 次访问，UA: {ua}", state.app_name)
}

// 返回 (StatusCode, Json<T>) 自定义状态码；impl IntoResponse 可以返回任意可转响应的类型
async fn maybe_found(State(s): State<AppState>) -> Result<Json<serde_json::Value>, StatusCode> {
    if s.app_name.is_empty() {
        Err(StatusCode::NOT_FOUND) // 返回 Err(StatusCode) 直接成为对应状态码的空响应
    } else {
        Ok(Json(serde_json::json!({"ok": true})))
    }
}

#[tokio::main]
async fn main() {
    let state = AppState {
        visit_count: Arc::new(AtomicU64::new(0)),
        app_name: "demo".into(),
    };

    let app = Router::new()
        .route("/users/{id}", get(get_user))          // {id} 与 Path<u64> 对应，类型不符自动 400
        .route("/users", get(list_users))
        .route("/visit", get(visit))
        .route("/found", get(maybe_found))
        .with_state(state);                            // 注入状态，handler 用 State 提取

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

use axum::{
    http::StatusCode,
    response::{IntoResponse, Response},
    Json, Router, routing::get, middleware,
};
use serde_json::json;

// 应用错误类型：实现 IntoResponse 后，handler 直接返回 Result<T, AppError>
// 为什么？否则每个 handler 都要手写 try/match 转 HTTP 响应，业务代码被噪音淹没
enum AppError { NotFound(String), Internal(anyhow::Error) }

impl IntoResponse for AppError {
    fn into_response(self) -> Response {
        let (status, msg) = match self {
            AppError::NotFound(m) => (StatusCode::NOT_FOUND, m),
            AppError::Internal(e) => {
                eprintln!("内部错误: {e:#}"); // 详细错误只进服务端日志
                (StatusCode::INTERNAL_SERVER_ERROR, "服务器内部错误".into())
                // 为什么不把内部错误详情返回给客户端？——防止泄露路径、SQL 等敏感信息
            }
        };
        (status, Json(json!({ "error": msg }))).into_response()
    }
}

// From 转换让 ? 直接可用
impl From<anyhow::Error> for AppError {
    fn from(e: anyhow::Error) -> Self { AppError::Internal(e) }
}

async fn handler() -> Result<String, AppError> {
    Err(AppError::NotFound("东西不存在".into()))
}

// 简单中间件：函数式 middleware
async fn log_requests(req: axum::extract::Request, next: middleware::Next) -> Response {
    let start = std::time::Instant::now();
    let method = req.method().clone();
    let path = req.uri().path().to_string();
    let resp = next.run(req).await;          // 调用链路的下一层
    println!("{method} {path} -> {} ({:?})", resp.status(), start.elapsed());
    resp
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/", get(handler))
        .layer(middleware::from_fn(log_requests)) // 挂在整个 Router 上
        .fallback(|| async { (StatusCode::NOT_FOUND, "路由不存在") }); // 自定义 404

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

use axum::{Router, routing::get};

fn api_routes() -> Router {
    Router::new().route("/health", get(|| async { "ok" }))
}

fn app() -> Router {
    Router::new()
        .nest("/api/v1", api_routes())      // 嵌套：/api/v1/health
        // .nest_service("/static", tower_http::services::ServeDir::new("static")) // 静态文件需 tower-http
}

[dependencies]
clap = { version = "4", features = ["derive"] }

use clap::{Parser, Subcommand, ValueEnum};

#[derive(Parser)]
#[command(name = "mytool", version, about = "一个示例工具", long_about = None)]
struct Cli {
    /// 输入文件（doc comment 自动成为帮助文本！）
    #[arg(short, long)]
    input: String,

    /// 输出目录
    #[arg(short, long, default_value = "./out")]   // 不传时的默认值
    output: String,

    /// 详细日志，-v / -vv / -vvv 可叠加
    #[arg(short, long, action = clap::ArgAction::Count)]
    verbose: u8,

    /// 并发数，1-32
    #[arg(short, long, default_value_t = 4, value_parser = clap::value_parser!(u8).range(1..=32))]
    jobs: u8,

    /// 输出格式
    #[arg(long, value_enum, default_value_t = Format::Json)]
    format: Format,

    #[command(subcommand)]
    command: Commands,
}

#[derive(Clone, ValueEnum)]
enum Format { Json, Text, Csv }

#[derive(Subcommand)]
enum Commands {
    /// 处理文件
    Process {
        /// 是否强制覆盖
        #[arg(short, long)]
        force: bool,
    },
    /// 清理缓存（位置参数：直接写在命令后面，不需要 --）
    Clean {
        target: String,
    },
}

fn main() {
    let cli = Cli::parse(); // 解析失败（缺参数/类型错）自动打印错误和用法，退出码 2

    match cli.command {
        Commands::Process { force } => {
            println!("处理 {} -> {} (force={force}, jobs={}, format={:?})",
                     cli.input, cli.output, cli.jobs, cli.format);
        }
        Commands::Clean { target } => println!("清理 {target}"),
    }
}

$ mytool --help          # 自动生成的漂亮帮助
$ mytool -i a.txt process --force
$ mytool -i a.txt clean cache_dir

[dependencies]
log = "0.4"
env_logger = "0.11"

use log::{trace, debug, info, warn, error};

fn main() {
    // 只在应用的 main 里初始化一次；库代码里绝不要调用 init
    // 默认级别由环境变量 RUST_LOG 控制，无需改代码
    env_logger::init();

    error!("出错了");   // 默认只显示 warn 及以上
    warn!("警告");
    info!("普通信息");  // RUST_LOG=info 才显示
    debug!("调试细节"); // RUST_LOG=debug
    trace!("最啰嗦");   // RUST_LOG=trace
}

RUST_LOG=info cargo run                  # 全局 info 级
RUST_LOG=myapp=debug,reqwest=warn cargo run  # 按模块精细控制：自己代码 debug，第三方库只留 warn

[dependencies]
tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] }

use tracing::{info, warn, instrument, info_span};

// #[instrument] 自动给函数建 span，参数自动记录为字段
// 这个函数内的所有日志都会自动带上 request_id 和 user 字段——无需手动传递！
#[instrument(skip(db), fields(request_id = %uuid_v4()))]
async fn handle_request(user: &str, db: &Database) {
    info!("开始处理");
    step1().await;
    warn!(latency_ms = 120, "某步骤偏慢"); // 结构化字段：可以被日志系统检索、聚合
}

#[instrument]
async fn step1() {
    info!("步骤1"); // 自动带上父 span 的 request_id、user
}

struct Database;
fn uuid_v4() -> String { "req-abc123".into() }

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt()
        .with_env_filter( // 同样支持 RUST_LOG 环境变量过滤
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| "myapp=info".into()))
        // .json()      // 生产环境开 JSON 输出，对接 ELK/Loki 等日志系统
        .init();

    let db = Database;
    handle_request("alice", &db).await;
}

INFO handle_request{request_id="req-abc123" user="alice"}: 开始处理
INFO handle_request{request_id="req-abc123" user="alice"}:step1: 步骤1

[dependencies]
chrono = { version = "0.4", features = ["serde"] } # serde feature 让时间字段可直接序列化

use chrono::{Local, Utc, NaiveDate, DateTime, Duration, TimeZone, Datelike, Timelike};

fn main() {
    // 1) 获取当前时间
    let now_utc = Utc::now();       // DateTime<Utc>：服务器存时间永远用 UTC
    let now_local = Local::now();   // DateTime<Local>：只用于展示给用户
    println!("UTC:   {now_utc}");
    println!("本地:  {now_local}");

    // 2) 格式化与解析
    println!("{}", now_utc.format("%Y-%m-%d %H:%M:%S"));          // 自定义格式
    println!("{}", now_utc.to_rfc3339());                          // 2026-09-28T12:00:00+00:00，API 交换标准格式
    let dt = DateTime::parse_from_rfc3339("2026-09-28T12:00:00+08:00").unwrap();
    let utc_dt = dt.with_timezone(&Utc);                           // 时区转换是零成本的（内部都是时间戳）

    // 3) 从日期构造时间
    let d = NaiveDate::from_ymd_opt(2026, 2, 29)   // Opt 版本返回 Option，不 panic
        .expect("2026 不是闰年，这里会 panic");
    let dt2 = Utc.from_utc_datetime(&d.and_hms_opt(8, 30, 0).unwrap());

    // 4) 时间运算
    let tomorrow = Utc::now() + Duration::days(1);
    let deadline = Utc::now() + Duration::hours(3) + Duration::minutes(30);
    let diff = deadline - Utc::now();       // 减法得 Duration
    println!("还剩 {} 秒", diff.num_seconds());
    let _ = (d, dt2, tomorrow);

    // 5) 取字段
    println!("{}年{}月{}日 星期{:?}", now_local.year(), now_local.month(), now_local.day(), now_local.weekday());
}

use chrono::{DateTime, Utc, NaiveDate};
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Event {
    name: String,
    at: DateTime<Utc>,                       // 默认序列化为 RFC3339 字符串
    #[serde(with = "date_fmt")]              // 自定义格式时用 with + 模块
    day: NaiveDate,
}

mod date_fmt {
    use chrono::{NaiveDate, serde::ts_microseconds as _}; // 只是示意，下面手写
    use serde::{Deserialize, Deserializer, Serializer};

    const FMT: &str = "%Y/%m/%d";
    pub fn serialize<S: Serializer>(d: &NaiveDate, s: S) -> Result<S::Ok, S::Error> {
        s.serialize_str(&d.format(FMT).to_string())
    }
    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<NaiveDate, D::Error> {
        let s = String::deserialize(d)?;
        NaiveDate::parse_from_str(&s, FMT).map_err(serde::de::Error::custom)
    }
}

[dependencies]
rand = "0.9"

use rand::prelude::*;

fn main() {
    let mut rng = rand::rng();          // 线程局部、密码学安全的默认随机源

    // 1) 基本类型
    let x: u32 = rng.random();          // 任意实现了相应 trait 的类型
    let b: bool = rng.random();
    let f: f64 = rng.random();          // [0, 1) 均匀分布

    // 2) 范围随机
    let dice = rng.random_range(1..=6);         // 1-6 含 6
    let score = rng.random_range(0.0..100.0);   // 浮点也行

    // 3) 概率
    if rng.random_bool(0.3) { println!("30% 概率命中"); }

    // 4) 序列操作
    let mut cards = vec!["A", "K", "Q", "J"];
    cards.shuffle(&mut rng);                       // 洗牌
    let pick = cards.choose(&mut rng).unwrap();    // 随机选一个
    let picks: Vec<_> = cards.choose_multiple(&mut rng, 2).collect(); // 不重复选多个

    // 5) 随机字符串（验证码、临时文件名）
    let code: String = (0..6).map(|_| rng.random_range(0..10).to_string()).collect();
    let token: String = rand::distr::Alphanumeric
        .sample_string(&mut rng, 16);              // 字母数字混合 16 位

    println!("{x} {b} {f} {dice} {score} {pick} {picks:?} {code} {token}");

    // 6) 需要可复现（测试、仿真）时，用固定种子的生成器
    let mut seeded = rand::rngs::StdRng::seed_from_u64(42); // 同种子必然产生同序列
    let _v: u64 = seeded.random();
}

[dependencies]
regex = "1"

use regex::Regex;

fn main() {
    // 1) 匹配判断
    let re = Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap(); // r"..." 原始字符串，不用转义反斜杠
    assert!(re.is_match("2026-09-28"));
    assert!(!re.is_match("2026/09/28"));

    // 2) 查找
    let re = Regex::new(r"\d+").unwrap();
    let m = re.find("房间号是 1024 室").unwrap();
    println!("找到 '{}' 位于 {:?}", m.as_str(), m.range());

    // 3) 捕获组：提取结构化数据
    let re = Regex::new(r"(\w+)@(\w+\.\w+)").unwrap();
    let text = "联系我: alice@example.com";
    if let Some(caps) = re.captures(text) {
        println!("整体: {}", &caps[0]);   // caps[0] 永远是整个匹配
        println!("用户名: {}", &caps[1]);
        println!("域名: {}", &caps[2]);
    }

    // 命名捕获组：长正则里比数字序号更可读
    let re = Regex::new(r"(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})").unwrap();
    let caps = re.captures("2026-09-28").unwrap();
    println!("{}月{}日", &caps["month"], &caps["day"]);

    // 4) 迭代所有匹配
    for m in re.find_iter("2026-09-28 和 2025-01-01") {
        println!("{:?}", m.as_str());
    }

    // 5) 替换
    let re = Regex::new(r"\d+").unwrap();
    let masked = re.replace_all("电话 13812345678 备用 01012345", "***");
    println!("{masked}");
    // 用捕获组做模板替换：$name 引用命名组
    let re = Regex::new(r"(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})").unwrap();
    println!("{}", re.replace("2026-09-28", "$d/$m/$y")); // 28/09/2026

    // 6) 分割
    let re = Regex::new(r"[,，;；\s]+").unwrap();
    let parts: Vec<&str> = re.split("苹果, 香蕉，橘子；西瓜 桃子").collect();
    println!("{parts:?}");
}

use regex::Regex;
use std::sync::LazyLock;

// Regex::new 要做语法解析+编译自动机，成本不低。
// 如果在循环或 handler 里每次 new，是新手最常见的性能坑。
// 为什么用 LazyLock？标准库 1.80+ 内置，首次访问时才初始化，线程安全，
// 替代过去的 lazy_static / once_cell 第三方宏。
static EMAIL_RE: LazyLock<Regex> = LazyLock::new(|| {
    Regex::new(r"^[\w.+-]+@[\w-]+\.[\w.]+$").unwrap()
});

fn validate(email: &str) -> bool {
    EMAIL_RE.is_match(email) // 复用同一份编译结果
}

[dependencies]
itertools = "0.14"

use itertools::Itertools;

fn main() {
    let v = vec![3, 1, 4, 1, 5, 9, 2, 6];

    // 1) unique：去重（保留顺序）
    let uniq: Vec<_> = v.iter().unique().collect(); // [3, 1, 4, 5, 9, 2, 6]

    // 2) sorted / sorted_by：迭代器直接排序
    let sorted: Vec<_> = v.iter().sorted().collect();
    let desc: Vec<_> = v.iter().sorted_by(|a, b| b.cmp(a)).collect();

    // 3) chunk / chunks：分组
    let chunks: Vec<Vec<_>> = v.iter().chunks(3).into_iter().map(|c| c.collect()).collect();
    // [[3,1,4], [1,5,9], [2,6]]

    // 4) group_by：按 key 分组（类似 SQL GROUP BY）
    let words = vec!["apple", "avocado", "banana", "blueberry", "cherry"];
    let groups = words.iter().into_group_map_by(|w| w.chars().next().unwrap());
    // {'a': [apple, avocado], 'b': [banana, blueberry], 'c': [cherry]}

    // 5) join：迭代器直接拼字符串（比 collect 成 Vec 再 join 少一步）
    let s = words.iter().join(", "); // "apple, avocado, ..."

    // 6) tuple_windows：相邻窗口
    let diffs: Vec<i32> = v.iter().tuple_windows().map(|(a, b)| b - a).collect();

    // 7) cartesian_product：笛卡尔积
    let pairs: Vec<_> = (1..=2).cartesian_product('a'..='b').collect();
    // [(1,'a'), (1,'b'), (2,'a'), (2,'b')]

    // 8) minmax：一次遍历同时拿最小最大值
    let (min, max) = v.iter().minmax().into_option().unwrap();

    // 9) zip_eq：长度必须相等的 zip（不等会 panic，用于防御长度不匹配的静默截断 bug）
    let zipped: Vec<_> = [1, 2, 3].iter().zip_eq(['a', 'b', 'c'].iter()).collect();

    // 10) format! 风格快速打印
    println!("{:?} {:?} {:?} {:?} {:?} {:?} {:?}", uniq, sorted, desc, chunks, groups, diffs, pairs);
    println!("{s} | min={min} max={max} | {}", zipped.iter().map(|(a,_)| a).join("+"));
}

[dependencies]
rayon = "1"

use rayon::prelude::*;

fn is_prime(n: u64) -> bool {
    if n < 2 { return false; }
    (2..=((n as f64).sqrt() as u64)).all(|i| n % i != 0)
}

fn main() {
    let nums: Vec<u64> = (1_000_000..2_000_000).collect();

    // 串行版
    let count = nums.iter().filter(|&&n| is_prime(n)).count();

    // 并行版：iter -> par_iter，就这一个改动
    let count_par = nums.par_iter().filter(|&&n| is_prime(n)).count();
    assert_eq!(count, count_par);

    // 其他常见并行操作，API 与迭代器几乎一致
    let sum: u64 = nums.par_iter().sum();                    // 并行求和
    let squares: Vec<u64> = nums.par_iter().map(|n| n * n).collect(); // 并行 map 收集
    let max = nums.par_iter().max();
    nums.par_iter().for_each(|n| { /* 只执行不收集 */ let _ = n; });
    println!("{sum} {} {max:?}", squares.len());
}

fn heavy_a() -> u64 { 1 }
fn heavy_b() -> u64 { 2 }

let (a, b) = rayon::join(heavy_a, heavy_b); // 两个闭包可能并行执行
println!("{a} {b}");

[dependencies]
sqlx = { version = "0.8", features = ["runtime-tokio", "mysql", "chrono"] }
tokio = { version = "1", features = ["full"] }
chrono = "0.4"

use sqlx::MySqlPool;

#[derive(sqlx::FromRow, Debug)]       // FromRow：把查询结果行映射到结构体
struct User {
    id: i64,
    name: String,
    email: Option<String>,
}

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    // 连接池：为什么必须用池？建一次 TCP+认证握手要几十毫秒，
    // 每个请求新建连接数据库会被打爆。池复用连接，自动处理断线重连。
    let pool = MySqlPool::connect("mysql://user:pass@localhost/mydb").await?;

    // 建表（演示用，生产用 sqlx migrate 管理迁移）
    sqlx::query("CREATE TABLE IF NOT EXISTS user (id BIGINT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(50), email VARCHAR(100))")
        .execute(&pool).await?;

    // 1) 插入：? 占位符绑定参数，杜绝 SQL 注入
    // 为什么不拼接字符串？format!("...WHERE id = {id}") 在 id 来自用户输入时就是注入漏洞
    let r = sqlx::query("INSERT INTO user (name, email) VALUES (?, ?)")
        .bind("小明")
        .bind("xm@example.com")
        .execute(&pool).await?;
    println!("插入 id = {}", r.last_insert_id());

    // 2) 查询单条映射到结构体
    let user = sqlx::query_as::<_, User>("SELECT id, name, email FROM user WHERE id = ?")
        .bind(1i64)
        .fetch_one(&pool).await?;      // 没有行时返回 Err(RowNotFound)
    println!("{user:?}");

    // 3) 查询多条
    let users: Vec<User> = sqlx::query_as("SELECT id, name, email FROM user WHERE name LIKE ?")
        .bind("小%")
        .fetch_all(&pool).await?;
    println!("共 {} 人", users.len());

    // 4) fetch_optional：行可能不存在时
    let maybe: Option<User> = sqlx::query_as("SELECT id, name, email FROM user WHERE id = ?")
        .bind(999i64)
        .fetch_optional(&pool).await?;
    println!("{maybe:?}");

    // 5) 更新 / 删除：看受影响行数
    let r = sqlx::query("UPDATE user SET email = ? WHERE id = ?")
        .bind("new@example.com").bind(1i64)
        .execute(&pool).await?;
    println!("更新 {} 行", r.rows_affected());

    // 6) 事务：要么全成，要么全回滚。转账类操作的底线
    let mut tx = pool.begin().await?;
    sqlx::query("UPDATE account SET balance = balance - 100 WHERE id = 1")
        .execute(&mut *tx).await?;
    sqlx::query("UPDATE account SET balance = balance + 100 WHERE id = 2")
        .execute(&mut *tx).await?;
    tx.commit().await?;   // 若中途 panic 或提前返回，tx 被 drop 自动回滚
    Ok(())
}

// 需要编译时能连到数据库（DATABASE_URL 环境变量或 .sqlx 离线数据）
// let user = sqlx::query_as!(User, "SELECT id, name, email FROM user WHERE id = ?", 1i64)
//     .fetch_one(&pool).await?;
// 表不存在、列名打错、类型不匹配 → 编译报错，不是运行时 500

dotenvy = "0.15"

// 开发时把配置写在项目根目录 .env 文件里（DATABASE_URL=mysql://...）
// main 开头一行加载，之后 std::env::var 就能读到
dotenvy::dotenv().ok();
// 为什么用 .ok() 忽略错误？生产环境没有 .env 文件（配置走真实环境变量），不应 panic

uuid = { version = "1", features = ["v4", "serde"] }

let id = uuid::Uuid::new_v4();            // 随机 UUID，做请求 ID、资源 ID
println!("{id}");                          // 550e8400-e29b-41d4-a716-446655440000

use std::sync::LazyLock;
// 1.80+ 标准库内置，别再引 lazy_static / once_cell 了
static CONFIG: LazyLock<String> = LazyLock::new(|| {
    std::env::var("APP_CONFIG").unwrap_or_else(|_| "default".into())
});

base64 = "0.22"
hex = "0.4"

use base64::{Engine as _, engine::general_purpose::STANDARD};
let b64 = STANDARD.encode("你好");         // 字节 -> base64 字符串
let raw = STANDARD.decode(&b64).unwrap(); // 还原
let h = hex::encode(b"abc");              // "616263"

walkdir = "2"

use walkdir::WalkDir;
// 递归遍历，自动处理符号链接和排序
for entry in WalkDir::new("./src").into_iter().filter_map(|e| e.ok()) {
    if entry.path().extension().is_some_and(|e| e == "rs") {
        println!("{}", entry.path().display());
    }
}

tempfile = "3"

let mut f = tempfile::NamedTempFile::new().unwrap();
use std::io::Write;
writeln!(f, "test").unwrap();
// 为什么用库而不是自己拼 /tmp/xxx？自动防重名、权限正确、离开作用域自动删除，测试不残留垃圾

csv = "1"