book

Learning Go

Name: Learning Go
Author: Jon Bodner
ISBN: 9781492077213

by Jon Bodner

March 2021

Beginner

375 pages

8h 59m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Preface
Who Should Read This BookConventions Used in This BookUsing Code ExamplesO’Reilly Online LearningHow to Contact UsAcknowledgments
1. Setting Up Your Go Environment
Installing the Go ToolsThe Go WorkspaceThe go Commandgo run and go buildGetting Third-Party Go ToolsFormatting Your CodeLinting and VettingChoose Your ToolsVisual Studio CodeGoLandThe Go PlaygroundMakefilesStaying Up to DateWrapping Up
2. Primitive Types and Declarations
Built-in TypesThe Zero ValueLiteralsBooleansNumeric TypesA Taste of Strings and RunesExplicit Type Conversionvar Versus :=Using constTyped and Untyped ConstantsUnused VariablesNaming Variables and ConstantsWrapping Up
3. Composite Types
Arrays—Too Rigid to Use DirectlySliceslenappendCapacitymakeDeclaring Your SliceSlicing SlicesConverting Arrays to SlicescopyStrings and Runes and BytesMapsReading and Writing a MapThe comma ok IdiomDeleting from MapsUsing Maps as SetsStructsAnonymous StructsComparing and Converting StructsWrapping Up
4. Blocks, Shadows, and Control Structures
BlocksShadowing VariablesDetecting Shadowed 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, gotoWrapping 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 ValueWrapping 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 WorkloadWrapping 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 nilThe 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)Wrapping Up
8. Errors
How to Handle Errors: The BasicsUse Strings for Simple ErrorsSentinel ErrorsErrors Are ValuesWrapping ErrorsIs and AsWrapping Errors with deferpanic and recoverGetting a Stack Trace from an ErrorWrapping Up
9. Modules, Packages, and Imports
Repositories, Modules, and Packagesgo.modBuilding PackagesImports and ExportsCreating and Accessing a PackageNaming PackagesHow to Organize Your ModuleOverriding a Package’s NamePackage Comments and godocThe internal PackageThe init Function: Avoid if PossibleCircular DependenciesGracefully Renaming and Reorganizing Your APIWorking with ModulesImporting Third-Party CodeWorking with VersionsMinimal Version SelectionUpdating to Compatible VersionsUpdating to Incompatible VersionsVendoringpkg.go.devAdditional InformationPublishing Your ModuleVersioning Your ModuleModule Proxy ServersSpecifying a Proxy ServerPrivate RepositoriesWrapping Up

10. Concurrency in Go
When to Use ConcurrencyGoroutinesChannelsReading, Writing, and Bufferingfor-range and ChannelsClosing a ChannelHow Channels BehaveselectConcurrency Practices and PatternsKeep Your APIs Concurrency-FreeGoroutines, for Loops, and Varying VariablesAlways Clean Up Your GoroutinesThe Done Channel PatternUsing a Cancel Function to Terminate a GoroutineWhen to Use Buffered and Unbuffered ChannelsBackpressureTurning Off a case in a selectHow to Time Out CodeUsing WaitGroupsRunning Code Exactly OncePutting Our Concurrent Tools TogetherWhen to Use Mutexes Instead of ChannelsAtomics—You Probably Don’t Need TheseWhere to Learn More About ConcurrencyWrapping Up
11. The Standard Library
io and FriendstimeMonotonic TimeTimers and Timeoutsencoding/jsonUse Struct Tags to Add MetadataUnmarshaling and MarshalingJSON, Readers, and WritersEncoding and Decoding JSON StreamsCustom JSON Parsingnet/httpThe ClientThe ServerWrapping Up
12. The Context
What Is the Context?CancellationTimersHandling Context Cancellation in Your Own CodeValuesWrapping Up
13. Writing Tests
The Basics of TestingReporting Test FailuresSetting Up and Tearing DownStoring Sample Test DataCaching Test ResultsTesting Your Public APIUse go-cmp to Compare Test ResultsTable TestsChecking Your Code CoverageBenchmarksStubs in GohttptestIntegration Tests and Build TagsFinding Concurrency Problems with the Race CheckerWrapping Up
14. Here There Be Dragons: Reflect, Unsafe, and Cgo
Reflection Lets Us Work with Types at RuntimeTypes, Kinds, and ValuesMaking 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 MethodsOnly Use Reflection If It’s Worthwhileunsafe Is UnsafeUse unsafe to Convert External Binary Dataunsafe Strings and Slicesunsafe ToolsCgo Is for Integration, Not PerformanceWrapping Up
15. Welcome to the Future: Generics in Go
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 StructuresThings That Are Left OutIdiomatic Go and GenericsFurther Futures UnlockedWrapping Up
Index
About the Author

Content preview from Learning Go

Chapter 9. Modules, Packages, and Imports

Most modern programming languages have a system for organizing code into namespaces and libraries, and Go is no exception. As we’ve seen while exploring other features, Go introduces some new approaches to this old idea. In this chapter, we’ll learn about organizing 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 the root of a Go library or application, stored in a repository. Modules consist of one or more packages, which give the module organization and structure.

Note

While you can store more than one module in a repository, it isn’t encouraged. Everything within a module is versioned together. Maintaining two modules in one repository means tracking separate versions for two different projects in a single repository.

Before we can use code from packages outside of the standard library, we need to make sure that we have declared that our project is a module. Every module has a globally unique identifier. This is not unique to Go. Java uses globally unique package declarations like com.companyname.projectname.library.

In Go, we usually use the path to the module repository where ...

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

Publisher Resources

ISBN: 9781492077206Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design