深入淺出Go語言核心編程

作者：張朝明//李奕鋒//甘海彬|責編:王金柱
出版社：清華大學
ISBN：9787302649106

出版日期：2024/01/01
裝幀：平裝
頁數：516

人民幣：RMB 149 元售價：元

內容大鋼

《深入淺出Go語言核心編程》是一本全面而深入的Go語言學習手冊，涵蓋了Go語言的諸多關鍵特性，包括語法結構、內存原理、併發、上下文機制與框架應用等。本書共20章。第1章引導讀者快速搭建開發環境，詳細介紹Go語言的環境配置及編譯運行的具體細節。第2?5章詳細討論Go語言獨特的變數、常量、常用數據類型和流程式控制制，並重點解析複雜類型的底層實現機制。第6?8章講解Go語言的函數及如何實現面向對象編程，打通Go語言面向過程和面向對象編程之間的橋樑。第9?12章探討Go語言的一些高級話題，包括併發、上下文、反射、泛型等。第13?15章探討Go語言的I/O、網路編程及RPC通信等編程場景。第16?18章是Go語言的擴展話題，涵蓋了內存管理、正則表達式和Go語言的彙編。第19章和第20章重點探討了Go語言在日常開發中的典型應用，主要介紹HTTP框架Gin的使用，以及如何利用Go語言開發一個綜合項目。
《深入淺出Go語言核心編程》內容豐富，由淺入深，力求帶領讀者探究Go語言的本質，既適合初次接觸Go語言的新手，也適合有一定經驗的軟體開發人員閱讀。

作者介紹

張朝明//李奕鋒//甘海彬|責編:王金柱

第1章  第一個Go程序
  1.1  搭建開發環境
  1.2  一個簡單的Go程序
    1.2.1  編寫第一個Go程序
    1.2.2  運行第一個Go程序
  1.3  環境變數說明
  1.4  在IDE中運行Go語言程序
    1.4.1  創建項目
    1.4.2  創建Go程序文件
    1.4.3  運行.go文件
  1.5  Go語言如何實現跨平台
    1.5.1  跨平台的準備工作
    1.5.2  執行跨平台編譯
  1.6  探尋Go語言程序的編譯執行過程
    1.6.1  gobuild命令的選項
    1.6.2  查看編譯的詳細過程
    1.6.3  鏈接環節
  1.7  編程範例——啟動參數的使用
    1.7.1  程序啟動的入口函數
    1.7.2  獲取啟動參數
  1.8  本章小結
第2章  變數與常量
  2.1  變數
    2.1.1  變數聲明
    2.1.2  變數賦值
    2.1.3  同時進行變數聲明和賦值
    2.1.4  多重賦值與「:=」操作符
    2.1.5  沒有多餘的局部變數
    2.1.6  全局變數
    2.1.7  全局變數與鏈接
  2.2  常量
    2.2.1  常量的聲明
    2.2.2  常量塊的使用
    2.2.3  常量可以聲明而不使用
  2.3  iota與枚舉
    2.3.1  iota實現自增
    2.3.2  iota計數不會中斷
    2.3.3  iota的使用場景
  2.4  編程範例——iota的使用技巧
  2.5  本章小結
第3章  簡單數據類型
  3.1  整型
    3.1.1  聲明整型變數
    3.1.2  int和uint的設計初衷
  3.2  浮點型
    3.2.1  聲明浮點型變數
    3.2.2  浮點型會產生精度損失
    3.2.3  Go語言中沒有float關鍵字的原因
    3.2.4  浮點型與類型推導
    3.2.5  浮點型的比較

  3.3  布爾類型
  3.4  字元型
    3.4.1  聲明字元型變數
    3.4.2  轉義字元
  3.5  字元串類型
    3.5.1  聲明字元串變數
    3.5.2  字元串在磁碟中的存儲
    3.5.3  字元串在內存中的存儲
    3.5.4  利用rune類型處理文本
    3.5.5  rune類型與字符集的關係
  3.6  數組類型
    3.6.1  聲明數組變數
    3.6.2  利用索引來訪問數組元素
    3.6.3  數組大小不可變更
    3.6.4  數組作為函數參數
  3.7  編程範例——原義字元的使用
  3.8  本章小結
