深入浅出Go语言核心编程 (张朝明)（Z-Library）

【One-Line Pitch】 A chapter-by-chapter tour of Go's core mechanics—from syntax and data structures to concurrency, reflection, generics, and network programming—written for developers who already know another language and want to switch to Go without getting lost in its quirks. 【Book Arc】 - **Opening (~0%–7%)**: Environment setup, GOROOT/GOPATH, the mandatory `main.main()` entry point, and how Go handles startup arguments differently from Java—getting a first program running and understanding why Go's conventions are strict. - **Early (~7%–29%)**: Language fundamentals: variables, type inference, `iota` pitfalls, booleans, arrays vs. slices (including capacity growth and underlying-array rebuilds), maps and their bucket structure, custom structs, and control flow with `for-range` and `switch-case`. - **Middle (~29%–57%)**: Functions (multiple return values and their runtime rationale), exception handling via `defer`/`panic`/`recover`, Go's take on OOP through embedding and interfaces, the GPM concurrency model, channel-based synchronization, `sync.Once`, and Context for parent-child goroutine coordination. - **Late (~57%–71%)**: Advanced features: reflection for runtime type and value manipulation, generics for code reuse and their interaction with interfaces, I/O operations with `bufio.Scanner`, and the start of network programming covering TCP and UDP. - **Ending (~71%–100%)**: HTTP internals and `Transport`, common network errors (CLOSE_WAIT, TIME_WAIT, connection reset), RPC and gRPC, memory management and garbage collection, regular expressions, Go assembly basics, the Gin framework, and a full MVC project. 【Key Takeaways】 - **Go's entry point is rigid by design** (Opening): only `main.main()` works, and command-line arguments come through `os.Args` rather than function parameters—a deliberate departure from Java-style conventions that signals Go's preference for simplicity over flexibility. - **`iota` is convenient but dangerous** (Early): inserting a new constant mid-block silently shifts all subsequent values, which can corrupt persisted enum data; the author recommends using it only for continuous, stable sequences like days of the week. - **Slices are value types wrapping a pointer to an array** (Early): passing a slice to a function copies the slice header, and `append` may trigger a full underlying-array rebuild when capacity is exceeded—understanding this prevents subtle aliasing bugs. - **Go's OOP is composition, not inheritance** (Middle): embedding gives you method promotion and even a form of multiple inheritance, but ambiguous method names cause compile errors rather than silent resolution—Go chooses safety over cleverness. - **The GPM model makes thread pools largely unnecessary** (Middle): `GOMAXPROCS` controls the number of logical processors, and goroutines are multiplexed onto OS threads by the runtime; channels can replace locks for synchronization, and `sync.Once` handles one-time initialization cleanly. - **Context is for coordination, not just data passing** (Middle): `cancelCtx` and `WithTimeout` let parent goroutines signal children to stop, which is essential for building responsive concurrent services. - **Reflection can read private fields but not write them** (Late): `FieldByName` accesses unexported fields, but `SetString`/`SetInt` on them panics—Go enforces encapsulation even at runtime. - **Generics solve code duplication without abandoning type safety** (Late): the `sum()` example shows why `interface{}` abstraction fails for mixed numeric and string operations, and generics fill that gap while remaining backward-compatible with interfaces. 【Reading Tips】 - **Skim the environment setup chapter** if you already have Go installed; the real value starts at variables and data structures. - **Deep-read the concurrency chapters (9–10)** —the GPM model, channel synchronization, and Context are where Go differs most from other languages and where the author spends the most explanatory effort. - **Treat the network programming chapters (14–15) as a reference** rather than a linear read; the CLOSE_WAIT/TIME_WAIT simulations are practical debugging material worth revisiting when you hit real issues. - **Don't skip the assembly chapter (18)** if you want to understand Go's runtime deeply, but it's safe to defer until you're comfortable with the higher-level material. - **Use the final MVC project (chapter 20) as a checkpoint**—if you can follow it end-to-end, you've absorbed the book's core content. 【Coverage Limits】 The excerpts cover chapters 1–20 at varying depth, with the strongest material on concurrency, reflection, generics, and networking. Some chapters (e.g., regex, assembly, Gin) are represented only by brief summaries, so this guide reflects the book's overall arc rather than every detail.