book

Learning Go, 2nd Edition

Name: Learning Go, 2nd Edition
Author: Jon Bodner
ISBN: 9781098139292

by Jon Bodner

January 2024

Beginner

494 pages

12h 30m

English

O'Reilly Media, Inc.

Audio summary available

Read now

Unlock full access

Includes

Quizzes

Sandbox

Preface
Who Should Read This BookConventions Used in This BookUsing Code ExamplesO’Reilly Online LearningHow to Contact UsAcknowledgments for the 2nd EditionAcknowledgments for the 1st Edition
1. Setting Up Your Go Environment
Installing the Go ToolsTroubleshooting Your Go InstallationGo ToolingYour First Go ProgramMaking a Go Modulego buildgo fmtgo vetChoose Your ToolsVisual Studio CodeGoLandThe Go PlaygroundMakefilesThe Go Compatibility PromiseStaying Up-to-DateExercisesWrapping Up
2. Predeclared Types and Declarations
The Predeclared TypesThe Zero ValueLiteralsBooleansNumeric TypesA Taste of Strings and RunesExplicit Type ConversionLiterals Are Untypedvar Versus :=Using constTyped and Untyped ConstantsUnused VariablesNaming Variables and ConstantsExercisesWrapping Up
3. Composite Types
Arrays—Too Rigid to Use DirectlySliceslenappendCapacitymakeEmptying a SliceDeclaring Your SliceSlicing SlicescopyConverting Arrays to SlicesConverting Slices to ArraysStrings and Runes and BytesMapsReading and Writing a MapThe comma ok IdiomDeleting from MapsEmptying a MapComparing MapsUsing Maps as SetsStructsAnonymous StructsComparing and Converting StructsExercisesWrapping Up
4. Blocks, Shadows, and Control Structures
BlocksShadowing Variablesif for, Four WaysThe Complete for StatementThe Condition-Only for StatementThe Infinite for Statementbreak and continueThe for-range StatementLabeling Your for StatementsChoosing the Right for StatementswitchBlank SwitchesChoosing Between if and switchgoto—Yes, gotoExercisesWrapping Up
5. Functions
Declaring and Calling FunctionsSimulating Named and Optional ParametersVariadic Input Parameters and SlicesMultiple Return ValuesMultiple Return Values Are Multiple ValuesIgnoring Returned ValuesNamed Return ValuesBlank Returns—Never Use These!Functions Are ValuesFunction Type DeclarationsAnonymous FunctionsClosuresPassing Functions as ParametersReturning Functions from FunctionsdeferGo Is Call by ValueExercisesWrapping Up
6. Pointers
A Quick Pointer PrimerDon’t Fear the PointersPointers Indicate Mutable ParametersPointers Are a Last ResortPointer Passing PerformanceThe Zero Value Versus No ValueThe Difference Between Maps and SlicesSlices as BuffersReducing the Garbage Collector’s WorkloadTuning the Garbage CollectorExercisesWrapping Up
7. Types, Methods, and Interfaces
Types in GoMethodsPointer Receivers and Value ReceiversCode Your Methods for nil InstancesMethods Are Functions TooFunctions Versus MethodsType Declarations Aren’t InheritanceTypes Are Executable Documentationiota Is for Enumerations—SometimesUse Embedding for CompositionEmbedding Is Not InheritanceA Quick Lesson on InterfacesInterfaces Are Type-Safe Duck TypingEmbedding and InterfacesAccept Interfaces, Return StructsInterfaces and nilInterfaces Are ComparableThe Empty Interface Says NothingType Assertions and Type SwitchesUse Type Assertions and Type Switches SparinglyFunction Types Are a Bridge to InterfacesImplicit Interfaces Make Dependency Injection EasierWireGo Isn’t Particularly Object-Oriented (and That’s Great)ExercisesWrapping Up
8. Generics
Generics Reduce Repetitive Code and Increase Type SafetyIntroducing Generics in GoGeneric Functions Abstract AlgorithmsGenerics and InterfacesUse Type Terms to Specify OperatorsType Inference and GenericsType Elements Limit ConstantsCombining Generic Functions with Generic Data StructuresMore on comparableThings That Are Left OutIdiomatic Go and GenericsAdding Generics to the Standard LibraryFuture Features UnlockedExercisesWrapping Up
9. Errors
How to Handle Errors: The BasicsUse Strings for Simple ErrorsSentinel ErrorsErrors Are ValuesWrapping ErrorsWrapping Multiple ErrorsIs and AsWrapping Errors with deferpanic and recoverGetting a Stack Trace from an ErrorExercisesWrapping Up