第4章  複雜數據類型
  4.1  值類型和指針類型
    4.1.1  值類型和指針類型的存儲結構
    4.1.2  為什麼要區分值類型和指針類型
    4.1.3  關於引用類型
  4.2  slice（切片）的使用及實現原理
    4.2.1  切片如何實現大小可變
    4.2.2  切片的聲明和定義
    4.2.3  切片長度的擴展
    4.2.4  切片容量的擴展
    4.2.5  切片參數的複製
    4.2.6  利用數組創建切片
    4.2.7  利用切片創建切片
    4.2.8  切片元素的修改
    4.2.9  切片的循環處理
    4.2.10  切片索引越界
    4.2.11  總結切片操作的底層原理
  4.3  map（映射）的使用及實現原理
    4.3.1  聲明和創建map
    4.3.2  遍歷map中的元素
    4.3.3  元素查找與避免二義性
    4.3.4  刪除元素
    4.3.5  map的存儲結構解析
    4.3.6  map元素的定位原理解析
    4.3.7  map的容量擴展原理解析
  4.4  channel（通道）的使用及實現原理
    4.4.1  channel的使用
    4.4.2  channel的實現原理
    4.4.3  channel與消息隊列、協程通信的對比
  4.5  自定義結構體
    4.5.1  自定義數據類型和自定義結構體
    4.5.2  自定義結構體的使用
    4.5.3  利用new創建實例

    4.5.4  從自定義結構體看訪問許可權控制
    4.5.5  自描述的訪問許可權
  4.6  編程範例——結構體使用實例
    4.6.1  利用自定義結構體實現bitmap
    4.6.2  利用timer.Ticker實現定時任務
  4.7  本章小結
第5章  流程式控制制
  5.1  分支控制
    5.1.1  if語句實現分支控制
    5.1.2  switch語句實現分支控制
    5.1.3  分支控制的本質是向下跳轉
    5.1.4  避免多層if嵌套的技巧
  5.2  循環控制
    5.2.1  for循環
    5.2.2  for-range循環
    5.2.3  循環控制的本質是向上跳轉
    5.2.4  循環和遞歸的區別
  5.3  跳轉控制
    5.3.1  goto關鍵字的使用
    5.3.2  goto的本質是任意跳轉
  5.4  編程範例——流程式控制制的靈活使用
    5.4.1  for循環的誤區
    5.4.2  switch-case的靈活使用
  5.5  本章小結
第6章  函數
  6.1  函數在Go語言中的地位
    6.1.1  Go語言中函數和方法的區別
    6.1.2  重新理解變數聲明中數據類型出現的位置
  6.2  函數的定義
    6.2.1  函數的參數
    6.2.2  函數的返回值
    6.2.3  函數多返回值的實現原理
  6.3  函數的管理——模塊和包
    6.3.1  函數管理形式
    6.3.2  模塊與文件夾
    6.3.3  本地包管理
    6.3.4  模塊名與文件夾名稱
    6.3.5  代碼規範的意義
  6.4  函數的調用和執行
    6.4.1  包的別名與函數調用
    6.4.2  init()函數與隱式執行順序
    6.4.3  利用init()函數執行初始化
    6.4.4  利用匿名包實現函數導入
  6.5  將函數作為變數使用
    6.5.1  將函數賦值給變數
    6.5.2  函數賦值給變數的應用場景
  6.6  匿名函數和閉包
    6.6.1  為什麼需要匿名函數
    6.6.2  閉包
  6.7  函數的強制轉換

    6.7.1  從數據類型的定義到函數類型的定義
    6.7.2  從數據類型的強制轉換到函數類型的強制轉換
    6.7.3  函數類型及強制轉換的意義
    6.7.4  利用強制轉換為函數綁定方法
  6.8  編程範例——閉包的使用
    6.8.1  閉包封裝變數的真正含義
    6.8.2  利用指針修改閉包外部的變數
  6.9  本章小結
