go语言基础.pdf

【实例截图】

【核心代码】

Table of Contents
Preface i
Chapter 1: Variables and Operators 1
Introduction .................................................................................................... 2
What Does Go Look Like? .................................................................................... 3
Exercise 1.01: Using Variables, Packages, and Functions to Print Stars ...... 9
Activity 1.01 Defining and Printing .................................................................. 10
Declaring Variables ............................................................................................ 11
Declaring a Variable Using var ......................................................................... 11
Exercise 1.02: Declaring a Variable Using var ................................................. 11
Declaring Multiple Variables at Once with var ............................................... 12
Exercise 1.03: Declaring Multiple Variables at Once with var ...................... 13
Skipping the Type or Value When Declaring Variables ................................. 14
Exercise 1.04: Skipping the Type or Value When Declaring Variables ......... 14
Type Inference Gone Wrong ............................................................................. 16
Short Variable Declaration ............................................................................... 16
Exercise 1.05: Implementing Short Variable Declaration ............................. 17
Declaring Multiple Variables with a Short Variable Declaration .................. 18
Exercise 1.06: Declaring Multiple Variables from a Function ....................... 19
Using var to Declare Multiple Variables in One Line .................................... 20
Non-English Variable Names ............................................................................ 21
Changing the Value of a Variable ..................................................................... 22
Exercise 1.07: Changing the Value of a Variable ............................................ 22
Changing Multiple Values at Once ................................................................... 23
Exercise 1.08: Changing Multiple Values at Once .......................................... 24
Operators ............................................................................................................ 25
Exercise 1.09 Using Operators with Numbers ................................................ 25
Shorthand Operator .......................................................................................... 28
Exercise 1.10: Implementing Shorthand Operators ...................................... 29
Comparing Values .............................................................................................. 30
Exercise 1.11: Comparing Values ..................................................................... 31
Zero Values ......................................................................................................... 32
Exercise 1.12 Zero Values .................................................................................. 33
Value versus Pointer .......................................................................................... 35
Getting a Pointer ................................................................................................ 37
Exercise 1.13: Getting a Pointer ....................................................................... 37
Getting a Value from a Pointer ........................................................................ 39
Exercise 1.14: Getting a Value from a Pointer ................................................ 39
Function Design with Pointers ......................................................................... 41
Exercise 1.15: Function Design with Pointers ................................................. 41
Activity 1.02: Pointer Value Swap ..................................................................... 43
Constants ............................................................................................................ 44
Exercise 1.16: Constants ................................................................................... 45
Enums .................................................................................................................. 47
Scope ................................................................................................................... 49
Activity 1.03: Message Bug ................................................................................ 51
Activity 1.04: Bad Count Bug ............................................................................. 52
Summary ....................................................................................................... 53
Chapter 2: Logic and Loops 55
Introduction .................................................................................................. 56
if Statements ...................................................................................................... 56
Exercise 2.01: A Simple if Statement ............................................................... 57
if else Statements .............................................................................................. 58
Exercise 2.02: Using an if else Statement ....................................................... 59
else if Statements .............................................................................................. 60
Exercise 2.03: Using an else if Statement ....................................................... 60
The Initial if Statement ...................................................................................... 61
Exercise 2.04: Implementing the Initial if Statements .................................. 62
Activity 2.01: Implementing FizzBuzz .............................................................. 64
Expression switch Statements ........................................................................ 66
Exercise 2.05: Using a switch Statement ......................................................... 67
Exercise 2.06: switch Statements and Multiple case Values ........................ 68
Exercise 2.07: Expressionless switch Statements ......................................... 70
Loops ................................................................................................................... 71
Exercise 2.08: Using the for i Loop ................................................................... 72
Exercise 2.09: Looping Over Arrays and Slices ............................................... 73
The range Loop .................................................................................................. 74
Exercise 2.10: Looping Over a Map .................................................................. 75
Activity 2.02: Looping Over Map Data Using range ....................................... 76
break and continue ........................................................................................... 77
Exercise 2.11: Using break and continue to Control Loops .......................... 78
Activity 2.03: Bubble Sort .................................................................................. 80
Summary ....................................................................................................... 81
Chapter 3: Core Types 83
Introduction .................................................................................................. 84
True and False .............................................................................................. 85
Exercise 3.01: Program to Measure Password Complexity .......................... 85
Numbers ....................................................................................................... 88
Integer ................................................................................................................. 89
Floating Point ..................................................................................................... 91
Exercise 3.02: Floating-Point Number Accuracy ............................................ 91
Overflow and Wraparound ............................................................................... 93
Exercise 3.03: Triggering Number Wraparound ............................................. 94
Big Numbers ....................................................................................................... 95
Exercise 3.04: Big Numbers .............................................................................. 95
Byte ................................................................................................................ 97
Text ................................................................................................................ 97
Rune ..................................................................................................................... 99
Exercise 3.05: Safely Looping over a String .................................................. 101
The nil Value ............................................................................................... 104
Activity 3.01: Sales Tax Calculator ................................................................. 104
Activity 3.02: Loan Calculator ........................................................................ 105
Summary ..................................................................................................... 107
Chapter 4: Complex Types 109
Introduction ................................................................................................ 110
Collection Types ......................................................................................... 110
Arrays .......................................................................................................... 111
Exercise 4.01: Defining an Array ................................................................... 111
Comparing Arrays ........................................................................................... 112
Exercise 4.02: Comparing Arrays ................................................................... 112
Initializing Arrays Using Keys ........................................................................ 114
Exercise 4.03: Initializing an Array Using Keys ............................................ 114
Reading from an Array ................................................................................... 115
Exercise 4.04: Reading a Single Item from an Array ................................... 116
Writing to an Array ......................................................................................... 116
Exercise 4.05: Writing to an Array ................................................................. 117
Looping an Array ............................................................................................ 118
Exercise 4.06: Looping Over an Array Using a "for i" Loop ....................... 118
Modifying the Contents of an Array in a Loop ............................................ 120
Exercise 4.07: Modifying the Contents of an Array in a Loop .................... 120
Activity 4.01: Filling an Array ......................................................................... 121
Slice .............................................................................................................. 122
Exercise 4.08: Working with Slices ................................................................ 123
Activity 4.02: Printing a User's Name Based on User Input ....................... 125
Appending Multiple Items to a Slice ............................................................. 125
Exercise 4.09: Appending Multiple Items to a Slice .................................... 126
Activity 4.03: Creating a Locale Checker ...................................................... 127
Creating Slices from Slices and Arrays ......................................................... 128
Exercise 4.10: Creating Slices from a Slice ................................................... 129
Understanding Slice Internals ....................................................................... 130
Exercise 4.11: Using make to Control the Capacity of a Slice .................... 131
Background Behavior of Slices ...................................................................... 133
Exercise 4.12: Controlling Internal Slice Behavior ..................................... 133
Map Fundamentals ......................................................................................... 138
Exercise 4.13: Creating, Reading, and Writing a Map ................................ 139
Reading from Maps ......................................................................................... 140
Exercise 4.14: Reading from a Map ............................................................... 141
Activity 4.04: Slicing the Week ....................................................................... 143
Deleting Elements from a Map ...................................................................... 144
Exercise 4.15: Deleting an Element from a Map ......................................... 144
Activity 4.05: Removing an Element from a Slice ........................................ 146
Simple Custom Types ................................................................................ 146
Exercise 4.16: Creating a Simple Custom Type ............................................ 147
Structs ......................................................................................................... 148
Exercise 4.17: Creating Struct Types and Values ......................................... 149
Comparing Structs to Each Other ................................................................. 152
Exercise 4.18: Comparing Structs to Each Other ......................................... 152
Struct Composition Using Embedding ......................................................... 154
Exercise 4.19: Struct Embedding and Initialization .................................... 155
Type Conversions ............................................................................................ 158
Exercise 4.20: Numeric Type Conversion ..................................................... 158
Type Assertions and interface{} .................................................................... 160
Exercise 4.21: Type Assertion ........................................................................ 161
Type Switch ...................................................................................................... 163
Exercise 4.22: Type Switch ............................................................................. 163
Activity 4.06: Type Checker ............................................................................ 166
Summary ..................................................................................................... 167
Chapter 5: Functions 169
Introduction ................................................................................................ 170
Functions .................................................................................................... 170
Parts of a function .......................................................................................... 171
fizzBuzz ........................................................................................................ 174
Exercise 5.01: Creating a Function to Print Salesperson
Expectation Ratings from the Number of Items Sold ................................ 177
Parameters ................................................................................................. 179
The Difference between an Argument and a Parameter .......................... 181
Exercise 5.02: Mapping Index Values to Column Headers ......................... 182
Function Variable Scope ................................................................................. 183
Return Values .................................................................................................. 185
Exercise 5.03: Creating a fizzBuzz Function with Return Values ............... 185
Activity 5.01: Calculating the Working Hours of Employees ...................... 187
Naked Returns ........................................................................................... 188
Exercise 5.04: Mapping a CSV Index to a Column Header
with Return Values ......................................................................................... 191
Variadic Function ............................................................................................ 192
Exercise 5.05: Summing Numbers ................................................................ 196
Anonymous Functions .................................................................................... 197
Exercise 5.06: Creating an Anonymous Function to Calculate
the Square Root of a Number ....................................................................... 199
Closures ....................................................................................................... 200
Exercise 5.07: Creating a Closure Function to Decrement a Counter ...... 202
Function Types ................................................................................................ 203
Exercise 5.08: Creating Various Functions to Calculate Salary .................. 207
defer ............................................................................................................ 209
Activity 5.02: Calculating Payable Amount for Employees
Based on Working Hours ............................................................................... 212
Summary ..................................................................................................... 214
Chapter 6: Errors 217
Introduction ................................................................................................ 218
What Are Errors? ........................................................................................ 218
Syntax Errors ................................................................................................... 219
Runtime Errors ................................................................................................ 220
Exercise 6.01: Runtime Errors While Adding Numbers .............................. 220
Semantic Errors ............................................................................................... 222
Exercise 6.02: Logic Error with Walking Distance ....................................... 222
Error Handling Using Other Programming Languages ......................... 224
Error Interface Type ................................................................................... 225
Creating Error Values ..................................................................................... 228
Exercise 6.03: Creating an Application to Calculate Pay for the Week ..... 229
Panic ............................................................................................................ 232
Exercise 6.04: Crashing the Program on Errors Using panic ..................... 237
Recover ........................................................................................................ 240
Exercise 6.05: Recovering from a Panic ........................................................ 242
Guidelines when working with Errors and Panic ........................................ 245
Activity 6.01: Creating a Custom Error Message
for a Banking Application .............................................................................. 245
Activity 6.02: Validating a Bank Customer's
Direct Deposit Submission ............................................................................. 246
Activity 6.03: Panic on Invalid Data Submission ......................................... 247
Activity 6.04: Preventing a Panic from Crashing the App .......................... 248
Summary ..................................................................................................... 249
Chapter 7: Interfaces 251
Introduction ................................................................................................ 252
Interface ...................................................................................................... 253
Defining an Interface ...................................................................................... 255
Implementing an Interface ............................................................................ 256
Advantages of Implementing Interfaces Implicitly ..................................... 258
Exercise 7.01: Implementing an Interface ................................................... 259
Duck Typing ................................................................................................ 261
Polymorphism ............................................................................................ 263
Exercise 7.02: Calculating the Area of Different Shapes
Using Polymorphism ...................................................................................... 269
Accepting Interfaces and Returning Structs ........................................... 272
Empty interface{} ............................................................................................ 275
Type Assertion and Switches ......................................................................... 277
Exercise 7.03: Analyzing Empty interface{} Data ........................................ 282
Activity 7.01: Calculating Pay and Performance Review ............................ 286
Summary ..................................................................................................... 287
Chapter 8: Packages 291
Introduction ................................................................................................ 292
Maintainable ............................................................................................... 294
Reusable....................................................................................................... 294
Modular........................................................................................................ 295
What Is a Package? .................................................................................... 296
Package Structure ........................................................................................... 297
Package Naming ............................................................................................. 298
Package Declarations ..................................................................................... 300
Exported and Unexported Code .............................................................. 301
GOROOT and GOPATH .................................................................................... 303
Package Alias ................................................................................................... 306
Main Package .................................................................................................. 307
Exercise 8.01: Creating a Package to Calculate Areas of Various Shapes 308
The init() Function ...................................................................................... 311
Exercise 8.02: Loading Budget Categories ................................................... 314
Executing Multiple init() Functions ............................................................... 315
Exercise 8.03: Assigning Payees to Budget Categories ............................... 317
Activity 8.01: Creating a Function to Calculate Payroll and Performance
Review .............................................................................................................. 318
Summary ..................................................................................................... 319
Chapter 9: Basic Debugging 323
Introduction ................................................................................................ 324
Methods for Bug-Free Code ...................................................................... 325
Code Incrementally and Test Often .............................................................. 326
Writing Unit Tests ........................................................................................... 326
Handling All Errors .......................................................................................... 326
Performing Logging ........................................................................................ 326
Formatting Using fmt ..................................................................................... 327
Exercise 9.01: Working with fmt.Println ....................................................... 327
Formatting Using fmt.Printf() ........................................................................ 328
Additional Options for Formatting ............................................................... 332
Exercise 9.02: Printing Decimal, Binary, and Hex Values ........................... 335
Basic Debugging ......................................................................................... 337
Printing Go Variable Types ............................................................................ 341
Exercise 9.03 Printing the Go Representation of a Variable ...................... 342
Logging ........................................................................................................ 344
Log Fatal Errors .......................................................................................... 347
Activity 9.01: Building a Program to Validate Social
Security Numbers ........................................................................................... 348
Summary ..................................................................................................... 350
Chapter 10: About Time 353
Introduction ................................................................................................ 354
Making Time ............................................................................................... 354
Exercise 10.1: Creating a Function to Return a timestamp ....................... 357
Comparing Time ......................................................................................... 358
Duration Calculation ................................................................................. 360
Managing Time ........................................................................................... 363
Exercise 10.2: Duration of Execution ............................................................ 364
Formatting Time ........................................................................................ 365
Exercise 10.03: What Is the Time in Your Zone? .......................................... 368
Activity 10.01: Formatting a Date According to User Requirements ........ 369
Activity 10.02: Enforcing a Specific Format of Date and Time ................... 370
Activity 10.03: Measuring Elapsed Time ....................................................... 371
Activity 10.04: Calculating the Future Date and Time ................................ 372
Activity 10.05: Printing the Local Time in Different Time Zones ............... 372
Summary ..................................................................................................... 373
Chapter 11: Encoding and Decoding (JSON) 375
Introduction ................................................................................................ 376
JSON ............................................................................................................. 376
Decoding JSON ........................................................................................... 380
Struct Tags ....................................................................................................... 382
Exercise 11.01: Unmarshaling Student Courses .......................................... 388
Encoding JSON ............................................................................................ 391
Exercise 11.02: Marshaling Student Courses ............................................... 400
Unknown JSON Structures ............................................................................. 404
Exercise 11.03: Analyzing College Class JSON .............................................. 406
GOB: Go's Own Encoding .......................................................................... 409
Exercise 11.04: Using gob to Encode Data ................................................... 411
Activity 11.01: Mimicking a Customer Order Using JSON .......................... 415
Summary ..................................................................................................... 418
Chapter 12: Files and Systems 421
Introduction ................................................................................................ 422
Filesystem ................................................................................................... 422
File Permissions .............................................................................................. 423
Flags and Arguments ................................................................................. 426
Signals .............................................................................................................. 431
Exercise 12.01: Simulating Cleanup .............................................................. 435
Creating and Writing to Files ................................................................... 438
Reading the Whole File at Once .................................................................... 443
Exercise 12.02: Backing Up Files .................................................................... 450
CSV ............................................................................................................... 455
Activity 12.01: Parsing Bank Transaction Files ............................................ 459
Summary ..................................................................................................... 462
Chapter 13: SQL and Databases 465
Introduction ................................................................................................ 466
The Database .............................................................................................. 466
Database API and Drivers ......................................................................... 468
Connecting to Databases .......................................................................... 469
Creating Tables .......................................................................................... 472
Inserting Data ............................................................................................. 475
Exercise 13.01: Creating a Table with Numbers .......................................... 477
Retrieving Data .......................................................................................... 479
Updating Existing Data .............................................................................. 482
Deleting Data .............................................................................................. 484
Exercise 13.02: Holding Prime Numbers in a Database ............................. 485
Truncating and Deleting Table ................................................................. 488
Activity 13.01: Holding User Data in a Table ................................................ 489
Activity 13.02: Finding Messages of Specific Users ..................................... 490
Summary ..................................................................................................... 491
Chapter 14: Using the Go HTTP Client 493
Introduction ................................................................................................ 494
The Go HTTP Client and Its Uses .............................................................. 494
Sending a Request to a Server ................................................................. 495
Exercise 14.01: Sending a Get Request to a Web Server
Using the Go HTTP Client ............................................................................... 496
Structured Data .......................................................................................... 498
Exercise 14.02: Using the HTTP Client with Structured Data ..................... 499
Activity 14.01: Requesting Data from a Web Server
and Processing the Response ........................................................................ 501
Sending Data to a Server .......................................................................... 502
Exercise 14.03: Sending a Post Request to a Web Server
Using the Go HTTP Client ............................................................................... 503
Uploading Files in a Post Request ................................................................. 505
Exercise 14.04: Uploading a File to a Web Server via a Post Request ....... 506
Custom Request Headers .............................................................................. 509
Exercise 14.05: Using Custom Headers and Options
with the Go HTTP Client ................................................................................. 509
Activity 14.02: Sending Data to a Web Server and Checking
Whether the Data Was Received Using POST and GET .............................. 512
Summary ..................................................................................................... 513
Chapter 15: HTTP Servers 515
Introduction ................................................................................................ 516
How to Build a Basic Server ...................................................................... 516
HTTP Handler ............................................................................................. 517
Exercise 15.01: Creating a Hello World Server ............................................ 518
Simple Routing ........................................................................................... 520
Exercise 15.02: Routing Our Server ............................................................... 520
Handler versus Handler Function ............................................................ 523
Activity 15.01: Adding a Page Counter to an HTML Page ........................... 524
Returning Complex Structures ................................................................. 527
Activity 15.02: Serving a Request with a JSON Payload .............................. 527
Dynamic Content ....................................................................................... 529
Exercise 15.03: Personalized Welcome ......................................................... 530
Templating .................................................................................................. 532
Exercise 15.04: Templating Our Pages ......................................................... 534
Static Resources ......................................................................................... 538
Exercise 15.05: Creating a Hello World Server Using a Static File ............. 539
Getting Some Style .................................................................................... 541
Exercise 15.06: A Stylish Welcome ................................................................ 542
Getting Dynamic ........................................................................................ 546
Activity 15.03: External Template ................................................................. 547
HTTP Methods ............................................................................................ 549
Exercise 15.07: Completing a Questionnaire ............................................... 550
JSON loads .................................................................................................. 554
Exercise 15.08: Building a Server That Accepts JSON Requests ................ 555
Summary ..................................................................................................... 557
Chapter 16: Concurrent Work 559
Introduction ................................................................................................ 560
Goroutines .................................................................................................. 560
Exercise 16.01: Using Concurrent Routines ................................................. 561
WaitGroup ................................................................................................... 564
Exercise 16.02: Experimenting with WaitGroup .......................................... 565
Race Conditions ......................................................................................... 567
Atomic Operations ..................................................................................... 568
Exercise 16.03: An Atomic Change ................................................................ 569
Invisible Concurrency ................................................................................ 574
Activity 16.01: Listing Numbers ..................................................................... 575
Channels ..................................................................................................... 576
Exercise 16.04: Exchange Greeting Messages via Channels ...................... 578
Exercise 16.05: Two-Way Message Exchange with Channels ..................... 580
Exercise 16.06: Sum Numbers from Everywhere ........................................ 581
Exercise 16.07: Request to Goroutines ......................................................... 583
The Importance of Concurrency .............................................................. 585
Exercise 16.08: Equally Splitting the Work between Routines .................. 586
Concurrency Patterns ............................................................................... 589
Activity 16.02: Source Files ............................................................................. 589
Buffers ......................................................................................................... 590
Exercise 16.09: Notifying When Computation Has Finished ...................... 593
Some More Common Practices ..................................................................... 595
HTTP Servers ............................................................................................... 595
Methods as Routines ................................................................................. 596
Exercise 16.10: A Structured Work ................................................................ 596
Go Context Package ................................................................................... 599
Exercise 16.11: Managing Routines with Context ....................................... 600
Summary ..................................................................................................... 602
Chapter 17: Using Go Tools 605
Introduction ................................................................................................ 606
The go build Tool ........................................................................................ 606
Exercise 17.01: Using the go build Tool ........................................................ 606
The go run Tool .......................................................................................... 607
Exercise 17.02: Using the go run Tool ........................................................... 608
The gofmt Tool ........................................................................................... 608
Exercise 17.03: Using the gofmt Tool ............................................................ 609
The goimports Tool .................................................................................... 610
Exercise 17.04: Using the goimports Tool .................................................... 611
The go vet Tool ........................................................................................... 612
Exercise 17.05: Using the go vet Tool ........................................................... 613
The Go Race Detector ................................................................................ 614
Exercise 17.06: Using the Go Race Detector ................................................ 615
The go doc Tool .......................................................................................... 617
Exercise 17.07: Implementing the go doc Tool ............................................ 618
The go get Tool ........................................................................................... 619
Exercise 17.08: Implementing the go get Tool ............................................. 620
Activity 17.01: Using gofmt, goimport, go vet, and go get
to Correct a File ............................................................................................... 621
Summary ..................................................................................................... 623
Chapter 18: Security 625
Introduction ................................................................................................ 626
Application Security ................................................................................... 626
SQL Injection .................................................................................................... 626
Command Injection ........................................................................................ 628
Exercise 18.01: Handling SQL Injection ........................................................ 630
Cross-Site Scripting .................................................................................... 634
Exercise 18.02: Handling XSS Attacks ........................................................... 635
Cryptography .............................................................................................. 638
Hashing Libraries ............................................................................................ 638
Exercise 18.03: Using Different Hashing Libraries ...................................... 639
Encryption ................................................................................................... 641
Symmetric Encryption .................................................................................... 642
Exercise 18.04: Symmetric Encryption and Decryption ............................. 642
Asymmetric Encryption .................................................................................. 644
Exercise 18.05: Asymmetric Encryption and Decryption ........................... 645
Random Generators .................................................................................. 646
Exercise 18.06: Random Generators ............................................................. 647
HTTPS/TLS ................................................................................................... 649
Exercise 18.07: Generating a Certificate and Private Key .......................... 649
Exercise 18.08: Running an HTTPS Server .................................................... 653
Password Management ............................................................................ 656
Activity 18.01: Authenticating Users on the Application
Using Hashed Passwords ............................................................................... 657
Activity 18.02: Creating CA Signed Certificates Using Crypto Libraries .... 658
Summary ..................................................................................................... 659
Chapter 19: Special Features 661
Introduction ................................................................................................ 662
Build Constraints ....................................................................................... 662
Build Tags ......................................................................................................... 663
Filenames ......................................................................................................... 666
Reflection .................................................................................................... 667
TypeOf and ValueOf .................................................................................. 669
Exercise 19.01: Using Reflection .................................................................... 670
Activity 19.01: Defining Build Constraints Using Filenames ...................... 672
DeepEqual ................................................................................................... 673
Wildcard Pattern ........................................................................................ 674
The unsafe Package ................................................................................... 675
Exercise 19.02: Using cgo with unsafe .......................................................... 677
Activity 19.02: Using Wildcard with Go Test ................................................ 678
Summary ..................................................................................................... 679
Appendix 683
Index 785