深入淺出Go語言核心編程

目    錄

第1章 第一個Go程序 1

1.1  搭建開發環境 1

1.2  一個簡單的Go程序 3

1.2.1  編寫第一個Go程序 3

1.2.2  運行第一個Go程序 5

1.3  環境變量說明 6

1.4  在IDE中運行Go語言程序 7

1.4.1  創建項目 7

1.4.2  創建Go程序文件 8

1.4.3  運行.go文件 9

1.5  Go語言如何實現跨平臺 9

1.5.1  跨平臺的準備工作 9

1.5.2  執行跨平臺編譯 10

1.6  探尋Go語言程序的編譯執行過程 11

1.6.1  go build命令的選項 11

1.6.2  查看編譯的詳細過程 11

1.6.3  鏈接環節 13

1.7  編程範例——啟動參數的使用 14

1.7.1  程序啟動的入口函數 14

1.7.2  獲取啟動參數 15

1.8  本章小結 19

第2章 變量與常量 20

2.1  變量 20

2.1.1  變量聲明 20

2.1.2  變量賦值 21

2.1.3  同時進行變量聲明和賦值 23

2.1.4  多重賦值與“:=”操作符 24

2.1.5  沒有多餘的局部變量 25

2.1.6  全局變量 25

2.1.7  全局變量與鏈接 26

2.2  常量 26

2.2.1  常量的聲明 26

2.2.2  常量塊的使用 27

2.2.3  常量可以聲明而不使用 28

2.3  iota與枚舉 28

2.3.1  iota實現自增 28

2.3.2  iota計數不會中斷 30

2.3.3  iota的使用場景 31

2.4  編程範例——iota的使用技巧 32

2.5  本章小結 34

第3章 簡單數據類型 35

3.1  整型 35

3.1.1  聲明整型變量 35

3.1.2  int和uint的設計初衷 36

3.2  浮點型 37

3.2.1  聲明浮點型變量 37

3.2.2  浮點型會產生精度損失 37

3.2.3  Go語言中沒有float關鍵字的原因 38

3.2.4  浮點型與類型推導 38

3.2.5  浮點型的比較 39

3.3  布爾類型 40

3.4  字符型 40

3.4.1  聲明字符型變量 41

3.4.2  轉義字符 42

3.5  字符串類型 43

3.5.1  聲明字符串變量 43

3.5.2  字符串在磁盤中的存儲 43

3.5.3  字符串在內存中的存儲 44

3.5.4  利用rune類型處理文本 45

3.5.5  rune類型與字符集的關系 46

3.6  數組類型 46

3.6.1  聲明數組變量 47

3.6.2  利用索引來訪問數組元素 47

3.6.3  數組大小不可變更 48

3.6.4  數組作為函數參數 48

3.7  編程範例——原義字符的使用 49

3.8  本章小結 50

第4章 復雜數據類型 51

4.1  值類型和指針類型 51

4.1.1  值類型和指針類型的存儲結構 51

4.1.2  為什麽要區分值類型和指針類型 53

4.1.3  關於引用類型 54

4.2  slice（切片）的使用及實現原理 54

4.2.1  切片如何實現大小可變 54

4.2.2  切片的聲明和定義 55

4.2.3  切片長度的擴展 56

4.2.4  切片容量的擴展 57

4.2.5  切片參數的復制 58

4.2.6  利用數組創建切片 60

4.2.7  利用切片創建切片 62

4.2.8  切片元素的修改 62

4.2.9  切片的循環處理 63

4.2.10  切片索引越界 63

4.2.11  總結切片操作的底層原理 64

4.3  map（映射）的使用及實現原理 65

4.3.1  聲明和創建map 65

4.3.2  遍歷map中的元素 65

4.3.3  元素查找與避免二義性 66

4.3.4  刪除元素 67

4.3.5  map的存儲結構解析 68

4.3.6  map元素的定位原理解析 70

4.3.7  map的容量擴展原理解析 72

4.4  channel（通道）的使用及實現原理 72

4.4.1  channel的使用 72

4.4.2  channel的實現原理 74

