Rust入门秘笈 (Rust)（Z-Library）

【One-Line Pitch】 A practical, example-driven introduction to Rust for beginners who want to learn the language's core concepts—ownership, borrowing, structs, enums, and error handling—without getting lost in theory. Ideal for programmers coming from C/C++ or other systems languages who want a hands-on, code-first entry point. 【Book Arc】 - **Opening (~0%–6%)**: Introduces Rust's origins, philosophy (memory safety without garbage collection), and installation via `rustup`. Walks through the first "Hello, world!" program, compilation with `rustc`, and basic control flow (`if`, `if-else`, nested conditions), establishing the syntax and toolchain fundamentals. - **Early (~6%–18%)**: Covers loops (`loop`, `for`, `while`) and then dives into Rust's signature feature—ownership. Explains the rules (single owner, move semantics, scope-based destruction), the `Copy` trait for stack-only types, and introduces references and borrowing, including the key restriction of one mutable reference at a time. - **Early (~18%–29%)**: Continues with slices (string slices, range syntax) and moves into user-defined types: structs (definition, instantiation, field access, update syntax) and methods via `impl` blocks, emphasizing the `self` parameter and method-call syntax. - **Middle (~29%–41%)**: Introduces enums and the `match` operator, including `Option<T>` and the `if let` shorthand. Then shifts to modules: file organization (`mod` declarations, `src/lib.rs`), visibility rules with `pub`, and the `use` and `super` keywords for path management. - **Middle (~41%–59%)**: Focuses on collections—vectors (creation, indexing with `[]` vs. `get()`, mutation, updating, deletion, storing mixed types via enums) and strings (creation, updating with `push_str` and `format!`, and why strings can't be indexed due to UTF-8 encoding). - **Late (~59%–end)**: Covers error handling: the distinction between recoverable (`Result<T, E>`) and unrecoverable (`panic!`) errors, plus macros like `assert!` and `unreachable!`. Discusses unwinding vs. aborting on panic and how to configure `panic = 'abort'`. 【Key Takeaways】 - **Ownership is Rust's core safety mechanism** (Early): Every value has a single owner; when the owner goes out of scope, the value is dropped. This eliminates garbage collection and manual memory management, preventing double-free and use-after-free bugs. - **Move semantics and the `Copy` trait** (Early): Assignment transfers ownership for heap types (like `String`), making the old variable unusable. Stack-only types (integers, booleans, floats, chars) implement `Copy`, so they remain valid after assignment—knowing which types are `Copy` prevents compile errors. - **Borrowing allows multiple references without violating single ownership** (Early): References (`&T`) let functions access data without taking ownership. The key rule: you can have either many immutable references or one mutable reference (`&mut T`) in a scope, never both—this prevents data races at compile time. - **Slices provide safe, zero-copy access to collections** (Early): A slice (`&str[0..10]`) references a contiguous portion of data without owning it. Range syntax (`..`, `..=`) is inclusive/exclusive as specified, and string literals are themselves slices stored in the binary. - **Structs and enums are the building blocks of custom types** (Early–Middle): Structs group related fields with named types; enums define a type with a fixed set of variants. The `match` operator exhaustively handles all variants, and `if let` offers a concise alternative for single-pattern matches. - **Modules organize code and control visibility** (Middle): Files map to modules (`mod` declarations, `src/lib.rs`), with `pub` controlling external access. The `use` keyword shortens paths, and `super` accesses parent modules—essential for structuring larger projects. - **Vectors and strings have distinct access patterns** (Middle): Vectors support indexing with `[]` (panics on out-of-bounds) or `get()` (returns `Option<&T>` for safe handling). Strings are UTF-8 encoded and cannot be indexed by byte position; use `push_str`, `format!`, or slicing with care. - **Error handling is explicit, not exception-based** (Late): Recoverable errors use `Result<T, E>` with `Ok`/`Err` variants; unrecoverable errors trigger `panic!`. Macros like `assert!` and `unreachable!` enforce invariants, and you can choose between stack unwinding and aborting via `panic = 'abort'`. 【Reading Tips】 - **Skim the installation and toolchain sections** (Opening): If you already have Rust installed via `rustup`, jump straight to the "Hello, world!" example and the control-flow sections—these are quick wins for syntax familiarity. - **Deep-read the ownership and borrowing chapters** (Early): These are the hardest and most important concepts. Work through the code examples line by line, especially the move/copy distinction and the mutable-reference restriction. Recreate the examples yourself to internalize the rules. - **Use the struct, enum, and module sections as reference material** (Early–Middle): The patterns here (struct update syntax, `impl` methods, `match` with enums, module file organization) are foundational for real Rust projects. Skim the theory, but type out the examples to see how they compile and run. - **Pay attention to the vector and string gotchas** (Middle): The `[]` vs. `get()` difference and the UTF-8 indexing error are common beginner pitfalls. Note the error messages shown—they're typical of what you'll encounter and worth recognizing. - **Treat the error-handling section as a mindset shift** (Late): Rust's explicit error handling differs from exceptions in other languages. Focus on the `Result` type and `panic!` behavior, and note the `unreachable!` macro as a debugging aid—this will prepare you for writing robust production code. 【Coverage Limits】 This guide covers the book's progression from syntax basics through ownership, types, modules, collections, and error handling. The excerpts do not cover advanced topics like traits, generics (beyond `Option<T>`), lifetimes, concurrency, or C interop in depth—those are mentioned but not elaborated in the sampled material.