Go Cookbook (Aaron Torres)（Z-Library）

# Go Cookbook: A Practical Guide to Advanced Go Programming ## 【One-Line Pitch】 A hands-on recipe collection that bridges the gap between Go basics and advanced production techniques, perfect for developers who know the syntax but want to master real-world patterns in I/O, error handling, concurrency, and web services. ## 【Book Arc】 - **Opening (~0%–13%)**: Foundations of I/O and file systems, covering the common I/O interfaces, bytes buffers, CSV parsing, and template engines—establishing the "recipe" format of problem → solution → explanation. - **Early (~13%–23%)**: Command-line tool building with flags, environment variables, and configuration management across JSON, TOML, and YAML formats, plus Unix pipe handling. - **Early (~23%–32%)**: Data conversion and composition techniques—type assertions, interface handling, string/number conversions, and null-value encoding patterns for JSON. - **Middle (~32%–48%)**: Error handling deep-dive covering error creation patterns, wrapping/annotating errors, logging strategies, panic recovery, and structured logging with context. - **Middle (~48%–65%)**: Database and storage integration using database/sql with MySQL, connection pooling, rate limiting, and transaction management. - **Late (~65%–100%)**: Web services, middleware, reverse proxies, gRPC-to-JSON export, testing strategies (mocking, table-driven tests, fuzzing), and advanced topics like parallelism, distributed systems, performance tuning, reactive and serverless programming. ## 【Key Takeaways】 - **I/O interfaces are the universal currency of Go data handling** (Opening): bytes.Buffer satisfies io.Reader, enabling seamless integration with ioutil functions; choose buffers for streaming, slices for small datasets. - **Templates scale from CSV to full HTML rendering** (Early): Go's text/template and HTML/template packages support nesting, function imports, and iteration—start simple, grow into website rendering. - **Configuration formats are interchangeable with struct tags** (Early): JSON works out of the box; TOML and YAML via third-party libraries; struct tags provide hints that make multi-format support trivial. - **Error wrapping preserves context without losing the original** (Middle): Annotate errors as they propagate through layers; this pattern becomes critical in larger applications for debugging. - **Panic recovery requires deliberate design** (Middle): Use defer/recover patterns to catch panics at boundaries, but never as a substitute for proper error handling. - **Database/sql abstracts away driver differences** (Middle): The blank import pattern (`_ "github.com/go-sql-driver/mysql"`) connects drivers; connection pooling and transactions work uniformly across MySQL, Postgres, SQLite. - **Testing is a first-class citizen, not an afterthought** (Late): Table-driven tests improve coverage systematically; mocking via standard library or Mockgen enables isolated unit tests; fuzzing catches edge cases. ## 【Reading Tips】 - **Skim the "Getting ready" sections** if you're comfortable with Go module setup—they repeat environment configuration across chapters. - **Deep-read the "How it works" sections**—they contain the conceptual gold, explaining why patterns matter beyond just showing code. - **Focus on Chapter 4 (Error Handling)** as a cornerstone—it's referenced from earlier chapters and underpins robust application design. - **Treat each recipe as a template**—the code is meant to be adapted, not copied; the book's GitHub repo has complete, runnable examples. - **Skip around by project need**—this is a cookbook, not a novel; jump to the chapter matching your current problem. ## 【Coverage Limits】 This guide covers the opening through middle sections in detail (I/O, CLI tools, data conversion, error handling, databases). The later chapters on web services, testing, concurrency, and serverless programming are only briefly outlined based on the table of contents and early excerpts. ##