10. Modules, Packages, and Imports
Repositories, Modules, and PackagesUsing go.modUse the go Directive to Manage Go Build VersionsThe require DirectiveBuilding PackagesImporting and ExportingCreating and Accessing a PackageNaming PackagesOverriding a Package’s NameDocumenting Your Code with Go Doc CommentsUsing the internal PackageAvoiding Circular DependenciesOrganizing Your ModuleGracefully Renaming and Reorganizing Your APIAvoiding the init Function if PossibleWorking with ModulesImporting Third-Party CodeWorking with VersionsMinimal Version SelectionUpdating to Compatible VersionsUpdating to Incompatible VersionsVendoringUsing pkg.go.devPublishing Your ModuleVersioning Your ModuleOverriding DependenciesRetracting a Version of Your ModuleUsing Workspaces to Modify Modules SimultaneouslyModule Proxy ServersSpecifying a Proxy ServerUsing Private RepositoriesAdditional DetailsExercisesWrapping Up
11. Go Tooling
Using go run to Try Out Small ProgramsAdding Third-Party Tools with go installImproving Import Formatting with goimportsUsing Code-Quality Scannersstaticcheckrevivegolangci-lintUsing govulncheck to Scan for Vulnerable DependenciesEmbedding Content into Your ProgramEmbedding Hidden FilesUsing go generateWorking with go generate and MakefilesReading the Build Info Inside a Go BinaryBuilding Go Binaries for Other PlatformsUsing Build TagsTesting Versions of GoUsing go help to Learn More About Go ToolingExercisesWrapping Up
12. Concurrency in Go
When to Use ConcurrencyGoroutinesChannelsReading, Writing, and BufferingUsing for-range and ChannelsClosing a ChannelUnderstanding How Channels BehaveselectConcurrency Practices and PatternsKeep Your APIs Concurrency-FreeGoroutines, for Loops, and Varying VariablesAlways Clean Up Your GoroutinesUse the Context to Terminate GoroutinesKnow When to Use Buffered and Unbuffered ChannelsImplement BackpressureTurn Off a case in a selectTime Out CodeUse WaitGroupsRun Code Exactly OncePut Your Concurrent Tools TogetherWhen to Use Mutexes Instead of ChannelsAtomics—You Probably Don’t Need TheseWhere to Learn More About ConcurrencyExercisesWrapping Up
13. The Standard Library
io and FriendstimeMonotonic TimeTimers and Timeoutsencoding/jsonUsing Struct Tags to Add MetadataUnmarshaling and MarshalingJSON, Readers, and WritersEncoding and Decoding JSON StreamsCustom JSON Parsingnet/httpThe ClientThe ServerResponseControllerStructured LoggingExercisesWrapping Up
14. The Context
What Is the Context?ValuesCancellationContexts with DeadlinesContext Cancellation in Your Own CodeExercisesWrapping Up
15. Writing Tests
Understanding the Basics of TestingReporting Test FailuresSetting Up and Tearing DownTesting with Environment VariablesStoring Sample Test DataCaching Test ResultsTesting Your Public APIUsing go-cmp to Compare Test ResultsRunning Table TestsRunning Tests ConcurrentlyChecking Your Code CoverageFuzzingUsing BenchmarksUsing Stubs in GoUsing httptestUsing Integration Tests and Build TagsFinding Concurrency Problems with the Data Race DetectorExercisesWrapping Up
16. Here Be Dragons: Reflect, Unsafe, and Cgo
Reflection Lets You Work with Types at RuntimeTypes, Kinds, and ValuesMake New ValuesUse Reflection to Check If an Interface’s Value Is nilUse Reflection to Write a Data MarshalerBuild Functions with Reflection to Automate Repetitive TasksYou Can Build Structs with Reflection, but Don’tReflection Can’t Make MethodsUse Reflection Only if It’s Worthwhileunsafe Is UnsafeUsing Sizeof and OffsetofUsing unsafe to Convert External Binary DataAccessing Unexported FieldsUsing unsafe ToolsCgo Is for Integration, Not PerformanceExercisesWrapping Up
Index
About the Author

Content preview from Learning Go, 2nd Edition

Chapter 10. Modules, Packages, and Imports

Most modern programming languages have a system for organizing code into namespaces and libraries, and Go is no exception. As you’ve seen while exploring other features, Go introduces some new approaches to this old idea. In this chapter, you’ll learn how to organize code with packages and modules, how to import them, how to work with third-party libraries, and how to create libraries of your own.

Repositories, Modules, and Packages

Library management in Go is based around three concepts: repositories, modules, and packages. A repository is familiar to all developers. It is a place in a version control system where the source code for a project is stored. A module is a bundle of Go source code that’s distributed and versioned as a single unit. Modules are stored in a repository. Modules consist of one or more packages, which are directories of source code. Packages give a module organization and structure.

Note

While you can store more than one module in a repository, it is discouraged. Everything within a module is versioned together. Maintaining two modules in one repository requires you to track separate versions for two different modules in a single repository.

Unfortunately, different programming languages use these words to represent different concepts. While packages in Java and Go are similar, a Java repository is a centralized place to store multiple artifacts (the analogue of a Go module). Node.js and Go swap the meanings ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Designing Data-Intensive Applications, 2nd Edition

Publisher Resources

ISBN: 9781098139285Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design