第7章  異常處理
  7.1  異常機制的意義
  7.2  Go語言中的異常
    7.2.1  創建異常
    7.2.2  拋出異常
    7.2.3  自定義異常
  7.3  異常捕獲
    7.3.1  利用延遲執行機制來捕獲異常
    7.3.2  在上層調用者中捕獲異常
    7.3.3  異常捕獲的限制條件
  7.4  異常捕獲后的資源清理
    7.4.1  未正常釋放鎖對象帶來的副作用
    7.4.2  確保鎖對象釋放的正確方式
  7.5  編程範例——異常的使用及誤區
    7.5.1  利用結構體自定義異常
    7.5.2  未成功捕獲異常，導致程序崩潰
  7.6  本章小結
第8章  Go語言的面向對象編程
  8.1  面向對象編程的本質
  8.2  Go語言實現封裝
    8.2.1  Go語言中欄位和方法的封裝
    8.2.2  為值類型和指針類型綁定方法的區別
  8.3  Go語言實現繼承
    8.3.1  利用組合實現繼承
    8.3.2  匿名欄位的支持
    8.3.3  多繼承
  8.4  Go語言實現多態
  8.5  面向介面編程
    8.5.1  Go語言中的介面
    8.5.2  Go語言中的介面實現
    8.5.3  利用面向介面編程實現方法多態
  8.6  編程範例——介面的典型應用
    8.6.1  介面嵌套實例
    8.6.2  偽繼承與介面實現
  8.7  本章小結
第9章  併發
  9.1  線程的概念
  9.2  線程模型
  9.3  協程的工作原理
    9.3.1  協程的使用
    9.3.2  GPM模型
    9.3.3  從3種線程模型看GOMAXPROCS參數

  9.4  Go語言中的協程同步
    9.4.1  獨佔鎖——Mutex
    9.4.2  讀寫鎖——RWMutex
    9.4.3  等待組——WaitGroup
  9.5  利用channel實現協程同步
    9.5.1  利用channel實現鎖定
    9.5.2  利用channel實現等待組
    9.5.3  總結使用channel實現併發控制
  9.6  讓出時間片
    9.6.1  time.Sleep()和runtime.Gosched()的本質區別
    9.6.2  runtime.Gosched()與多核CPU
  9.7  Go語言中的單例
    9.7.1  利用sync.Once實現單例
    9.7.2  sync.Once的實現原理
  9.8  編程範例——協程池及協程中斷
    9.8.1  協程池的實現
    9.8.2  協程的中斷執行
  9.9  本章小結
第10章  上下文
  10.1  上下文和普通參數的區別
  10.2  上下文樹
    10.2.1  上下文介面——Context
    10.2.2  利用context.emptyCtx創建樹的根節點
    10.2.3  上下文樹的構建
  10.3  利用valueCtx實現信息透傳
    10.3.1  valueCtx用於參數傳遞
    10.3.2  從父節點獲得透傳值
  10.4  利用cancelCtx通知協程終止執行
    10.4.1  通知子協程終止執行
    10.4.2  通知子協程的實現過程
    10.4.3  為什麼需要取消函數
  10.5  利用timerCtx實現定時取消
    10.5.1  調用context.WithDeadline()創建定時器上下文
    10.5.2  調用context.WithTimeout()創建定時器上下文
  10.6  編程範例——上下文的典型應用場景
    10.6.1  利用結構體傳遞參數
    10.6.2  valueContext為什麼需要key
    10.6.3  利用cancelCtx同時取消多個子協程
  10.7  本章小結
第11章  反射
  11.1  反射的意義
  11.2  反射的API
    11.2.1  利用reflect.TypeOf()來獲得類型信息
    11.2.2  利用reflect.Type.Kind()方法來獲取類型的具體分類
    11.2.3  利用reflect.Type.Element()方法來獲取元素類型
    11.2.4  類型斷言的用法與局限性
  11.3  值信息
    11.3.1  利用reflect.ValueOf()來獲得值信息
    11.3.2  利用reflect.Value.Kind()來獲得值的分類信息
    11.3.3  利用reflect.Value.Elem()來獲得值的元素信息

    11.3.4  利用反射訪問和修改值信息
    11.3.5  利用反射機制動態調用方法
  11.4  編程範例——動態方法調用
  11.5  本章小結
