The-Way-To-Go

【实例简介】The-Way-To-Go

作者: Ivo Balbaert
出版社: iUniverse
副标题: A Thorough Introduction To The Go Programming Language
出版年: 2012-3-8
页数: 628
定价: USD 34.95
装帧: Paperback
ISBN: 9781469769165

【实例截图】

【核心代码】

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 1 st 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