book

The Go Workshop

Name: The Go Workshop
ISBN: 9781838647940

by Delio D'Anna, Andrew Hayes, Sam Hennessy, Jeremy Leasor, Gobin Sougrakpam, Dániel Szabó, Philipp Mieden, David Parker, Gwenn Etourneau, Arpit Aggarwal, Eugene Wang

December 2019

Beginner

824 pages

14h 36m

English

Packt Publishing

Read now

Unlock full access

Preface
About the BookAbout the ChaptersConventionsBefore You BeginHardware and Software Recommendations for Windows with DockerHardware and Software Recommendations for Windows without DockerHardware and Software Recommendations for macOS with DockerHardware and Software Recommendations for macOS without DockerHardware and Software Recommendations for LinuxInstall the Go CompilerInstall GitInstall Visual Studio Code (Editor/IDE)Create a Test ApplicationInstall DockerInstalling the Code Bundle
1. Variables and Operators
IntroductionWhat Does Go Look Like?Exercise 1.01: Using Variables, Packages, and Functions to Print Stars Activity 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 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 Line Non-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 OperatorExercise 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: ConstantsEnumsScopeActivity 1.03: Message BugActivity 1.04: Bad Count BugSummary
2. Logic and Loops
Introductionif StatementsExercise 2.01: A Simple if Statementif else StatementsExercise 2.02: Using an if else Statementelse if StatementsExercise 2.03: Using an else if StatementThe Initial if StatementExercise 2.04: Implementing the Initial if StatementsActivity 2.01: Implementing FizzBuzzExpression switch Statements Exercise 2.05: Using a switch StatementExercise 2.06: switch Statements and Multiple case ValuesExercise 2.07: Expressionless switch Statements LoopsExercise 2.08: Using the for i LoopExercise 2.09: Looping Over Arrays and SlicesThe range LoopExercise 2.10: Looping Over a MapActivity 2.02: Looping Over Map Data Using rangebreak and continueExercise 2.11: Using break and continue to Control LoopsActivity 2.03: Bubble SortSummary
3. Core Types
IntroductionTrue and FalseExercise 3.01: Program to Measure Password ComplexityNumbersIntegerFloating PointExercise 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
4. Complex Types
IntroductionCollection 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 an Array Exercise 4.06: Looping Over an Array Using a "for i" Loop Modifying the Contents of an Array in a LoopExercise 4.07: Modifying the Contents of an Array in a LoopActivity 4.01: Filling an ArraySliceExercise 4.08: Working with SlicesActivity 4.02: Printing a User's Name Based on User InputAppending Multiple Items to a SliceExercise 4.09: Appending Multiple Items to a SliceActivity 4.03: Creating a Locale CheckerCreating 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 Behavior Map FundamentalsExercise 4.13: Creating, Reading, and Writing a Map Reading from MapsExercise 4.14: Reading from a MapActivity 4.04: Slicing the WeekDeleting Elements from a MapExercise 4.15: Deleting an Element from a MapActivity 4.05: 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 Initialization Type ConversionsExercise 4.20: Numeric Type ConversionType Assertions and interface{}Exercise 4.21: Type AssertionType SwitchExercise 4.22: Type SwitchActivity 4.06: Type CheckerSummary
5. Functions
IntroductionFunctionsParts of a functionfizzBuzzExercise 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 fizzBuzz 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 FunctionExercise 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 Payable Amount for Employees Based on Working HoursSummary
6. Errors
IntroductionWhat Are Errors?Syntax ErrorsRuntime ErrorsExercise 6.01: Runtime Errors While Adding NumbersSemantic ErrorsExercise 6.02: Logic 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 panicRecoverExercise 6.05: Recovering from a PanicGuidelines when working with Errors and PanicActivity 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
7. Interfaces
IntroductionInterfaceDefining an InterfaceImplementing an InterfaceAdvantages of Implementing Interfaces ImplicitlyExercise 7.01: Implementing an InterfaceDuck TypingPolymorphismExercise 7.02: Calculating the Area of Different Shapes Using PolymorphismAccepting Interfaces and Returning StructsEmpty interface{}Type Assertion and SwitchesExercise 7.03: Analyzing Empty interface{} DataActivity 7.01: Calculating Pay and Performance ReviewSummary
8. Packages
IntroductionMaintainableReusableModularWhat Is a Package?Package StructurePackage NamingPackage DeclarationsExported and Unexported CodeGOROOT and GOPATHPackage AliasMain PackageExercise 8.01: Creating a Package to Calculate Areas of Various ShapesThe init() FunctionExercise 8.02: Loading Budget CategoriesExecuting Multiple init() FunctionsExercise 8.03: Assigning Payees to Budget CategoriesActivity 8.01: Creating a Function to Calculate Payroll and Performance ReviewSummary
9. Basic Debugging
IntroductionMethods for Bug-Free CodeCode Incrementally and Test OftenWriting Unit TestsHandling All ErrorsPerforming LoggingFormatting Using fmtExercise 9.01: Working with fmt.PrintlnFormatting Using fmt.Printf()Additional Options for FormattingExercise 9.02: Printing Decimal, Binary, and Hex ValuesBasic DebuggingPrinting Go Variable TypesExercise 9.03 Printing the Go Representation of a VariableLoggingLog Fatal ErrorsActivity 9.01: Building a Program to Validate Social Security NumbersSummary

