Learning Go

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

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

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

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

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

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

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

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

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

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

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

14. The Context
What Is the Context?
Values
Cancellation
Contexts with Deadlines
Context Cancellation in Your Own Code
Exercises
Wrapping Up

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

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