book

Go Programming - From Beginner to Professional - Second Edition

Name: Go Programming - From Beginner to Professional - Second Edition
Author: Samantha Coyle
ISBN: 9781803243054

by Samantha Coyle

March 2024

Beginner to intermediate

680 pages

14h 40m

English

Packt Publishing

Read now

Unlock full access

Go Programming - From Beginner to Professional
ContributorsAbout the authorAbout the reviewers
Preface
Who this book is forWhat this book coversTo get the most out of this bookInstall the Go CompilerInstall GitInstall Visual Studio Code (Editor/IDE)Install DockerInstall PostgreSQLDownload the example code filesConventions usedGet in touchShare Your ThoughtsDownload a free PDF copy of this book
Part 1: Scripts
Chapter 1: Variables and Operators
Technical requirementsIntroduction to GoWhat does Go look like?Exercise 1.01 – using variables, packages, and functions to print starsActivity 1.01 – defining and printingDeclaring variablesDeclaring a variable using varExercise 1.02 – declaring a variable using varDeclaring multiple variables at once with varExercise 1.03 – declaring multiple variables at once with varSkipping the type or value when declaring variablesExercise 1.04 – skipping the type or value when declaring variablesType inference gone wrongShort variable declarationExercise 1.05 – implementing a short variable declarationDeclaring multiple variables with a short variable declarationExercise 1.06 – declaring multiple variables from a functionUsing var to declare multiple variables in one lineNon-English variable namesChanging the value of a variableExercise 1.07 – changing the value of a variableChanging multiple values at onceExercise 1.08 – changing multiple values at onceOperatorsExercise 1.09 – using operators with numbersShorthand operatorsExercise 1.10 – implementing shorthand operatorsComparing valuesExercise 1.11 – comparing valuesZero valuesExercise 1.12 – zero valuesValue versus pointerGetting a pointerExercise 1.13 – getting a pointerGetting a value from a pointerExercise 1.14 – getting a value from a pointerFunction design with pointersExercise 1.15 – function design with pointersActivity 1.02 – pointer value swapConstantsExercise 1.16 – constantsEnumsActivity 1.03 – message bugActivity 1.04 – bad count bugSummary
Chapter 2: Command and Control
Technical requirementsIntroductionif statementsExercise 2.01 – a simple if statementif else statementsExercise 2.02 – using an if else statementelse if statementsExercise 2.03 – using an else if statementinitial if statementsExercise 2.04 – implementing initial if statementsExpression switch statementsExercise 2.05 – using a switch statementExercise 2.06 – switch statements and multiple case valuesExercise 2.07 – expressionless switch statementsLoopsExercise 2.08 – using a for i loopExercise 2.09 – looping over arrays and slicesrange loopExercise 2.10 – looping over a mapActivity 2.01 – looping over map data using rangeActivity 2.02 – implementing FizzBuzzbreak and continueExercise 2.11 – using break and continue to control loopsActivity 2.03 – bubble sortgoto statementsExercise 2.12 – using goto statementsSummary
Chapter 3: Core Types
Technical requirementsIntroductionTrue and falseExercise 3.01 – Program to measure password complexityNumbersIntegersFloating-point numbersExercise 3.02 – Floating-point number accuracyOverflow and wraparoundExercise 3.03 – Triggering number wraparoundBig numbersExercise 3.04 – Big numbersbyteTextRuneExercise 3.05 – Safely looping over a stringThe nil valueActivity 3.01 – Sales tax calculatorActivity 3.02 – Loan calculatorSummary
Chapter 4: Complex Types
Technical requirementsIntroductionCollection typesArraysExercise 4.01 – Defining an arrayComparing arraysExercise 4.02 – Comparing arraysInitializing arrays using keysExercise 4.03 – Initializing an array using keysReading from an arrayExercise 4.04 – Reading a single item from an arrayWriting to an arrayExercise 4.05 – Writing to an arrayLooping over an arrayExercise 4.06 – Looping over an array using a “for i” loopModifying the contents of an array in a loopExercise 4.07 – Modifying the contents of an array in a loopActivity 4.01 – Filling an arraySlicesExercise 4.08 – Working with slicesAppending multiple items to a sliceExercise 4.09 – Appending multiple items to a sliceCreating slices from slices and arraysExercise 4.10 – Creating slices from a sliceUnderstanding slice internalsExercise 4.11 – Using make to control the capacity of a sliceBackground behavior of slicesExercise 4.12 – Controlling internal slice behaviorMap fundamentalsExercise 4.13 – Creating, reading, and writing a mapReading from mapsExercise 4.14 – Reading from a mapActivity 4.02 – Printing a user’s name based on user inputActivity 4.03 – Slicing the weekDeleting elements from a mapExercise 4.15 – Deleting an element from a mapActivity 4.04 – Removing an element from a sliceSimple custom typesExercise 4.16 – Creating a simple custom typeStructsExercise 4.17 – Creating struct types and valuesComparing structs to each otherExercise 4.18 – Comparing structs to each otherStruct composition using embeddingExercise 4.19 – Struct embedding and initializationActivity 4.05 – Creating a locale checkerType conversionsExercise 4.20 – Numeric type conversionsType assertions and interface{}Exercise 4.21 – Type assertionsType switchExercise 4.22 – Type switchActivity 4.06 – Type checkerSummary
Part 2: Components
Chapter 5: Functions – Reduce, Reuse, and Recycle
Technical requirementsIntroductionFunctionsParts of a functionThe checkNumbers functionExercise 5.01 – creating a function to print salesperson expectation ratings from the number of items soldParametersThe difference between an argument and a parameterExercise 5.02 – mapping index values to column headersFunction variable scopeReturn valuesExercise 5.03 – creating a checkNumbers function with return valuesActivity 5.01 – calculating the working hours of employeesNaked returnsExercise 5.04 – mapping a CSV index to a column header with return valuesVariadic functionsExercise 5.05 – summing numbersAnonymous functionsExercise 5.06 – creating an anonymous function to calculate the square root of a numberClosuresExercise 5.07 – creating a closure function to decrement a counterFunction typesExercise 5.08 – creating various functions to calculate salarydeferActivity 5.02 – calculating the payable amount for employees based on working hoursSeparating similar codeSummary
Chapter 6: Don’t Panic! Handle Your Errors
Technical requirementsIntroductionWhat are errors?Syntax errorsRuntime errorsExercise 6.01 – runtime errors while adding numbersSemantic errorsExercise 6.02 – a semantic error with walking distanceError handling using other programming languagesError interface typeCreating error valuesExercise 6.03 – creating an application to calculate pay for the weekPanicExercise 6.04 – Crashing the program on errors using a panicRecoverExercise 6.05 – recovering from a panicGuidelines when working with errors and panicsError wrappingActivity 6.01 – creating a custom error message for a banking applicationActivity 6.02 – validating a bank customer’s direct deposit submissionActivity 6.03 – panic on invalid data submissionActivity 6.04 – preventing a panic from crashing the appSummary