4.4.3  channel與消息隊列、協程通信的對比 76

4.5  自定義結構體 76

4.5.1  自定義數據類型和自定義結構體 76

4.5.2  自定義結構體的使用 77

4.5.3  利用new創建實例 78

4.5.4  從自定義結構體看訪問權限控制 79

4.5.5  自描述的訪問權限 80

4.6  編程範例——結構體使用實例 80

4.6.1  利用自定義結構體實現bitmap 80

4.6.2  利用timer.Ticker實現定時任務 84

4.7  本章小結 87

第5章 流程控制 88

5.1  分支控制 88

5.1.1  if語句實現分支控制 88

5.1.2  switch語句實現分支控制 89

5.1.3  分支控制的本質是向下跳轉 90

5.1.4  避免多層if嵌套的技巧 91

5.2  循環控制 94

5.2.1  for循環 94

5.2.2  for-range循環 95

5.2.3  循環控制的本質是向上跳轉 97

5.2.4  循環和遞歸的區別 98

5.3  跳轉控制 99

5.3.1  goto關鍵字的使用 99

5.3.2  goto的本質是任意跳轉 101

5.4  編程範例——流程控制的靈活使用 101

5.4.1  for循環的誤區 101

5.4.2  switch-case的靈活使用 104

5.5  本章小結 106

第6章 函數 107

6.1  函數在Go語言中的地位 107

6.1.1  Go語言中函數和方法的區別 108

6.1.2  重新理解變量聲明中數據類型出現的位置 109

6.2  函數的定義 110

6.2.1  函數的參數 110

6.2.2  函數的返回值 111

6.2.3  函數多返回值的實現原理 113

6.3  函數的管理——模塊和包 115

6.3.1  函數管理形式 115

6.3.2  模塊與文件夾 116

6.3.3  本地包管理 119

6.3.4  模塊名與文件夾名稱 121

6.3.5  代碼規範的意義 123

6.4  函數的調用和執行 123

6.4.1  包的別名與函數調用 123

6.4.2  init()函數與隱式執行順序 125

6.4.3  利用init()函數執行初始化 126

6.4.4  利用匿名包實現函數導入 127

6.5  將函數作為變量使用 128

6.5.1  將函數賦值給變量 128

6.5.2  函數賦值給變量的應用場景 129

6.6  匿名函數和閉包 132

6.6.1  為什麽需要匿名函數 132

6.6.2  閉包 134

6.7  函數的強制轉換 137

6.7.1  從數據類型的定義到函數類型的定義 137

6.7.2  從數據類型的強制轉換到函數類型的強制轉換 138

6.7.3  函數類型及強制轉換的意義 138

6.7.4  利用強制轉換為函數綁定方法 140

6.8  編程範例——閉包的使用 142

6.8.1  閉包封裝變量的真正含義 142

6.8.2  利用指針修改閉包外部的變量 145

6.9  本章小結 146

第7章 異常處理 147

7.1  異常機制的意義 147

7.2  Go語言中的異常 150

7.2.1  創建異常 150

7.2.2  拋出異常 151

7.2.3  自定義異常 152

7.3  異常捕獲 154

7.3.1  利用延遲執行機制來捕獲異常 155

7.3.2  在上層調用者中捕獲異常 157

7.3.3  異常捕獲的限制條件 158

7.4  異常捕獲後的資源清理 159

7.4.1  未正常釋放鎖對象帶來的副作用 160

7.4.2  確保鎖對象釋放的正確方式 162

7.5  編程範例——異常的使用及誤區 163

7.5.1  利用結構體自定義異常 163

7.5.2  未成功捕獲異常，導致程序崩潰 164

7.6  本章小結 166

第8章 Go語言的面向對象編程 167

8.1  面向對象編程的本質 167

8.2  Go語言實現封裝 168

8.2.1  Go語言中字段和方法的封裝 168

8.2.2  為值類型和指針類型綁定方法的區別 169

8.3  Go語言實現繼承 171

8.3.1  利用組合實現繼承 171

8.3.2  匿名字段的支持 173

