English
资源说明：The Way to Go，: A Thorough Introduction to the Go Programming Language 英文书籍，已Cross the wall，从Google获得书中源代码，分享一下。喜欢请购买正版。
目录如下：
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
14.16 Benchmarking goroutines...................................................................................433
14.17 Concurrent acces to objects by using a channel..................................................434
Chapter 15—Networking, templating and web-applications..............................................436
15.1 A tcp-server .........................................................................................................436
15.2 A simple webserver...............................................................................................445
15.3 Polling websites and reading in a web page...........................................................448
15.4 Writing a simple web application.........................................................................452
15.5 Making a web application robust..........................................................................454
15.6 Writing a web application with templates.............................................................456
15.7 Exploring the template package............................................................................461
15.7.1. Field substitution: {{.FieldName}}............................................................462
15.7.2. Validation of the templates.......................................................................463
15.7.3 If-else........................................................................................................464
15.7.4 Dot and with-end.....................................................................................465
15.7.5 Template variables $..................................................................................466
15.7.6 Range-end.................................................................................................467
15.7.7 Predefined template functions...................................................................467
15.8 An elaborated webserver with different functions.................................................468
(works only on Unix because calls /bin/date)........................................................474
15.9 Remote procedure calls with rpc...........................................................................474
15.10 Channels over a network with netchan...............................................................477
15.11 Communication with websocket........................................................................478
15.12 Sending mails with smtp....................................................................................480
PART 4—APPLYING GO
Chapter 16—Common Go Pitfalls or Mistakes..................................................................485
16.1 Hiding (shadowing) a variable by misusing short declaration...............................486
16.2 Misusing strings...................................................................................................486
16.3 Using defer for closing a file in the wrong scope...................................................487
16.4 Confusing new() and make()................................................................................488
16.5 No need to pass a pointer to a slice to a function..................................................488
16.6 Using pointers to interface types...........................................................................488
16.7 Misusing pointers with value types.......................................................................489
16.8 Misusing goroutines and channels........................................................................489
16.9 Using closures with goroutines.............................................................................490
16.10 Bad error handling.............................................................................................491
16.10.1 Don’t use booleans:.................................................................................491
16.10.2 Don’t clutter your code with error-checking:...........................................492
Chapter 17—Go Language Patterns...................................................................................494
17.1 The comma, ok pattern........................................................................................494
17.2 The defer pattern..................................................................................................495
17.3 The visibility pattern............................................................................................497
17.4 The operator pattern and interface.......................................................................497
17.4.1 Implement the operators as functions.......................................................497
17.4.2 Implement the operators as methods.........................................................498
17.4.3 Using an interface.....................................................................................499
Chapter 18—Useful Code Snippets—Performance Advice.................................................500
18.1 Strings..................................................................................................................500
18.2 Arrays and slices...................................................................................................501
18.3 Maps....................................................................................................................502
18.4 Structs..................................................................................................................502
18.5 Interfaces..............................................................................................................503
18.6 Functions.............................................................................................................503
18.7 Files......................................................................................................................504
18.8 Goroutines and channels......................................................................................505
18.9 Networking and web applications.........................................................................507
18.9.1. Templating:......................................................................................................507
18.10 General..............................................................................................................508
18.11 Performance best practices and advice................................................................508
Chapter 19—Building a complete application....................................................................509
19.1 Introduction.........................................................................................................509
19.2 Introducing Project UrlShortener.........................................................................509
19.3 Data structure......................................................................................................510
19.4 Our user interface: a web server frontend.............................................................515
19.5 Persistent storage: gob..........................................................................................519
19.6 Using goroutines for performance........................................................................524
19.7 Using json for storage...........................................................................................527
19.8 Multiprocessing on many machines......................................................................528
19.9 Using a ProxyStore...............................................................................................532
19.10 Summary and enhancements..............................................................................536
Chapter 20—Go in Google App Engine............................................................................538
20.1 What is Google App Engine ?...............................................................................538
20.2 Go in the cloud ...................................................................................................540
20.3 Installation of the Go App Engine SDK: the development environment for Go...540
20.3.1. Installation...............................................................................................540
20.3.2. Checking and testing...............................................................................542
20.4 Building your own Hello world app ....................................................................543
20.4.1 Map structure—Creating a simple http-handler........................................543
20.4.2 Creating the configuration file app.yaml...................................................544
20.4.3 Iterative development................................................................................548
20.4.4. Integrating with the GoClipse IDE..........................................................548
20.5 Using the Users service and exploring its API.......................................................549
20.6 Handling forms....................................................................................................551
20.7 Using the datastore...............................................................................................552
20.8 Uploading to the cloud.......................................................................................556
Chapter 21—Real World Uses of Go.................................................................................559
21.1 Heroku—a highly available consistent data store in Go. ......................................559
21.2 MROffice—a VOIP system for call centers in Go................................................561
21.3 Atlassian—a virtual machine cluster management system.....................................562
21.4 Camlistore—a content addressable storage system................................................563
21.5 Other usages of the Go language..........................................................................563
APPENDICES...................................................................................................................567
(A) CODE REFERENCE...........................................................................................567
(B)CUTE GO QUOTES.............................................................................................571
GO QUOTES: TRUE BUT NOT SO CUTE....................................................572
(C) LIST OF CODE EXAMPLES (Listings)...............................................................572
(E) References in the text to Go—packages..................................................................583
(F) References in the text to Go—tools........................................................................586
(G) Answers to Questions............................................................................................586
(H) ANSWERS TO EXERCISES................................................................................590
(I) BIBLIOGRAPHY (Resources and References)........................................................593
Index..............................................................................................................................597
List of Illustrations
Chapter 1—Origins, Context and Popularity of Go...............................................................1
Fig 1.1: The designers of Go: Griesemer, Thompson and Pike..........................................1
Fig 1.2: The logo’s of Go..................................................................................................3
Fig 1.3: Influences on Go.................................................................................................5
Chapter 3—Editors, IDE’s and Other tools.........................................................................28
Fig 3.1: LiteIDE and its AST-view..................................................................................33
Fig 3.2: GoClipse and its outline code-view...................................................................34
Chapter 4—Basic constructs and elementary data types.......................................................49
Fig 4.1: Value type..........................................................................................................67
Fig 4.2: Assignment of value types..................................................................................67
Fig 4.3: Reference types and assignment.........................................................................67
Fig 4.4: Pointers and memory usage...............................................................................98
Fig 4.5: Pointers and memory usage, 2...........................................................................99
Chapter 7—Arrays and Slices.............................................................................................157
Fig 7.1: Array in memory.............................................................................................158
Fig 7.2: Slice in memory..............................................................................................166
Chapter 9—Packages.........................................................................................................196
Fig 9.1: Package documentation with godoc.................................................................210
Chapter 10—Structs and Methods.....................................................................................224
Fig 10.1: Memory layout of a struct.............................................................................227
Fig 10.2: Memory layout of a struct of structs..............................................................229
Fig. 10.3: Linked list as recursive struct........................................................................230
Fig 10.4: Binary tree as recursive struct.........................................................................230
Chapter 11—Interfaces and reflection................................................................................263
Fig 11.1: Interface value in memory.............................................................................264
Chapter 14—Goroutines and Channels.............................................................................375
Fig 14.1: Channels and goroutines...............................................................................382
Fig 14.2: The sieve prime-algorithm.............................................................................397
Chapter 15—Networking, templating and web-applications..............................................436
Fig 15.1—Screen of exercise 15.6.................................................................................454
Chapter 19—Building a complete application....................................................................509
Fig 19.1: Handler functions in goto.............................................................................515
Fig 19.2: The Add handler...........................................................................................518
Fig 19.3: The response of the Add handler...................................................................519
Fig 19.4: The response of the Redirect handler.............................................................519
Fig 19.5: Distributing the work load over master- and slave computers........................529
Chapter 20—Go in Google App Engine............................................................................538
Fig 20.1: The Application Control Panel......................................................................558
本源码包内暂不包含可直接显示的源代码文件，请下载源码包。
