精通Rust（第2版） ( etc.)（Z-Library）

【One-Line Pitch】 A comprehensive, project-driven guide to Rust that takes you from language basics through systems programming, concurrency, web services, and FFI — ideal for developers with some C, C++, or Python experience who want to master Rust's safety and performance in real-world applications. 【Book Arc】 - **Opening (~0%–10%)**: Introduces Rust's design philosophy (memory safety without GC, zero-cost abstractions, concurrency safety) and walks through installation via rustup, primitive types, variables, functions, closures, strings, control flow, match expressions, custom types, modules, and collections — ending with a character counter project. - **Early (~10%–25%)**: Covers project management with Cargo (dependencies, workspaces, clippy), testing (unit/integration, documentation, benchmarks), and dives into the type system — generics, traits, trait bounds, and trait objects for polymorphism. - **Early–Middle (~25%–40%)**: Explains memory management fundamentals — stack vs. heap, ownership, borrowing, lifetimes, and smart pointers — followed by error handling with Option/Result, combinators, the `?` operator, and custom error types. - **Middle (~40%–60%)**: Explores advanced concepts: deeper type system features (type inference, aliases, never type), String vs. &str, iterators, advanced traits (Sized, Borrow, From/Into), closures (Fn/FnMut/FnOnce), pattern matching guards, and serialization with serde. - **Late (~60%–85%)**: Moves to applied topics — concurrency (threads, Arc/Mutex, message passing, Send/Sync, actor model), macros and metaprogramming (macro_rules!, procedural macros), unsafe Rust and FFI (calling C, Python via PyO3, Node.js), logging frameworks, and network programming (sync/async Redis server). - **Ending (~85%–100%)**: Builds full applications: HTTP services with hyper and actix-web, database integration with diesel (SQLite/PostgreSQL), WebAssembly (markdown editor), GTK+ desktop apps, and debugging with GDB in VS Code. 【Key Takeaways】 - **Rust's core promise is compile-time memory safety without a garbage collector** (Early): ownership, borrowing, and lifetimes let the compiler catch use-after-free and data races before runtime — the foundation for everything else in the book. - **Zero-cost abstractions mean high-level code compiles to efficient machine code** (Early): the book's Kotlin-vs-Rust iterator comparison shows how Rust's lazy iterators avoid heap allocations that JVM streams incur, matching hand-written loop performance. - **Cargo is more than a build tool — it's your project lifecycle manager** (Early): from dependencies and workspaces to testing, documentation generation, and clippy linting, mastering Cargo early makes all later chapters smoother. - **The type system is your design partner, not just a compiler check** (Early–Middle): generics, traits, and trait objects enable polymorphism and code reuse; understanding trait bounds and object safety is key to writing flexible, idiomatic libraries. - **Error handling is explicit and composable** (Middle): Option/Result types, combinators like map and and_then, and the `?` operator turn error propagation into readable, safe code — a deliberate contrast to exceptions in other languages. - **Concurrency safety is enforced by the type system via Send and Sync** (Late): the book shows how Arc<Mutex<T>> and message-passing patterns let you build data-race-free concurrent programs, with the actor model as a higher-level alternative. - **Macros enable real metaprogramming for code generation** (Late): from macro_rules! for DSLs (like a HashMap initializer) to procedural and derive macros, you can reduce boilerplate and extend the language itself. - **Rust integrates with the wider ecosystem through FFI and WebAssembly** (Ending): practical examples show calling C code, building Python extensions with PyO3, Node.js native modules, and compiling to WebAssembly for browser apps. 【Reading Tips】 - **Skim Chapter 1 if you know another language** — the basics (variables, functions, match) are familiar; focus instead on the "Rust philosophy" sections about memory safety and zero-cost abstractions, which frame the whole book. - **Deep-read Chapters 4–5 (types, memory)** — these are the conceptual core; the ownership/borrowing rules and trait system are where most beginners struggle, and the examples here repay careful study. - **Treat the projects as the real curriculum** — the logic gate simulator, Redis server, URL shortener, and bookmark API are where concepts click; type the code yourself and experiment with breaking it to learn from compiler errors. - **Watch for the "deliberately broken" code files** — the book includes non-compiling examples so you can practice fixing them; use the compiler's error messages as a learning tool rather than a frustration. - **Skip or skim Chapter 17 (GDB) if you're not doing systems debugging yet** — it's useful but peripheral; you can return to it when you need to debug complex memory or concurrency issues. 【Coverage Limits】 This guide synthesizes the book's table of contents, preface, and early chapter excerpts (roughly the first 40% of the book). Detailed content from later chapters (concurrency, macros, FFI, web, databases, WebAssembly, GTK+, GDB) is summarized from the TOC and preface rather than from full text.