通过例子学rust 中文版 (rust team)（Z-Library）

【One-Line Pitch】 A hands-on, example-driven tour of Rust's core concepts—from syntax and types to ownership, traits, and error handling—perfect for programmers who learn best by reading and running code rather than wading through theory. 【Book Arc】 - **Opening (~0%–10%)**: Starts with "Hello World" and quickly moves into primitives (integers, floats, chars, bools), custom types (structs, enums), and variable bindings. The focus is on getting you comfortable with Rust's syntax and type system through small, runnable snippets. - **Early (~10%–25%)**: Covers type casting, expressions, and control flow (if/else, loops, match). Introduces pattern matching and destructuring, plus the basics of functions and closures, including how closures capture variables. - **Early–Middle (~25%–40%)**: Dives into modules, crates, and Cargo—Rust's package manager. Explains visibility rules, file hierarchy, and conditional compilation with `cfg`. Begins generics, showing how to write functions and types that work with multiple data types. - **Middle (~40%–55%)**: Focuses on ownership, borrowing, and lifetimes—the heart of Rust's memory safety. Covers RAII, the `Drop` trait, mutable vs. immutable references, and how lifetimes ensure references stay valid. Includes the `'static` lifetime and its uses. - **Late (~55%–70%)**: Explores traits in depth, including derivation (`#[derive]`), operator overloading, and the `Drop` trait. Shows how to implement custom behavior for types and how traits enable polymorphism. - **Ending (~70%–100%)**: Covers macros, error handling (`Result`, `panic`), standard library types (collections, strings, files), threading, and testing. Wraps up with unsafe operations and compatibility notes, plus tips on documentation and benchmarking. 【Key Takeaways】 - **Primitives and type inference are your foundation** (Opening): Rust's scalar types (i8–i128, u8–u128, f32, f64, char, bool) and compound types (arrays, tuples) come with sensible defaults—integers default to `i32`, floats to `f64`. Understanding these basics makes later concepts easier. - **`fmt::Debug` vs `fmt::Display` is a key formatting choice** (Opening): `Debug` can be auto-derived with `#[derive(Debug)]` and is great for quick printing with `{:?}`, while `Display` requires manual implementation for custom types. Use `{:#?}` for pretty-printed debug output. - **Expressions, not just statements, drive Rust logic** (Early): Code blocks are expressions; the last expression without a semicolon becomes the block's value. This enables concise patterns like `let y = { let x = 5; x + 1 };` and returning values from loops via `break value`. - **Pattern matching with `if let` and `match` is powerful** (Early): Destructuring tuples, enums, pointers, and structs lets you extract values cleanly. `if let` is especially useful for matching enum variants without requiring `PartialEq`—a common gotcha. - **Ownership and borrowing are Rust's safety core** (Middle): The borrow checker ensures references are valid by tracking lifetimes. Mutable references (`&mut T`) allow read/write, while immutable references (`&T`) allow read-only. Lifetimes, though often implicit, are crucial for preventing dangling references. - **`Drop` and RAII manage resources deterministically** (Middle): The `Drop` trait defines cleanup when a value goes out of scope, eliminating memory leaks without garbage collection. Types like `Box`, `Vec`, and `String` rely on this for automatic resource release. - **Traits enable polymorphism and code reuse** (Late): `#[derive]` auto-implements common traits like `Debug`, `Clone`, and `PartialEq`. For custom behavior, implement traits manually—e.g., `Add` for operator overloading or `Drop` for custom cleanup logic. - **Cargo and modules keep projects organized** (Early–Middle): Modules control visibility (private by default, `pub` to expose), and files map to module hierarchies. Cargo handles dependencies, testing, and benchmarking, making it essential for real-world Rust development. 【Reading Tips】 - **Skim the "Hello World" and primitive sections** if you're already familiar with systems programming; they're straightforward. Focus instead on the "动手试一试" (Try It) exercises—they reinforce syntax through practice. - **Deep-read the ownership, borrowing, and lifetimes chapters** (Middle). These are the hardest concepts for newcomers and the most critical for writing safe Rust. Run the examples and experiment with the commented-out error cases to see compiler diagnostics in action. - **Pay attention to the `?` operator and `try!` macro** in the formatting and error-handling sections. They simplify `Result` handling significantly and appear throughout idiomatic Rust code. - **Use the "参见" (See Also) links** to jump between related topics—e.g., from traits to generics or from lifetimes to methods. This helps connect concepts that build on each other. - **Don't skip the exercises at the end of each section**—they're not optional. They often ask you to extend the examples (e.g., implementing `Display` for a `Matrix` or writing a `transpose` function), which is where the learning sticks. 【Coverage Limits】 The excerpts cover roughly the first half to two-thirds of the book (through traits and `Drop`). Later sections on macros, error handling, standard library types, threading, and testing are mentioned in the table of contents but not detailed in the provided material.