第12章  泛型
  12.1  泛型的意義
  12.2  泛型應用到函數
    12.2.1  泛型函數的使用
    12.2.2  泛型中的隱含信息
    12.2.3  避免類型強制轉換
    12.2.4  泛型類型的單獨定義
  12.3  泛型導致介面定義的變化
    12.3.1  介面定義的變化
    12.3.2  空介面的二義性
    12.3.3  介面類型的限制
  12.4  泛型類型應用到receiver
    12.4.1  泛型類型不能直接用於定義receiver
    12.4.2  間接實現泛型定義receiver
  12.5  編程範例——自定義隊列的實現
  12.6  本章小結
第13章  I/O
  13.1  Reader和Writer
    13.1.1  理解Reader和Writer
    13.1.2  Reader和Writer介面
    13.1.3  Go語言的I/OAPI要解決的問題
    13.1.4  文件讀取
    13.1.5  文件寫入
    13.1.6  文件許可權與umask
    13.1.7  一次性讀寫
  13.2  緩衝區讀寫
    13.2.1  bufio中的Reader和Writer
    13.2.2  利用bufio實現按行讀取
  13.3  字元串數據源
    13.3.1  strings.Reader解析
    13.3.2  位元組掃描器ByteScanner
    13.3.3  按Rune讀取UTF-8字元
  13.4  bufio.Scanner的使用
    13.4.1  掃描過程及源碼解析
    13.4.2  掃描時的最大支持
    13.4.3  掃描時的最小容忍
  13.5  編程範例——文件系統相關操作
    13.5.1  查看文件系統
    13.5.2  臨時文件
  13.6  本章小結
第14章  網路編程
  14.1  網路連接的本質
  14.2  利用TCP實現網路通信
    14.2.1  創建TCP連接
    14.2.2  利用TCP連接進行消息傳遞
  14.3  利用UDP實現網路通信

    14.3.1  監聽模式
    14.3.2  撥號模式
    14.3.3  總結監聽模式和撥號模式
  14.4  HTTP的相關操作
    14.4.1  客戶端發送HTTP請求
    14.4.2  服務端處理HTTP請求
    14.4.3  HTTP請求源碼解析
    14.4.4  提煉思考
  14.5  數據傳輸過程
    14.5.1  本地處理階段
    14.5.2  路由器處理階段
    14.5.3  目標主機處理階段
    14.5.4  網路地址轉換（NAT）所扮演的角色
    14.5.5  總結數據傳輸
  14.6  編程範例——常見網路錯誤的產生及解決方案
    14.6.1  模擬CLOSE_WAIT
    14.6.2  模擬I/Otimeout
    14.6.3  模擬read:connection reset by peer異常
    14.6.4  模擬TIME_WAIT
  14.7  本章小結
第15章  RPC通信
  15.1  如何理解RPC通信
  15.2  Gob格式——利用HTTP和TCP實現RPC通信
    15.2.1  利用HTTP實現RPC通信
    15.2.2  HTTP實現RPC通信的原理
    15.2.3  利用TCP實現RPC通信
    15.2.4  利用HTTP和TCP實現RPC的區別
  15.3  JSON格式——利用jsonrpc實現RPC通信
  15.4  gRPC格式——利用gRPC實現RPC通信
    15.4.1  生成RPC支持文件
    15.4.2  gRPC調用過程
  15.5  編程範例——基於Wireshark理解RPC通信
  15.6  本章小結
第16章  內存管理
  16.1  內存對齊
    16.1.1  內存空隙
    16.1.2  內存對齊和對齊邊界
    16.1.3  結構體的內存對齊
  16.2  內存分級管理
    16.2.1  分級管理的本質
    16.2.2  Go語言內存管理的基本單位——Span
    16.2.3  線程級別維護Span——mcache
    16.2.4  進程級別維護Span——mcentral
    16.2.5  堆級別維護Span——mheap
  16.3  Go語言的垃圾回收
    16.3.1  內存標記——雙色標記法
    16.3.2  內存標記——三色標記法
    16.3.3  三色標記法與寫屏障
    16.3.4  垃圾回收
    16.3.5  垃圾回收的時機

  16.4  編程範例——unsafe包的使用
    16.4.1  利用unsafe修改結構體欄位
    16.4.2  內存地址強制轉換為結構體
    16.4.3  並非所有內存均可修改
  16.5  本章小結