8.3.3  多繼承 174

8.4  Go語言實現多態 176

8.5  面向接口編程 178

8.5.1  Go語言中的接口 179

8.5.2  Go語言中的接口實現 179

8.5.3  利用面向接口編程實現方法多態 180

8.6  編程範例——接口的典型應用 181

8.6.1  接口嵌套實例 181

8.6.2  偽繼承與接口實現 183

8.7  本章小結 184

第9章 並發 185

9.1  線程的概念 185

9.2  線程模型 187

9.3  協程的工作原理 187

9.3.1  協程的使用 188

9.3.2  GPM模型 189

9.3.3  從3種線程模型看GOMAXPROCS參數 191

9.4  Go語言中的協程同步 192

9.4.1  獨占鎖——Mutex 192

9.4.2  讀寫鎖——RWMutex 195

9.4.3  等待組——WaitGroup 198

9.5  利用channel實現協程同步 199

9.5.1  利用channel實現鎖定 200

9.5.2  利用channel實現等待組 202

9.5.3  總結使用channel實現並發控制 204

9.6  讓出時間片 204

9.6.1  time.Sleep()和runtime.Gosched()的本質區別 204

9.6.2  runtime.Gosched()與多核CPU 205

9.7  Go語言中的單例 206

9.7.1  利用sync.Once實現單例 206

9.7.2  sync.Once的實現原理 208

9.8  編程範例——協程池及協程中斷 209

9.8.1  協程池的實現 209

9.8.2  協程的中斷執行 213

9.9  本章小結 217

第10章 上下文 218

10.1  上下文和普通參數的區別 218

10.2  上下文樹 219

10.2.1  上下文接口——Context 219

10.2.2  利用context.emptyCtx創建樹的根節點 219

10.2.3  上下文樹的構建 220

10.3  利用valueCtx實現信息透傳 222

10.3.1  valueCtx用於參數傳遞 222

10.3.2  從父節點獲得透傳值 223

10.4  利用cancelCtx通知協程終止執行 224

10.4.1  通知子協程終止執行 225

10.4.2  通知子協程的實現過程 226

10.4.3  為什麽需要取消函數 230

10.5  利用timerCtx實現定時取消 230

10.5.1  調用context.WithDeadline()創建定時器上下文 231

10.5.2  調用context.WithTimeout()創建定時器上下文 233

10.6  編程範例——上下文的典型應用場景 234

10.6.1  利用結構體傳遞參數 234

10.6.2  valueContext為什麽需要key 236

10.6.3  利用cancelCtx同時取消多個子協程 237

10.7  本章小結 239

第11章  反射 240

11.1  反射的意義 240

11.2  反射的API 241

11.2.1  利用reflect.TypeOf()來獲得類型信息 241

11.2.2  利用reflect.Type.Kind()方法來獲取類型的具體分類 242

11.2.3  利用reflect.Type.Element()方法來獲取元素類型 243

11.2.4  類型斷言的用法與局限性 245

11.3  值信息 246

11.3.1  利用reflect.ValueOf()來獲得值信息 246

11.3.2  利用reflect.Value.Kind()來獲得值的分類信息 247

11.3.3  利用reflect.Value.Elem()來獲得值的元素信息 248

11.3.4  利用反射訪問和修改值信息 249

11.3.5  利用反射機制動態調用方法 252

11.4  編程範例——動態方法調用 255

11.5  本章小結 258

第12章  泛型 259

12.1  泛型的意義 259

12.2  泛型應用到函數 261

12.2.1  泛型函數的使用 261

12.2.2  泛型中的隱含信息 262

12.2.3  避免類型強制轉換 263

12.2.4  泛型類型的單獨定義 264

12.3  泛型導致接口定義的變化 265

12.3.1  接口定義的變化 265

12.3.2  空接口的二義性 266

12.3.3  接口類型的限制 266

12.4  泛型類型應用到receiver 268

12.4.1  泛型類型不能直接用於定義receiver 268

12.4.2  間接實現泛型定義receiver 269

12.5  編程範例——自定義隊列的實現 270

12.6  本章小結 272