10. About Time
IntroductionMaking TimeExercise 10.1: Creating a Function to Return a timestampComparing TimeDuration CalculationManaging TimeExercise 10.2: Duration of ExecutionFormatting TimeExercise 10.03: What Is the Time in Your Zone?Activity 10.01: Formatting a Date According to User RequirementsActivity 10.02: Enforcing a Specific Format of Date and TimeActivity 10.03: Measuring Elapsed TimeActivity 10.04: Calculating the Future Date and TimeActivity 10.05: Printing the Local Time in Different Time ZonesSummary
11. Encoding and Decoding (JSON)
IntroductionJSONDecoding JSONStruct TagsExercise 11.01: Unmarshaling Student CoursesEncoding JSONExercise 11.02: Marshaling Student CoursesUnknown JSON StructuresExercise 11.03: Analyzing College Class JSONGOB: Go's Own EncodingExercise 11.04: Using gob to Encode DataActivity 11.01: Mimicking a Customer Order Using JSONSummary
12. Files and Systems
IntroductionFilesystemFile PermissionsFlags and ArgumentsSignalsExercise 12.01: Simulating CleanupCreating and Writing to Files Reading the Whole File at OnceExercise 12.02: Backing Up FilesCSVActivity 12.01: Parsing Bank Transaction FilesSummary
13. SQL and Databases
IntroductionThe DatabaseDatabase API and DriversConnecting to DatabasesCreating TablesInserting DataExercise 13.01: Creating a Table with NumbersRetrieving DataUpdating Existing DataDeleting DataExercise 13.02: Holding Prime Numbers in a DatabaseTruncating and Deleting TableActivity 13.01: Holding User Data in a TableActivity 13.02: Finding Messages of Specific UsersSummary
14. Using the Go HTTP Client
IntroductionThe Go HTTP Client and Its UsesSending a Request to a ServerExercise 14.01: Sending a Get Request to a Web Server Using the Go HTTP ClientStructured DataExercise 14.02: Using the HTTP Client with Structured DataActivity 14.01: Requesting Data from a Web Server and Processing the ResponseSending Data to a ServerExercise 14.03: Sending a Post Request to a Web Server Using the Go HTTP ClientUploading Files in a Post RequestExercise 14.04: Uploading a File to a Web Server via a Post RequestCustom Request HeadersExercise 14.05: Using Custom Headers and Options with the Go HTTP ClientActivity 14.02: Sending Data to a Web Server and Checking Whether the Data Was Received Using POST and GETSummary
15. HTTP Servers
IntroductionHow to Build a Basic ServerHTTP HandlerExercise 15.01: Creating a Hello World ServerSimple RoutingExercise 15.02: Routing Our ServerHandler versus Handler FunctionActivity 15.01: Adding a Page Counter to an HTML PageReturning Complex StructuresActivity 15.02: Serving a Request with a JSON PayloadDynamic ContentExercise 15.03: Personalized WelcomeTemplatingExercise 15.04: Templating Our PagesStatic ResourcesExercise 15.05: Creating a Hello World Server Using a Static FileGetting Some StyleExercise 15.06: A Stylish WelcomeGetting DynamicActivity 15.03: External TemplateHTTP MethodsExercise 15.07: Completing a QuestionnaireJSON loadsExercise 15.08: Building a Server That Accepts JSON RequestsSummary
16. Concurrent Work
IntroductionGoroutinesExercise 16.01: Using Concurrent RoutinesWaitGroupExercise 16.02: Experimenting with WaitGroupRace ConditionsAtomic OperationsExercise 16.03: An Atomic ChangeInvisible ConcurrencyActivity 16.01: Listing NumbersChannelsExercise 16.04: Exchange Greeting Messages via ChannelsExercise 16.05: Two-Way Message Exchange with ChannelsExercise 16.06: Sum Numbers from EverywhereExercise 16.07: Request to GoroutinesThe Importance of ConcurrencyExercise 16.08: Equally Splitting the Work between RoutinesConcurrency PatternsActivity 16.02: Source FilesBuffersExercise 16.09: Notifying When Computation Has FinishedSome More Common PracticesHTTP ServersMethods as RoutinesExercise 16.10: A Structured WorkGo Context PackageExercise 16.11: Managing Routines with ContextSummary
17. Using Go Tools
IntroductionThe go build ToolExercise 17.01: Using the go build ToolThe go run ToolExercise 17.02: Using the go run ToolThe gofmt ToolExercise 17.03: Using the gofmt ToolThe goimports ToolExercise 17.04: Using the goimports ToolThe go vet ToolExercise 17.05: Using the go vet ToolThe Go Race DetectorExercise 17.06: Using the Go Race DetectorThe go doc ToolExercise 17.07: Implementing the go doc ToolThe go get ToolExercise 17.08: Implementing the go get ToolActivity 17.01: Using gofmt, goimport, go vet, and go get to Correct a FileSummary
18. Security
IntroductionApplication SecuritySQL InjectionCommand InjectionExercise 18.01: Handling SQL InjectionCross-Site ScriptingExercise 18.02: Handling XSS AttacksCryptographyHashing LibrariesExercise 18.03: Using Different Hashing LibrariesEncryptionSymmetric EncryptionExercise 18.04: Symmetric Encryption and DecryptionAsymmetric EncryptionExercise 18.05: Asymmetric Encryption and DecryptionRandom GeneratorsExercise 18.06: Random GeneratorsHTTPS/TLSExercise 18.07: Generating a Certificate and Private KeyExercise 18.08: Running an HTTPS ServerPassword ManagementActivity 18.01: Authenticating Users on the Application Using Hashed PasswordsActivity 18.02: Creating CA Signed Certificates Using Crypto LibrariesSummary
19. Special Features
IntroductionBuild ConstraintsBuild TagsFilenamesReflectionTypeOf and ValueOfExercise 19.01: Using ReflectionActivity 19.01: Defining Build Constraints Using FilenamesDeepEqualWildcard PatternThe unsafe PackageExercise 19.02: Using cgo with unsafeActivity 19.02: Using Wildcard with Go TestSummary
Appendix
1. Variables and OperatorsActivity 1.01 Defining and PrintingActivity 1.02: Pointer Value SwapActivity 1.03: Message BugActivity 1.04: Bad Count Bug2. Logic and LoopsActivity 2.01: Implementing FizzBuzzActivity 2.02: Looping Over Map Data Using rangeActivity 2.03: Bubble Sort3. Core TypesActivity 3.01: Sales Tax CalculatorActivity 3.02: Loan Calculator4. Complex TypesActivity 4.01: Filling an ArrayActivity 4.02: Printing a User's Name Based on User InputActivity 4.03: Creating a Locale CheckerActivity 4.04: Slicing the WeekActivity 4.05: Removing an Element from a SliceActivity 4.06: Type Checker5. FunctionsActivity 5.01: Calculating the Working Hours of EmployeesActivity 5.02: Calculating Payable Amount for Employees Based on Working Hours6. ErrorsActivity 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 App7. InterfacesActivity 7.01: Calculating Pay and Performance Review8. PackagesActivity 8.01: Creating a Function to Calculate Payroll and Performance Review9. Basic DebuggingActivity 9.01: Building a Program to Validate Social Security Numbers10. About TimeActivity 10.01: Formatting a Date According to User RequirementsActivity 10.02: Enforcing a Specific Format of Date and TimeActivity 10.03: Measuring Elapsed TimeActivity 10.04: Calculating the Future Date and TimeActivity 10.05: Printing the Local Time in Different Time Zones11. Encoding and Decoding (JSON)Activity 11.01: Mimicking a Customer Order Using JSON12. Files and SystemsActivity 12.01: Parsing Bank Transaction Files13. SQL and DatabasesActivity 13.1: Holding User Data in a TableActivity 13.2: Finding Messages of Specific Users14. Using the Go HTTP ClientActivity 14.01: Requesting Data from a Web Server and Processing the ResponseActivity 14.02: Sending Data to a Web Server and Checking Whether the Data Was Received Using POST and GET15. HTTP ServersActivity 15.01: Adding a Page Counter to an HTML PageActivity 15.02: Serving a Request with a JSON PayloadActivity 15.03: External Template16. Concurrent WorkActivity 16.01: Listing NumbersActivity 16.02: Source Files17. Using Go ToolsActivity 17.01: Using gofmt, goimport, go vet, and go get to Correct a File18. SecurityActivity 18.01: Authenticating Users on the Application Using Hashed PasswordsActivity 18.02: Creating CA Signed Certificates Using Crypto Libraries19. Special FeaturesActivity 19.01: Defining Build Constraints Using FilenamesActivity 19.02: Using Wildcard with Go Test
What Next?
The SQL WorkshopThe Java WorkshopThe Kubernetes WorkshopPlease leave a review

Content preview from The Go Workshop

4. Complex Types

Overview

This chapter introduces Go's more complex types. This will build on what we learned in the previous chapter regarding Go's core types. These complex types are indispensable when you build more complex software as they allow you to logically group related data together. This ability to group data makes your code easier to understand, maintain, and fix.

By the end of this chapter, you will be able to use arrays, slices, and maps to group data together. You will learn to create custom types based on the core types. You will also learn to use structs to create structures composed of named fields of any other types and explain the importance of interface{}.

Introduction

In the previous chapter, we covered Go's core ...

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

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

The Go Workshop

by Delio D'Anna, Andrew Hayes, Sam Hennessy, Jeremy Leasor, Gobin Sougrakpam, Dániel Szabó, Philipp Mieden, David Parker, Gwenn Etourneau, Arpit Aggarwal, Eugene Wang

4. Complex Types

Introduction

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.