第17章  Go語言中的正則表達式
  17.1  正則表達式基礎
    17.1.1  正則表達式與通配符
    17.1.2  元字元和普通字元
    17.1.3  字元轉義與字元類
    17.1.4  字元組的使用
  17.2  Go語言中的正則表達式
    17.2.1  ASCII字元類
    17.2.2  語言文字字元類
    17.2.3  Unicode編碼方式
  17.3  Go語言中的正則表達式函數
    17.3.1  正則表達式函數
    17.3.2  正則表達式結構體RegExp
  17.4  編程範例——判斷行為序列
  17.5  本章小結
第18章  深入理解Go——Plan9彙編
  18.1  Go彙編簡介
    18.1.1  為什麼需要Go彙編
    18.1.2  彙編文件——.s文件
    18.1.3  .s文件的命名
    18.1.4  .go文件和.s文件的編譯
  18.2  從內存角度看函數的調用過程
    18.2.1  內存布局
    18.2.2  函數執行過程
    18.2.3  棧頂和棧底
    18.2.4  棧內存分配與內存變數讀取
  18.3  寄存器與內存布局
    18.3.1  通用寄存器
    18.3.2  偽寄存器
    18.3.3  自動分配的內存
    18.3.4  區分通用寄存器和偽寄存器
    18.3.5  棧幀的大小由什麼決定
  18.4  第一個Go彙編程序
    18.4.1  利用彙編文件修改變數的值
    18.4.2  跨包引用變數
  18.5  利用Go彙編定義變數
    18.5.1  全局變數和局部變數
    18.5.2  字面量和表達式
    18.5.3  定義字元串型變數
    18.5.4  定義布爾型變數
    18.5.5  定義整型變數
    18.5.6  定義切片變數
    18.5.7  總結變數定義
  18.6  利用Go彙編定義函數
    18.6.1  Go中調用彙編函數

    18.6.2  彙編中調用Go函數
  18.7  Go彙編中的流程式控制制
    18.7.1  Go彙編中的if條件控制
    18.7.2  Go彙編中的for循環
  18.8  重新理解多返回值
  18.9  編程範例——理解常用寄存器
    18.9.1  真、偽寄存器的對比使用
    18.9.2  驗證偽寄存器SP和FP值的差異
  18.10  本章小結
第19章  Gin處理HTTP請求及響應
  19.1  Gin框架簡介
  19.2  Gin框架與HTTP請求
    19.2.1  安裝Gin框架
    19.2.2  利用Gin框架開發第一個HTTP介面程序
  19.3  Gin框架處理參數
    19.3.1  獲得URL查詢參數
    19.3.2  獲得表單參數
    19.3.3  獲得URL路徑參數
    19.3.4  將JSON格式的參數解析為結構體
    19.3.5  將表單參數解析為結構體
    19.3.6  接收和處理上傳文件
  19.4  Gin框架處理響應
    19.4.1  返回JSON格式的響應
    19.4.2  返回XML格式的響應
    19.4.3  返回HTML格式的響應
    19.4.4  文件下載
    19.4.5  自定義響應
  19.5  Gin框架的路由處理
    19.5.1  單個路由
    19.5.2  路由組
    19.5.3  Any方法
    19.5.4  NoRoute和NoMethod方法
  19.6  Gin框架的中間件
    19.6.1  內置中間件
    19.6.2  自定義中間件
  19.7  編程範例——實現登錄認證
  19.8  本章小結
第20章  Go語言實現MVC項目
  20.1  項目背景
    20.1.1  業務背景概述
    20.1.2  技術背景概述
    20.1.3  項目代碼結構
  20.2  利用gorm生成MySQL數據表
    20.2.1  定義結構體及表結構
    20.2.2  從結構體到數據表
  20.3  實現用戶註冊
  20.4  實現用戶登錄
  20.5  實現用戶查詢
  20.6  實現用戶刪除
  20.7  本章小結

同類熱銷排行榜

最近瀏覽的商品

深入淺出Go語言核心編程