第13章  I/O 273

13.1  Reader和Writer 273

13.1.1  理解Reader和Writer 273

13.1.2  Reader和Writer接口 274

13.1.3  Go語言的I/O API要解決的問題 275

13.1.4  文件讀取 275

13.1.5  文件寫入 278

13.1.6  文件權限與umask 281

13.1.7  一次性讀寫 283

13.2  緩沖區讀寫 284

13.2.1  bufio中的Reader和Writer 285

13.2.2  利用bufio實現按行讀取 285

13.3  字符串數據源 287

13.3.1  strings.Reader解析 287

13.3.2  字節掃描器ByteScanner 288

13.3.3  按Rune讀取UTF-8字符 289

13.4  bufio.Scanner的使用 292

13.4.1  掃描過程及源碼解析 292

13.4.2  掃描時的最大支持 298

13.4.3  掃描時的最小容忍 301

13.5  編程範例——文件系統相關操作 303

13.5.1  查看文件系統 303

13.5.2  臨時文件 305

13.6  本章小結 307

第14章  網絡編程 308

14.1  網絡連接的本質 308

14.2  利用TCP實現網絡通信 310

14.2.1  創建TCP連接 310

14.2.2  利用TCP連接進行消息傳遞 312

14.3  利用UDP實現網絡通信 315

14.3.1  監聽模式 316

14.3.2  撥號模式 319

14.3.3  總結監聽模式和撥號模式 322

14.4  HTTP的相關操作 322

14.4.1  客戶端發送HTTP請求 322

14.4.2  服務端處理HTTP請求 326

14.4.3  HTTP請求源碼解析 328

14.4.4  提煉思考 333

14.5  數據傳輸過程 334

14.5.1  本地處理階段 334

14.5.2  路由器處理階段 335

14.5.3  目標主機處理階段 335

14.5.4  網絡地址轉換（NAT）所扮演的角色 335

14.5.5  總結數據傳輸 336

14.6  編程範例——常見網絡錯誤的產生及解決方案 336

14.6.1  模擬CLOSE_WAIT 336

14.6.2  模擬I/O timeout 341

14.6.3  模擬read: connection reset by peer異常 344

14.6.4  模擬TIME_WAIT 347

14.7  本章小結 351

第15章  RPC通信 352

15.1  如何理解RPC通信 352

15.2  Gob格式——利用HTTP和TCP實現RPC通信 354

15.2.1  利用HTTP實現RPC通信 354

15.2.2  HTTP實現RPC通信的原理 358

15.2.3  利用TCP實現RPC通信 370

15.2.4  利用HTTP和TCP實現RPC的區別 373

15.3  JSON格式——利用jsonrpc實現RPC通信 374

15.4  gRPC格式——利用gRPC實現RPC通信 376

15.4.1  生成RPC支持文件 377

15.4.2  gRPC調用過程 381

15.5  編程範例——基於Wireshark理解RPC通信 385

15.6  本章小結 389

第 16 章  內存管理 390

16.1  內存對齊 390

16.1.1  內存空隙 390

16.1.2  內存對齊和對齊邊界 391

16.1.3  結構體的內存對齊 393

16.2  內存分級管理 395

16.2.1  分級管理的本質 395

16.2.2  Go語言內存管理的基本單位——Span 396

16.2.3  線程級別維護Span——mcache 398

16.2.4  進程級別維護Span——mcentral 398

16.2.5  堆級別維護Span——mheap 399

16.3  Go語言的垃圾回收 400

16.3.1  內存標記——雙色標記法 400

16.3.2  內存標記——三色標記法 403

16.3.3  三色標記法與寫屏障 405

16.3.4  垃圾回收 406

16.3.5  垃圾回收的時機 407

16.4  編程範例——unsafe包的使用 408

16.4.1  利用unsafe修改結構體字段 409

16.4.2  內存地址強制轉換為結構體 411

16.4.3  並非所有內存均可修改 412

16.5  本章小結 415

第 17 章  Go語言中的正則表達式 416

17.1  正則表達式基礎 416

