Learning Go: An Idiomatic Approach to Real-world Go Programming, 2nd Edition

Copyright
Table of Contents
Preface
Who Should Read This Book
Conventions Used in This Book
Using Code Examples
O’Reilly Online Learning
How to Contact Us
Acknowledgments for the 2nd Edition
Acknowledgments for the 1st Edition
Chapter 1. Setting Up Your Go Environment
Installing the Go Tools
Troubleshooting Your Go Installation
Go Tooling
Your First Go Program
Making a Go Module
go build
go fmt
go vet
Choose Your Tools
Visual Studio Code
GoLand
The Go Playground
Makefiles
The Go Compatibility Promise
Staying Up-to-Date
Exercises
Wrapping Up
Chapter 2. Predeclared Types and Declarations
The Predeclared Types
The Zero Value
Literals
Booleans
Numeric Types
A Taste of Strings and Runes
Explicit Type Conversion
Literals Are Untyped
var Versus :=
Using const
Typed and Untyped Constants
Unused Variables
Naming Variables and Constants
Exercises
Wrapping Up
Chapter 3. Composite Types
Arrays—Too Rigid to Use Directly
Slices
len
append
Capacity
make
Emptying a Slice
Declaring Your Slice
Slicing Slices
copy
Converting Arrays to Slices
Converting Slices to Arrays
Strings and Runes and Bytes
Maps
Reading and Writing a Map
The comma ok Idiom
Deleting from Maps
Emptying a Map
Comparing Maps
Using Maps as Sets
Structs
Anonymous Structs
Comparing and Converting Structs
Exercises
Wrapping Up
Chapter 4. Blocks, Shadows, and Control Structures
Blocks
Shadowing Variables
if   
for, Four Ways
The Complete for Statement
The Condition-Only for Statement
The Infinite for Statement
break and continue
The for-range Statement
Labeling Your for Statements
Choosing the Right for Statement
switch
Blank Switches
Choosing Between if and switch
goto—Yes, goto
Exercises
Wrapping Up
Chapter 5. Functions
Declaring and Calling Functions
Simulating Named and Optional Parameters
Variadic Input Parameters and Slices
Multiple Return Values
Multiple Return Values Are Multiple Values
Ignoring Returned Values
Named Return Values
Blank Returns—Never Use These!
Functions Are Values
Function Type Declarations
Anonymous Functions
Closures
Passing Functions as Parameters
Returning Functions from Functions
defer
Go Is Call by Value
Exercises
Wrapping Up
Chapter 6. Pointers
A Quick Pointer Primer
Don’t Fear the Pointers
Pointers Indicate Mutable Parameters
Pointers Are a Last Resort
Pointer Passing Performance
The Zero Value Versus No Value
The Difference Between Maps and Slices
Slices as Buffers
Reducing the Garbage Collector’s Workload
Tuning the Garbage Collector
Exercises
Wrapping Up
Chapter 7. Types, Methods, and Interfaces
Types in Go
Methods
Pointer Receivers and Value Receivers
Code Your Methods for nil Instances
Methods Are Functions Too
Functions Versus Methods
Type Declarations Aren’t Inheritance
Types Are Executable Documentation
iota Is for Enumerations—Sometimes
Use Embedding for Composition
Embedding Is Not Inheritance
A Quick Lesson on Interfaces
Interfaces Are Type-Safe Duck Typing
Embedding and Interfaces
Accept Interfaces, Return Structs
Interfaces and nil
Interfaces Are Comparable
The Empty Interface Says Nothing
Type Assertions and Type Switches
Use Type Assertions and Type Switches Sparingly
Function Types Are a Bridge to Interfaces
Implicit Interfaces Make Dependency Injection Easier
Wire
Go Isn’t Particularly Object-Oriented (and That’s Great)
Exercises
Wrapping Up
Chapter 8. Generics
Generics Reduce Repetitive Code and Increase Type Safety
Introducing Generics in Go
Generic Functions Abstract Algorithms
Generics and Interfaces
Use Type Terms to Specify Operators
Type Inference and Generics
Type Elements Limit Constants
Combining Generic Functions with Generic Data Structures
More on comparable
Things That Are Left Out
Idiomatic Go and Generics
Adding Generics to the Standard Library
Future Features Unlocked
Exercises
Wrapping Up
Chapter 9. Errors
How to Handle Errors: The Basics
Use Strings for Simple Errors
Sentinel Errors
Errors Are Values
Wrapping Errors
Wrapping Multiple Errors
Is and As
Wrapping Errors with defer
panic and recover
Getting a Stack Trace from an Error
Exercises
Wrapping Up
Chapter 10. Modules, Packages, and Imports
Repositories, Modules, and Packages
Using go.mod
Use the go Directive to Manage Go Build Versions
The require Directive
Building Packages
Importing and Exporting
Creating and Accessing a Package
Naming Packages
Overriding a Package’s Name
Documenting Your Code with Go Doc Comments
Using the internal Package
Avoiding Circular Dependencies
Organizing Your Module
Gracefully Renaming and Reorganizing Your API
Avoiding the init Function if Possible
Working with Modules
Importing Third-Party Code
Working with Versions
Minimal Version Selection
Updating to Compatible Versions
Updating to Incompatible Versions
Vendoring
Using pkg.go.dev
Publishing Your Module
Versioning Your Module
Overriding Dependencies
Retracting a Version of Your Module
Using Workspaces to Modify Modules Simultaneously
Module Proxy Servers
Specifying a Proxy Server
Using Private Repositories
Additional Details
Exercises
Wrapping Up
Chapter 11. Go Tooling
Using go run to Try Out Small Programs
Adding Third-Party Tools with go install
Improving Import Formatting with goimports
Using Code-Quality Scanners
staticcheck
revive
golangci-lint
Using govulncheck to Scan for Vulnerable Dependencies
Embedding Content into Your Program
Embedding Hidden Files
Using go generate
Working with go generate and Makefiles
Reading the Build Info Inside a Go Binary
Building Go Binaries for Other Platforms
Using Build Tags
Testing Versions of Go
Using go help to Learn More About Go Tooling
Exercises
Wrapping Up
Chapter 12. Concurrency in Go
When to Use Concurrency
Goroutines
Channels
Reading, Writing, and Buffering
Using for-range and Channels
Closing a Channel
Understanding How Channels Behave
select
Concurrency Practices and Patterns
Keep Your APIs Concurrency-Free
Goroutines, for Loops, and Varying Variables
Always Clean Up Your Goroutines
Use the Context to Terminate Goroutines
Know When to Use Buffered and Unbuffered Channels
Implement Backpressure
Turn Off a case in a select
Time Out Code
Use WaitGroups
Run Code Exactly Once
Put Your Concurrent Tools Together
When to Use Mutexes Instead of Channels
Atomics—You Probably Don’t Need These
Where to Learn More About Concurrency
Exercises
Wrapping Up
Chapter 13. The Standard Library
io and Friends
time
Monotonic Time
Timers and Timeouts
encoding/json
Using Struct Tags to Add Metadata
Unmarshaling and Marshaling
JSON, Readers, and Writers
Encoding and Decoding JSON Streams
Custom JSON Parsing
net/http
The Client
The Server
ResponseController
Structured Logging
Exercises
Wrapping Up
Chapter 14. The Context
What Is the Context?
Values
Cancellation
Contexts with Deadlines
Context Cancellation in Your Own Code
Exercises
Wrapping Up
Chapter 15. Writing Tests
Understanding the Basics of Testing
Reporting Test Failures
Setting Up and Tearing Down
Testing with Environment Variables
Storing Sample Test Data
Caching Test Results
Testing Your Public API
Using go-cmp to Compare Test Results
Running Table Tests
Running Tests Concurrently
Checking Your Code Coverage
Fuzzing
Using Benchmarks
Using Stubs in Go
Using httptest
Using Integration Tests and Build Tags
Finding Concurrency Problems with the Data Race Detector
Exercises
Wrapping Up
Chapter 16. Here Be Dragons: Reflect, Unsafe, and Cgo
Reflection Lets You Work with Types at Runtime
Types, Kinds, and Values
Make New Values
Use Reflection to Check If an Interface’s Value Is nil
Use Reflection to Write a Data Marshaler
Build Functions with Reflection to Automate Repetitive Tasks
You Can Build Structs with Reflection, but Don’t
Reflection Can’t Make Methods
Use Reflection Only if It’s Worthwhile
unsafe Is Unsafe
Using Sizeof and Offsetof
Using unsafe to Convert External Binary Data
Accessing Unexported Fields
Using unsafe Tools
Cgo Is for Integration, Not Performance
Exercises
Wrapping Up
Index
About the Author
Colophon