Chapter 7: Interfaces
Technical requirementsIntroductionInterfaceDefining an interfaceImplementing an interfaceAdvantages of implementing interfaces implicitlyExercise 7.01 – implementing an interfaceDuck typingPolymorphismEmpty interfaceType assertion and switchesExercise 7.03 – analyzing empty interface{} dataActivity 7.01 – calculating pay and performance reviewanySummary
Chapter 8: Generic Algorithm Superpowers
Technical requirementsIntroductionWhen to use generics?Type parametersActivity 8.01 – a minimum valueType constraintsExercise 8.01 – calculate the maximum value using interfacesExercise 8.02 – calculate the largest stock of items on a ranchType inferenceWhen to use generics versus interfacesWhat are some best practices?Summary
Part 3: Modules
Chapter 9: Using Go Modules to Define a Project
Technical requirementsIntroductionWhat is a module?Key components when working with Go modulesThe go.mod fileThe go.sum fileHow are modules helpful?Precise and simplified dependency managementVersioning and reproducibilityImproved collaborationDependency safetyEase of use while promoting isolation and modularityExercise 09.01 – creating and using your first moduleWhen should you use external modules, and why?Exercise 09.02 – using an external module within our moduleConsuming multiple modules within a projectActivity 9.01 – consuming multiple modulesDefining multiple modules within a projectGo workspacesExercise 09.03 – working with workspacesSummary
Chapter 10: Packages Keep Projects Manageable
Technical requirementsIntroductionMaintainableReusableModularWhat is a package?Package structurePackage namingPackage declarationsExported and unexported codePackage aliasMain packageExercise 10.01 – Creating a package to calculate areas of various shapesThe init() functionExercise 10.02 – Loading budget categoriesExecuting multiple init() functionsExercise 10.03 – Assigning payees to budget categoriesActivity 10.01 – Creating a function to calculate payroll and performance reviewSummary
Chapter 11: Bug-Busting Debugging Skills
Technical requirementsIntroductionMethods for bug-free codeCoding incrementally and testing oftenWriting unit testsHandling all errorsPerforming loggingFormatting using fmtExercise 11.01 – Working with fmt.PrintlnFormatting using fmt.Printf()Additional options for formattingExercise 11.02 – Printing decimal, binary, and hex valuesBasic debuggingPrinting Go variable typesExercise 11.03 – Printing the Go representation of a variableLoggingLogging fatal errorsActivity 11.01 – Building a program to validate Social Security NumbersDebugging in live or restricted environmentsSummary
Chapter 12: About Time
Technical requirementsIntroductionMaking timeExercise 12.01 – Creating a function to return a timestampComparing timeDuration calculationManaging timeExercise 12.02 – Duration of executionFormatting timeExercise 12.03 – What is the time in your zone?Activity 12.01 – Formatting a date according to user requirementsActivity 12.02 – Enforcing a specific format of date and timeActivity 12.03 – Measuring elapsed timeActivity 12.04 – Calculating the future date and timeActivity 12.05 – Printing the local time in different time zonesSummary
Part 4: Applications
Chapter 13: Programming from the Command Line
Technical requirementsIntroductionReading argumentsExercise 13.01 – saying hello using a name passed as an argumentUsing flags to control behaviorExercise 13.02 – using flags to say hello conditionallyStreaming large amounts of data in and out of your applicationExercise 13.03 – using pipes, stdin, and stdout to apply a Rot13 encoding to a fileExit codes and command line best practicesKnowing when to stop by watching for interruptsStarting other commands from your applicationExercise 13.04 – creating a stopwatch with a time limitTerminal UIsExercise 13.05 – creating a wrapper for our Rot13 pipelinego installSummary
Chapter 14: File and Systems
Technical requirementsIntroductionFilesystemFile permissionsFlags and argumentsSignalsExercise 14.01 – simulating a cleanupCreate and write to filesReading the whole file at onceExercise 14.02 – backing up filesCSVEmbeddingSummary
Chapter 15: SQL and Databases
Technical requirementsIntroductionUnderstanding the databaseInstalling and configuring Postgres SQLDatabase API and driversConnecting to databasesCreating a new projectCreating tablesInserting dataExercise 15.01 – creating a table that holds a series of numbersRetrieving dataUpdating existing dataDeleting dataExercise 15.02 – holding prime numbers in a databaseTruncating and deleting tableActivity 15.01 – holding user data in a tableActivity 15.02 – finding the messages of specific usersAdding users with GORMFinding Users with GORMSummary
Part 5: Building For The Web
Chapter 16: Web Servers
Technical requirementsIntroductionHow to build a basic serverHTTP handlerExercise 16.01 – creating a Hello World serverSimple routingExercise 16.02 – routing our serverHandler versus handler functionActivity 16.01 – adding a page counter to an HTML pageAdding middlewareDynamic contentExercise 16.03 – personalized welcomeTemplatingExercise 16.04 – templating our pagesStatic resourcesExercise 16.05 – creating a Hello World server using a static fileGetting some styleExercise 16.06 – a stylish welcomeGetting dynamicActivity 16.02 – external templateEmbedding external filesSummary
Chapter 17: Using the Go HTTP Client
Technical requirementsIntroductionThe Go HTTP Client and its usesSending a request to a serverExercise 17.01 – sending a GET request to a web server using the Go HTTP ClientStructured dataExercise 17.02 – using the HTTP Client with structured dataActivity 17.01 – requesting data from a web server and processing the responseSending data to a serverExercise 17.03 – sending a POST request to a web server using the Go HTTP ClientUploading files in a POST requestExercise 17.04 – uploading a file to a web server via a POST requestCustom request headersExercise 17.05 – using custom headers and options with the Go HTTP ClientActivity 17.02 – sending data to a web server and checking whether the data was received using POST and GETSummary
Part 6: Professional
Chapter 18: Concurrent Work
Technical requirementsIntroductionGoroutinesExercise 18.01 – using concurrent GoroutinesWaitGroupExercise 18.02 – experimenting with WaitGroupRace conditionsAtomic operationsExercise 18.03 – an atomic changeInvisible concurrencyChannelsExercise 18.04 – exchanging greeting messages via channelsExercise 18.05 – two-way message exchange with channelsExercise 18.06 – summing numbers from everywhereExercise 18.07 – request to GoroutinesThe importance of concurrencyExercise 18.08 – equally splitting work between GoroutinesConcurrency patternsBuffersExercise 18.09 – notifying when the computation has finishedSome more common practicesHTTP serversMethods as GoroutinesExercise 18.10 – a structured workGo context packageExercise 18.11 – managing Goroutines with a contextConcurrent work with sync.CondExercise 18.12 – creating a WIP limited queueThe thread-safe mapExercise 18.13 – counting how many times random numbers are between 0 and 9 using sync.MapSummary
Chapter 19: Testing
Technical requirementsIntroductionUnit testsExercise 19.01 – table-driven testsIntegration testsExercise 19.02 – integration test with a databaseE2E testsHTTP testingExercise 19.03 – authentication integration with a test serverFuzz testingBenchmarksTest suitesExercise 19.04 – using TestMain to execute several test functionsTest reportCode coverageSummary
Chapter 20: Using Go Tools
Technical requirementsIntroductionThe go build toolExercise 20.01 – using the go build toolThe go run toolExercise 20.02 – using the go run toolThe gofmt toolExercise 20.03 – using the gofmt toolThe goimports toolExercise 20.04 – using the goimports toolThe go vet toolExercise 20.05 – using the go vet toolThe Go race detectorExercise 20.06 – using the Go race detectorThe go doc toolExercise 20.07 – implementing the go doc toolThe go get toolExercise 20.08 – implementing the go get toolActivity 20.01 – using gofmt, goimport, go vet, and go get to correct a fileSummary
Chapter 21: Go in the Cloud
Technical requirementsIntroductionMaking your app monitorable by systems such as PrometheusExercise 21.01 – Creating an app with a /healthz endpointEnabling deep insights through OpenTelemetryExercise 21.02 – Using OpenTelemetry for queryable logs and tracingBest practices for putting your Go application in a containerExercise 21.03 – Creating a Dockerfile for a Go applicationMaking your app ready to work with orchestrators such as KubernetesSummary
Index
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youShare Your ThoughtsDownload a free PDF copy of this book

Content preview from Go Programming - From Beginner to Professional - Second Edition

13 Programming from the Command Line

Overview

In this chapter, we will look at programming from the command line. We will see how Go is an excellent choice for creating powerful command-line utilities and applications, as well as discuss the many tools available for working with the command line using Go.

By reading this chapter, you will acquaint yourself with developing powerful command-line utilities and applications in Go. We will start with the basics of reading in command-line arguments and employing those flag values to control application behavior, take a peek at dealing with larger amounts of data inside and outside the application, and evaluate exit codes and best practices along the way. Then, we will dive a bit deeper and discuss ...

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: 9781803243054

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Go Programming - From Beginner to Professional - Second Edition

by Samantha Coyle

13

Programming from the Command Line

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.