The Way to Go. A thorough Introduction to the Go Programming Language

612 Pages·2012·2.304 MB·

by  Ivo Balbaert

THE WAY TO GO
A Thorough Introduction to the Go Programming Language
IVO BALBAERT
iUniverse, Inc.
Bloomington
The Way to Go
A Thorough Introduction to the Go Programming Language
Copyright © 2012 by Ivo Balbaert.
ISBN: 978-1-4697-6916-5 (sc)
ISBN: 978-1-4697-6917-2 (ebk)
Printed in the United States of America
iUniverse rev. date: 03/05/2012
CONTENTS
Preface ................................................................................................................................xix
PART 1—WHY LEARN GO—GETTING STARTED
Chapter 1—Origins, Context and Popularity of Go ..............................................................1
1.1 Origins and evolution ...............................................................................................1
1.2 Main characteristics, context and reasons for developing a new language ...................4
1.2.1 Languages that influenced Go ........................................................................4
1.2.2 Why a new language? .....................................................................................5
1.2.3 Targets of the language ...................................................................................5
1.2.4 Guiding design principles ..............................................................................7
1.2.5 Characteristics of the language .......................................................................7
1.2.6 Uses of the language .......................................................................................8
1.2.7 Missing features? ............................................................................................9
1.2.8 Programming in Go .....................................................................................10
1.2.9 Summary .....................................................................................................10
Chapter 2—Installation and Runtime Environment ...........................................................11
2.1 Platforms and architectures ....................................................................................11
(1) The gc Go-compilers: .................................................................................11
(2) The gccgo-compiler: ...................................................................................13
(3) File extensions and packages: ......................................................................14
2.2 Go Environment variables .......................................................................................14
2.3 Installing Go on a Linux system ..............................................................................16
2.4 Installing Go on an OS X system ............................................................................21
2.5 Installing Go on a Windows system.........................................................................21
2.6 What is installed on your machine? ........................................................................26
2.7 The Go runtime ......................................................................................................27
2.8 A Go interpreter .....................................................................................................27
Chapter 3—Editors, IDE’s and Other tools.........................................................................28
3.1 Basic requirements for a decent Go development environment ................................28
3.2 Editors and Integrated Development Environments ................................................29
3.2.1. Golang LiteIDE .........................................................................................32
3.2.2. GoClipse .....................................................................................................33
3.3 Debuggers ...............................................................................................................34
3.4 Building and running go-programs with command- and Makefiles .........................35
3.5 Formatting code: go fmt or gofmt ...........................................................................39
3.6 Documenting code: go doc or godoc .......................................................................40
3.7 Other tools ..............................................................................................................41
3.8 Go’s performance ....................................................................................................41
3.9 Interaction with other languages. .............................................................................43
3.9.1. Interacting with C ......................................................................................43
3.9.2. Interacting with C++ ...................................................................................45
PART 2—CORE CONSTRUCTS AND TECHNIQUES OF THE LANGUAGE
Chapter 4—Basic constructs and elementary data types ......................................................49
4.1. Filenames—Keywords—Identifiers .........................................................................49
4.2. Basic structure and components of a Go-program ..................................................50
4.2.1 Packages, import and visibility .....................................................................51
4.2.3 Comments ...................................................................................................56
4.2.4 Types............................................................................................................57
4.2.5 General structure of a Go-program ..............................................................58
4.2.6 Conversions .................................................................................................60
4.2.7 About naming things in Go .........................................................................60
4.3. Constants ...............................................................................................................60
4.4. Variables .................................................................................................................63
4.4.1 Introduction ................................................................................................63
4.4.2 Value types and reference types ....................................................................66
4.4.3 Printing........................................................................................................68
4.4.4 Short form with the := assignment operator .................................................69
4.4.5 Init-functions ...............................................................................................70
4.5. Elementary types and operators ..............................................................................73
4.5.1. Boolean type bool .......................................................................................73
4.5.2. Numerical types ..........................................................................................75
4.5.2.1 ints and floats ............................................................................................75
4.5.2.2 Complex numbers ....................................................................................79
4.5.2.3 Bit operators .............................................................................................79
4.5.2.4 Logical operators .......................................................................................81
4.5.2.5 Arithmetic operators ................................................................................82
4.5.2.6 Random numbers .....................................................................................82
4.5.3. Operators and precedence ...........................................................................84
4.5.4. Aliasing types ..............................................................................................84
4.5.5. Character type ............................................................................................85
4.6. Strings ....................................................................................................................86
4.7. The strings and strconv package .............................................................................88
4.7.1—Prefixes and suffixes: ..................................................................................88
4.7.2—Testing whether a string contains a substring: ............................................89
4.7.3—Indicating at which position (index) a substring or character occurs
in a string: ..................................................................................................89
4.7.4—Replacing a substring: ...............................................................................90
4.7.5—Counting occurrences of a substring: .........................................................90
4.7.6—Repeating a string:.....................................................................................90
4.7.7—Changing the case of a string:....................................................................91
4.7.8—Trimming a string: ....................................................................................92
4.7.9—Splitting a string: .......................................................................................92
4.7.10—Joining over a slice: .................................................................................92
4.7.11—Reading from a string: .............................................................................93
4.8. Times and dates ......................................................................................................95
4.9. Pointers ..................................................................................................................96
Chapter 5—Control structures ..........................................................................................101
5.1—The if else construct ...........................................................................................101
5.2—Testing for errors on functions with multiple return values .................................106
5.3—The switch keyword ...........................................................................................110
5.4—The for construct ...............................................................................................114
5.4.1 Counter-controlled iteration ......................................................................114
Character on position 2 is: ..........................................................................................116
5.4.2 Condition-controlled iteration ..................................................................117
5.4.3 Infinite loops ............................................................................................118
5.4.4 The for range construct ..............................................................................119
5.5—Break / continue .................................................................................................121
5.6—Use of labels with break and continue—goto ......................................................123
Chapter 6—Functions.......................................................................................................126
6.1 Introduction ..........................................................................................................126
6.2 Parameters and return values .................................................................................129
6.2.1 Call by value / Call by reference .................................................................129
6.2.2 Named return variables ..............................................................................131
6.2.3 Blank identifier ..........................................................................................133
6.2.4 Changing an outside variable .....................................................................134
6.3 Passing a variable number of parameters ................................................................135
6.4 Defer and tracing ..................................................................................................137
6.5 Built-in functions ..................................................................................................142
6.6 Recursive functions ...............................................................................................143
6.8 Closures (function literals) ....................................................................................147
6.9 Applying closures: a function returning another function .....................................150
6.10 Debugging with closures .....................................................................................153
6.11 Timing a function ..............................................................................................154
6.12 Using memoization for performance ...................................................................154
Chapter 7—Arrays and Slices ............................................................................................157
7.1 Declaration and initialization ................................................................................157
7.1.1 Concept .....................................................................................................157
7.1.2 Array literals ...............................................................................................161
7.1.3 Multidimensional arrays .............................................................................162
7.1.4 Passing an array to a function .....................................................................163
7.2 Slices .....................................................................................................................164
7.2.1 Concept .....................................................................................................164
7.2.2 Passing a slice to a function ........................................................................168
7.2.3 Creating a slice with make() .......................................................................168
7.2.4 Difference between new() and make() ........................................................170
7.2.5 Multidimensional slices ..............................................................................171
7.2.6 The bytes package ......................................................................................171
7.3 For range construct ...............................................................................................172
7.4 Reslicing ................................................................................................................175
7.5 Copying and appending slices ...............................................................................176
7.6 Applying strings, arrays and slices ..........................................................................178
7.6.1 Making a slice of bytes from a string ..........................................................178
7.6.2 Making a substring of a string ....................................................................179
7.6.3 Memory representation of a string and a slice .............................................179
7.6.4 Changing a character in a string .................................................................180
7.6.5 Comparison function for byte arrays ..........................................................180
7.6.6 Searching and sorting slices and arrays ......................................................181
7.6.7 Simulating operations with append ............................................................182
7.6.8 Slices and garbage collection ......................................................................182
Chapter 8—Maps .............................................................................................................185
8.1 Declaration, initialization and make ......................................................................185
8.1.1 Concept .....................................................................................................185
8.1.2 Map capacity .............................................................................................188
8.1.3 Slices as map values ....................................................................................188
8.2 Testing if a key-value item exists in a map—Deleting an element ..........................188
8.3 The for range construct .........................................................................................190
8.4 A slice of maps .....................................................................................................191
8.5 Sorting a map ........................................................................................................192
8.6 Inverting a map .....................................................................................................194
Chapter 9—Packages ........................................................................................................196
A The standard library .................................................................................................196
9.1 Overview of the standard library. ...........................................................................196
9.2 The regexp package. ..............................................................................................199
9.3 Locking and the sync package. ..............................................................................200
9.4 Accurate computations and the big package. .........................................................202
B Custom and external packages: use, build, test, document, install ............................203
9.5 Custom packages and visibility ..............................................................................203
9.6 Using godoc for your custom packages. .................................................................208
9.7 Using go install for installing custom packages. .....................................................210
9.8 Custom packages: map structure, go install and go test .........................................212
9.8.1 Map-structure for custom packages ............................................................212
9.8.2 Locally installing the package .....................................................................215
9.8.3 OS dependent code ....................................................................................216
9.9 Using git for distribution and installation. .............................................................216
9.9.1 Installing to github ....................................................................................216
9.9.2 Installing from github ................................................................................217
9.10 Go external packages and projects. .....................................................................218
9.11 Using an external library in a Go program. ..........................................................219
Chapter 10—Structs and Methods ....................................................................................224
10.1 Definition of a struct ...........................................................................................224
10.2 Creating a struct variable with a Factory method .................................................232
10.2.1 A factory for structs..................................................................................232
10.2.2 new() and make() revisited for maps and structs: ......................................234
10.3 Custom package using structs ..............................................................................235
10.4 Structs with tags ..................................................................................................236
10.5 Anonymous fields and embedded structs .............................................................237
10.5.1 Definition ................................................................................................237
10.5.2 Embedded structs ....................................................................................238
10.5.3 Conflicting names ....................................................................................239
10.6 Methods ..............................................................................................................240
10.6.1 What is a method? ...................................................................................240
10.6.2 Difference between a function and a method ...........................................244
10.6.3 Pointer or value as receiver .......................................................................245
10.6.4 Methods and not-exported fields .............................................................247
10.6.5 Methods on embedded types and inheritance ...........................................248
10.6.6 How to embed functionality in a type ......................................................251
10.6.7 Multiple inheritance .................................................................................253
10.6.8 Universal methods and method naming ...................................................256
10.6.9 Comparison between Go types and methods and other
object-oriented languages. .........................................................................256
10.7 The String()-method and format specifiers for a type...........................................258
10.8 Garbage collection and SetFinalizer .....................................................................261
Chapter 11—Interfaces and reflection ...............................................................................263
11.1 What is an interface? ...........................................................................................263
11.2 Interface embedding interface(s) ..........................................................................270
11.3 How to detect and convert the type of an interface variable: type assertions ........270
11.4 The type switch ...................................................................................................273
11.5 Testing if a value implements an interface ............................................................274
11.6 Using method sets with interfaces ........................................................................275
11.7 1st example: sorting with the Sorter interface .......................................................277
11.8 2nd example: Reading and Writing .....................................................................282
11.9 Empty Interface...................................................................................................284
11.9.1 Concept ...................................................................................................284
11.9.2 Constructing an array of a general type or with variables of
different types ...........................................................................................286
11.9.3 Copying a data-slice in a slice of interface{} ..............................................287
11.9.4 Node structures of general or different types ............................................288
11.9.5 Interface to interface ................................................................................289
11.10 The reflect package ............................................................................................290
11.10.1 Methods and types in reflect ..................................................................290
11.10.2 Modifying (setting) a value through reflection........................................293
11.10.3 Reflection on structs ..............................................................................294
11.11 Printf and reflection. .........................................................................................296
11.12 Interfaces and dynamic typing ...........................................................................298
11.12.1 Dynamic typing in Go ...........................................................................298
11.12.2 Dynamic method invocation ..................................................................300
11.12.3 Extraction of an interface .......................................................................301
11.12.4 Explicitly indicating that a type implements an interface........................303
11.12.5 Empty interface and function overloading..............................................304
11.12.6 Inheritance of interfaces .........................................................................304
11.13 Summary: the object-orientedness of Go ...........................................................306
11.14 Structs, collections and higher order functions ..................................................306
PART 3—ADVANCED GO
Chapter 12—Reading and writing ....................................................................................313
12.1 Reading input from the user ................................................................................313
12.2 Reading from and writing to a file .......................................................................317
12.2.1 Reading from a file ...................................................................................317
12.2.2 The package compress: reading from a zipped file ....................................321
12.2.3 Writing to a file ........................................................................................322
12.3 Copying files .......................................................................................................324
12.4 Reading arguments from the command-line ........................................................325
12.4.1 With the os-package .................................................................................325
12.4.2 With the flag-package ..............................................................................326
12.5 Reading files with a buffer ...................................................................................328
12.6 Reading and writing files with slices ....................................................................330
12.7 Using defer to close a file ....................................................................................332
12.8 A practical example of the use of interfaces: fmt.Fprintf .....................................332
12.9 The json dataformat ............................................................................................334
12.10 The xml dataformat ...........................................................................................340
12.11 Datatransport through gob ................................................................................342
12.12 Cryptography with go .......................................................................................345
Chapter 13—Error-handling and Testing ..........................................................................348
13.1 Error-handling ....................................................................................................349
13.1.1 Defining errors .........................................................................................349
13.1.2 Making an error-object with fmt .............................................................353
13.2 Run-time exceptions and panic ...........................................................................353
13.4 Error-handling and panicking in a custom package .............................................357
13.5 An error-handling scheme with closures ..............................................................360
13.6 Starting an external command or program ..........................................................363
13.7 Testing and benchmarking in Go ........................................................................364
13.8 Testing: a concrete example .................................................................................367
13.9 Using table-driven tests. ......................................................................................369
13.10 Investigating performance: tuning and profiling Go programs ...........................371
13.10.1 Time and memory consumption ............................................................371
13.10.2 Tuning with go test ................................................................................371
13.10.3 Tuning with pprof ..................................................................................371
Chapter 14—Goroutines and Channels ............................................................................375
14.1 Concurrency, parallelism and goroutines .............................................................375
14.1.1 What are goroutines? ...............................................................................375
14.1.2 The difference between concurrency and parallelism ................................377
14.1.3 Using GOMAXPROCS ...........................................................................378
14.1.4 How to specify the number of cores to be used on the command-line?.....379
14.1.5 Goroutines and coroutines .......................................................................381
14.2 Channels for communication between goroutines ...............................................381
14.2.1 Concept ...................................................................................................381
14.2.2 Communication operator <- ....................................................................383
14.2.3 Blocking of channels ................................................................................385
14.2.4 Goroutines synchronize through the exchange of data on one (or
more) channel(s). ......................................................................................387
14.2.5 Asynchronous channels—making a channel with a buffer ........................387
14.2.6 Goroutine using a channel for outputting result(s) ...................................388
14.2.7 Semaphore pattern ...................................................................................389
14.2.8 Implementing a parallel for-loop ..............................................................391
14.2.9 Implementing a semaphore using a buffered channel ...............................391
14.2.10 For—range applied to channels ..............................................................394
14.2.11 Channel directionality............................................................................396
14.3 Synchronization of goroutines: closing a channel—testing for blocked channels .400
14.4 Switching between goroutines with select ............................................................403
14.5 Channels, Timeouts and Tickers ..........................................................................408
14.6 Using recover with goroutines .............................................................................412
14.7 Comparing the old and the new model: Tasks and Worker processes. ..................413
14.8 Implementing a lazy generator .............................................................................416
14.9 Implementing Futures .........................................................................................420
14.10 Multiplexing .....................................................................................................421
14.10.1 A typical client-server pattern .................................................................421
14.10.2 Teardown: shutdown the server by signaling a channel ...........................424
14.11 Limiting the number of requests processed concurrently ...................................427
14.12 Chaining goroutines ..........................................................................................428
14.13 Parallelizing a computation over a number of cores ...........................................429
14.14 Parallelizing a computation over a large amount of data ....................................430
14.15 The leaky bucket algorithm ...............................................................................431