17.1.1  正則表達式與通配符 416

17.1.2  元字符和普通字符 417

17.1.3  字符轉義與字符類 417

17.1.4  字符組的使用 418

17.2  Go語言中的正則表達式 418

17.2.1  ASCII字符類 418

17.2.2  語言文字字符類 419

17.2.3  Unicode編碼方式 420

17.3  Go語言中的正則表達式函數 421

17.3.1  正則表達式函數 421

17.3.2  正則表達式結構體RegExp 423

17.4  編程範例——判斷行為序列 429

17.5  本章小結 430

第 18 章  深入理解Go——Plan 9匯編 431

18.1  Go匯編簡介 432

18.1.1  為什麽需要Go匯編 432

18.1.2  匯編文件——.s文件 432

18.1.3  .s文件的命名 432

18.1.4  .go文件和.s文件的編譯 433

18.2  從內存角度看函數的調用過程 434

18.2.1  內存佈局 434

18.2.2  函數執行過程 435

18.2.3  棧頂和棧底 437

18.2.4  棧內存分配與內存變量讀取 437

18.3  寄存器與內存佈局 439

18.3.1  通用寄存器 439

18.3.2  偽寄存器 439

18.3.3  自動分配的內存 444

18.3.4  區分通用寄存器和偽寄存器 444

18.3.5  棧幀的大小由什麽決定 444

18.4  第一個Go匯編程序 445

18.4.1  利用匯編文件修改變量的值 445

18.4.2  跨包引用變量 448

18.5  利用Go匯編定義變量 449

18.5.1  全局變量和局部變量 449

18.5.2  字面量和表達式 449

18.5.3  定義字符串型變量 450

18.5.4  定義布爾型變量 453

18.5.5  定義整型變量 454

18.5.6  定義切片變量 455

18.5.7  總結變量定義 457

18.6  利用Go匯編定義函數 457

18.6.1  Go中調用匯編函數 457

18.6.2  匯編中調用Go函數 459

18.7  Go匯編中的流程控制 462

18.7.1  Go匯編中的if條件控制 462

18.7.2  Go匯編中的for循環 464

18.8  重新理解多返回值 467

18.9  編程範例——理解常用寄存器 467

18.9.1  真、偽寄存器的對比使用 467

18.9.2  驗證偽寄存器SP和FP值的差異 469

18.10  本章小結 471

第19章  Gin處理HTTP請求及響應 472

19.1  Gin框架簡介 472

19.2  Gin框架與HTTP請求 473

19.2.1  安裝Gin框架 473

19.2.2  利用Gin框架開發第一個HTTP接口程序 473

19.3  Gin框架處理參數 475

19.3.1  獲得URL查詢參數 475

19.3.2  獲得表單參數 476

19.3.3  獲得URL路徑參數 477

19.3.4  將JSON格式的參數解析為結構體 478

19.3.5  將表單參數解析為結構體 479

19.3.6  接收和處理上傳文件 480

19.4  Gin框架處理響應 481

19.4.1  返回JSON格式的響應 481

19.4.2  返回XML格式的響應 483

19.4.3  返回HTML格式的響應 484

19.4.4  文件下載 486

19.4.5  自定義響應 487

19.5  Gin框架的路由處理 489

19.5.1  單個路由 489

19.5.2  路由組 489

19.5.3  Any方法 491

19.5.4  NoRoute和NoMethod方法 491

19.6  Gin框架的中間件 492

19.6.1  內置中間件 492

19.6.2  自定義中間件 494

19.7  編程範例——實現登錄認證 496

19.8  本章小結 499

第20章  Go語言實現MVC項目 500

20.1  項目背景 500

20.1.1  業務背景概述 500

20.1.2  技術背景概述 501

20.1.3  項目代碼結構 502

20.2  利用gorm生成MySQL數據表 502

20.2.1  定義結構體及表結構 502

20.2.2  從結構體到數據表 503

20.3  實現用戶註冊 506

20.4  實現用戶登錄 510

20.5  實現用戶查詢 512

20.6  實現用戶刪除 514

20.7  本章小結 516