The Way To Go PART 1—WHY LEARN GO—GETTING STARTED

文件名称: The Way To Go

所属分类: 其它

开发工具:

文件大小: 4mb

下载次数: 0

上传时间: 2012-12-13

提供者: atom****

下载 (4mb)

不能下载？报告错误

详细说明： 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 ...展开收缩

(系统自动生成,下载前可以参看下载内容)