Go 语言圣经 中文版

			目錄
介紹					0
前言			1
	Go語言起源		1.1
	Go語言項目		1.2
	本書的組織		1.3
	更多的信息			1.4
	致謝		1.5
入門			2
	Hello, World		2.1
	命令行參數		2.2
	査找重複的行			2.3
	GIF動畵		2.4
	獲取URL		2.5
	併發獲取多個URL		2.6
	Web服務		2.7
	本章要點			2.8
程序結構			3
	命名		3.1
	聲明		3.2
	變量		3.3
	賦值		3.4
	類型			3.5
	包和文件		3.6
	作用域		3.7
基礎數據類型			4
	整型		4.1
	浮點數			4.2
	複數		4.3
	布爾型		4.4
	字符串		4.5

2

Go 语言圣经 中文版

		常量			4.6
複合數據類型				5
		數組		5.1
		Slice		5.2
		Map		5.3
		結構體			5.4
		JSON		5.5
		文本和HTML模闆		5.6
函數				6
		函數聲明		6.1
		遞歸			6.2
		多返迴值			6.3
		錯誤		6.4
		函數值		6.5
		匿名函數		6.6
		可變參數		6.7
		Deferred函數			6.8
		Panic異常		6.9
		Recover捕獲異常		6.10
				7
方法
		方法聲明		7.1
		基於指針對象的方法			7.2
		通過嵌入結構體來擴展類型		7.3
		方法值和方法表達式		7.4
		示例: Bit數組		7.5
		封裝		7.6
接口				8
		接口是合約		8.1
		接口類型		8.2
		實現接口的條件		8.3
		flag.Value接口		8.4
		接口值			8.5
		sort.Interface接口		8.6
		http.Handler接口		8.7

3

Go 语言圣经 中文版

	error接口			8.8
	示例: 表達式求值	8.9
	類型斷言	8.10
		8.11
	基於類型斷言識别錯誤類型
	通過類型斷言査詢接口	8.12
	類型分支	8.13
	示例: 基於標記的XML解碼	8.14
		8.15
	補充幾點
Goroutines和Channels		9
	Goroutines			9.1
	示例: 併發的Clock服務			9.2
	示例: 併發的Echo服務	9.3
	Channels	9.4
	併發的循環	9.5
	示例: 併發的Web爬蟲	9.6
	基於select的多路複用			9.7
	示例: 併發的字典遍歷	9.8
	併發的退出	9.9
	示例: 聊天服務	9.10
		10
基於共享變量的併發
	競爭條件	10.1
	sync.Mutex互斥鎖	10.2
	sync.RWMutex讀寫鎖	10.3
		10.4
	內存同步
	sync.Once初始化	10.5
		10.6
	競爭條件檢測
	示例: 併發的非阻塞緩存	10.7
	Goroutines和線程	10.8
		11
包和工具
	包簡介	11.1
	導入路徑		11.2
	包聲明	11.3
	導入聲明	11.4

4

Go 语言圣经 中文版

	包的匿名導入		11.5
	包和命名		11.6
			11.7
	工具
			12
測試
	go test		12.1
			12.2
	測試函數
	測試覆蓋率		12.3
			12.4
	基準測試
			12.5
	剖析
			12.6
	示例函數
				13
反射
	爲何需要反射?		13.1
	reflect.Type和reflect.Value		13.2
	Display遞歸打印		13.3
	示例: 編碼S表達式		13.4
	通過reflect.Value脩改值		13.5
	示例: 解碼S表達式		13.6
	獲取結構體字段標識		13.7
			13.8
	顯示一個類型的方法集
			13.9
	幾點忠告
			14
底層編程
	unsafe.Sizeof, Alignof 和 Offsetof		14.1
	unsafe.Pointer		14.2
	示例: 深度相等判斷		14.3
	通過cgo調用C代碼		14.4
			14.5
	幾點忠告
				15
附録

5

Go 语言圣经 中文版

Go語言聖經（中文版）

Go語言聖經 《The Go Programming Language》 中文版本，僅供學習交流之用。

項目主頁：http://github.com/golang-china/gopl-zh

項目進度：http://github.com/golang-china/gopl-zh/blob/master/progress.md

參與人員：http://github.com/golang-china/gopl-zh/blob/master/CONTRIBUTORS.md

離線版本：http://github.com/golang-china/gopl-zh/archive/gh-pages.zip

在線預覽：http://golang-china.github.io/gopl-zh

原版官網：http://gopl.io

從源文件構建

先安裝NodeJS和GitBook命令行工具( npm install gitbook-cli -g 命令)。

1.下載 https://github.com/golang-china/gopl-zh/archive/master.zip ，獲取源文件。

2.切換到 gopl-zh 目録，運行 gitbook install ，安裝GitBook插件。

3.運行 gitbook build ，生成 _book 目録。

介紹

6

Go 语言圣经 中文版

4.打開 _book/index.html 文件。

簡體/繁體轉換

切片到 gopl-zh 目録：

make zh2tw 或 go run zh2tw.go . "\.md$" zh2tw ，轉繁體。 make tw2zh 或 go run zh2tw.go . "\.md$" tw2zh ，轉簡體。

Markdown 格式預覽

SUMMARY-github.md

版權聲明

Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License。

嚴禁任何商業行爲使用或引用該文檔的全部或部分內容！

歡迎大家提供建議！

介紹

7

Go 语言圣经 中文版

譯者序

在上個世紀70年代，貝爾實驗室的Ken Thompson和Dennis M. Ritchie合作發明了UNIX操作 繫統，同時Dennis M. Ritchie爲了解決UNIX繫統的移植性問題而發明了C語言，貝爾實驗室 的UNIX和C語言兩大發明奠定了整個現代IT行業最重要的軟件基礎（目前的三大桌面操作繫 統的中Linux和Mac OS X都是源於UINX繫統，兩大移動平台的操作繫統iOS和Android也都是 源於UNIX繫統。C繫家族的編程語言占據統治地位達幾十年之久）。在UINX和C語言發明40 年之後，目前已經在Google工作的Ken Thompson和Rob Pike（他們在貝爾實驗室時就是同 事）、還有Robert Griesemer（設計了V8引擎和HotSpot虛擬機）一起合作，爲了解決在21世 紀多核和網絡化環境下越來越複雜的編程問題而發明了Go語言。從Go語言庫早期代碼庫日誌

可以看出它的演化歷程（Git用 git log --before={2008-03-03} --reverse 命令査看）：

從早期提交日誌中也可以看出，Go語言是從Ken Thompson發明的B語言、Dennis M. Ritchie 發明的C語言逐步演化過來的，是C語言家族的成員，因此很多人將Go語言稱爲21世紀的C語 言。縱觀這幾年來的發展趨勢，Go語言已經成爲雲計算、雲存儲時代最重要的基礎編程語 言。

在C語言發明之後約5年的時間之後（1978年），Brian W. Kernighan和Dennis M. Ritchie合作 編寫出版了C語言方面的經典敎材《The C Programming Language》，該書被譽爲C語言程 序員的聖經，作者也被大家親切地稱爲K&R。同樣在Go語言正式發布（2009年）約5年之後 （2014年開始寫作，2015年出版），由Go語言核心糰隊成員Alan A. A. Donovan和K&R中的 Brian W. Kernighan合作編寫了Go語言方面的經典敎材《The Go Programming

前言

8

Go 语言圣经 中文版

Language》。Go語言被譽爲21世紀的C語言，如果説K&R所著的是聖經的舊約，那麽D&K所 著的必將成爲聖經的新約。該書介紹了Go語言幾乎全部特性，併且隨着語言的深入層層遞 進，對每個細節都解讀得非常細致，每一節內容都精綵不容錯過，是廣大Gopher的必讀書 目。同時，大部分Go語言核心糰隊的成員都參與了該書校對工作，因此該書的質量是可以完 全放心的。

同時，單憑閲讀和學習其語法結構併不能眞正地掌握一門編程語言，必鬚進行足夠多的編程 實踐——親自編寫一些程序併研究學習别人寫的程序。要從利用Go語言良好的特性使得程序 模塊化，充分利用Go的標準函數庫以Go語言自己的風格來編寫程序。書中包含了上百個精心 挑選的習題，希望大家能先用自己的方式嚐試完成習題，然後再參考官方給出的解決方案。

該書英文版約從2015年10月開始公開發售，同時同步發售的還有日文版本。不過比較可惜的 是，中文版併沒有在同步發售之列，甚至連中文版是否會引進、是由哪個出版社引進、卽使 引進將由何人來翻譯、何時能出版都成了一個祕密。中国的Go語言社區是全球最大的Go語言 社區，我們從一開始就始終緊跟着Go語言的發展腳步。我們應該也完全有能力以中国Go語言 社區的力量同步完成Go語言聖經中文版的翻譯工作。與此同時，国內有很多Go語言愛好者也 在積極關註該書（本人也在第一時間購買了紙質版本，亞馬遜價格314人民幣）。爲了Go語 言的學習和交流，大家決定合作免費翻譯該書。

翻譯工作從2015年11月20日前後開始，到2016年1月底初步完成，前後歷時約2個月時間。其 中，chai2010翻譯了前言、第2~4章、第10~13章，Xargin翻譯了第1章、第6章、第8~9

章，CrazySssst翻譯了第5章，foreversmart翻譯了第7章，大家共同參與了基本的校驗工作， 還有其他一些朋友提供了積極的反饋建議。如果大家還有任何問題或建議，可以直接到中文 版項目頁面提交Issue，如果發現英文版原文在勘誤中未提到的任何錯誤，可以直接去英文版 項目提交。

最後，希望這本書能夠幫助大家用Go語言快樂地編程。

2016年 1月 於 武漢

前言

“Go是一個開源的編程語言，它很容易用於構建簡單、可靠和高效的軟件。”（摘自Go語言官 方網站：http://golang.org ）

Go語言由來自Google公司的Robert Griesemer，Rob Pike和Ken Thompson三位大牛於2007 年9月開始設計和實現，然後於2009年的11月對外正式發布（譯註：關於Go語言的創世紀過 程請參考 http://talks.golang.org/2015/how-go-was-made.slide ）。語言及其配套工具的設計 目標是具有表達力，高效的編譯和執行效率，有效地編寫高效和健壯的程序。

前言

9

Go 语言圣经 中文版

Go語言有着和C語言類似的語法外表，和C語言一樣是專業程序員的必備工具，可以用最小的 代價獲得最大的戰果。 但是它不僅僅是一個更新的C語言。它還從其他語言借鑒了很多好的 想法，同時避免引入過度的複雜性。 Go語言中和併發編程相關的特性是全新的也是有效的， 同時對數據抽象和面向對象編程的支持也很靈活。 Go語言同時還集成了自動垃圾收集技術用 於更好地管理內存。

Go語言尤其適合編寫網絡服務相關基礎設施，同時也適合開發一些工具軟件和繫統軟件。 但 是Go語言確實是一個通用的編程語言，它也可以用在圖形圖像驅動編程、移動應用程序開發 和機器學習等諸多領域。目前Go語言已經成爲受歡迎的作爲無類型的腳本語言的替代者： 因 爲Go編寫的程序通常比腳本語言運行的更快也更安全，而且很少會發生意外的類型錯誤。

Go語言還是一個開源的項目，可以免費獲編譯器、庫、配套工具的源代碼。 Go語言的貢獻 者來自一個活躍的全球社區。Go語言可以運行在類UNIX繫統—— 比如 Linux、FreeBSD、OpenBSD、Mac OSX——和Plan9繫統和Microsoft Windows操作繫統之 上。 Go語言編寫的程序無需脩改就可以運行在上面這些環境。

本書是爲了幫助你開始以有效的方式使用Go語言，充分利用語言本身的特性和自帶的標準庫 去編寫清晰地道的Go程序。

前言

10

Go 语言圣经 中文版

Go語言起源

編程語言的演化就像生物物種的演化類似，一個成功的編程語言的後代一般都會繼承它們祖 先的優點；當然有時多種語言雜合也可能會産生令人驚訝的特性；還有一些激進的新特性可 能併沒有先例。我們可以通過觀察編程語言和軟硬件環境是如何相互促進、相互影響的演化 過程而學到很多。

下圖展示了有哪些早期的編程語言對Go語言的設計産生了重要影響。

Go語言有時候被描述爲“C類似語言”，或者是“21世紀的C語言”。Go從C語言繼承了相似的表 達式語法、控製流結構、基礎數據類型、調用參數傳值、指針等很多思想，還有C語言一直所 看中的編譯後機器碼的運行效率以及和現有操作繫統的無縫適配。

但是在Go語言的家族樹中還有其它的祖先。其中一個有影響力的分支來自Niklaus Wirth所設 計的Pascal)語言。然後Modula-2語言激發了包的概念。然後Oberon)語言摒棄了模塊接口文 件和模塊實現文件之間的區别。第二代的Oberon-2)語言直接影響了包的導入和聲明的語法，

Go語言起源

11

Go 语言圣经 中文版

還有Oberon)語言的面向對象特性所提供的方法的聲明語法等。

Go語言的另一支祖先，帶來了Go語言區别其他語言的重要特性，靈感來自於貝爾實驗室的 Tony Hoare於1978年發表的鮮爲外界所知的關於併發研究的基礎文獻 順序通信進程 （ communicating sequential processes ，縮寫爲CSP）。在CSP中，程序是一組中間沒有共享 狀態的平行運行的處理過程，它們之間使用管道進行通信和控製同步。不過Tony Hoare的 CSP隻是一個用於描述併發性基本概念的描述語言，併不是一個可以編寫可執行程序的通用 編程語言。

接下來，Rob Pike和其他人開始不斷嚐試將CSP引入實際的編程語言中。他們第一次嚐試引 入CSP特性的編程語言叫Squeak（老鼠間交流的語言），是一個提供鼠標和鍵盤事件處理的 編程語言，它的管道是靜態創建的。然後是改進版的Newsqueak語言，提供了類似C語言語 句和表達式的語法和類似Pascal)語言的推導語法。Newsqueak是一個帶垃圾迴收的純函數式 語言，它再次針對鍵盤、鼠標和窗口事件管理。但是在Newsqueak語言中管道是動態創建 的，屬於第一類值, 可以保存到變量中。

在Plan9操作繫統中，這些優秀的想法被吸收到了一個叫Alef的編程語言中。Alef試圖將 Newsqueak語言改造爲繫統編程語言，但是因爲缺少垃圾迴收機製而導致併發編程很痛苦。 （譯註：在Aelf之後還有一個叫Limbo的編程語言，Go語言從其中借鑒了很多特性。 具體請 參考Pike的講稿：http://talks.golang.org/2012/concurrency.slide#9 ）

Go語言的其他的一些特性零散地來自於其他一些編程語言；比如iota語法是從APL)語言借 鑒，詞法作用域與嵌套函數來自於Scheme)語言（和其他很多語言）。當然，我們也可以從 Go中發現很多創新的設計。比如Go語言的切片爲動態數組提供了有效的隨機存取的性能，這 可能會讓人聯想到鏈表的底層的共享機製。還有Go語言新發明的defer語句。

Go語言起源

12

Go 语言圣经 中文版

Go語言項目

所有的編程語言都反映了語言設計者對編程哲學的反思，通常包括之前的語言所暴露的一些 不足地方的改進。Go項目是在Google公司維護超級複雜的幾個軟件繫統遇到的一些問題的反 思（但是這類問題絶不是Google公司所特有的）。

正如Rob Pike所説，“軟件的複雜性是乘法級相關的”，通過增加一個部分的複雜性來脩複問題 通常將慢慢地增加其他部分的複雜性。通過增加功能和選項和配置是脩複問題的最快的途 徑，但是這很容易讓人忘記簡潔的內涵，卽使從長遠來看，簡潔依然是好軟件的關鍵因素。

簡潔的設計需要在工作開始的時候舍棄不必要的想法，併且在軟件的生命週期內嚴格區别好 的改變或壞的改變。通過足夠的努力，一個好的改變可以在不破壞原有完整概念的前提下保 持自適應，正如Fred Brooks所説的“概念完整性”；而一個壞的改變則不能達到這個效果，它 們僅僅是通過膚淺的和簡單的妥協來破壞原有設計的一致性。隻有通過簡潔的設計，才能讓 一個繫統保持穩定、安全和持續的進化。

Go項目包括編程語言本身，附帶了相關的工具和標準庫，最後但併非代表不重要的，關於簡 潔編程哲學的宣言。就事後諸葛的角度來看，Go語言的這些地方都做的還不錯：擁有自動垃 圾迴收、一個包繫統、函數作爲一等公民、詞法作用域、繫統調用接口、隻讀的UTF8字符串 等。但是Go語言本身隻有很少的特性，也不太可能添加太多的特性。例如，它沒有隱式的數 值轉換，沒有構造函數和析構函數，沒有運算符重載，沒有默認參數，也沒有繼承，沒有泛 型，沒有異常，沒有宏，沒有函數脩飾，更沒有線程局部存儲。但是語言本身是成熟和穩定 的，而且承諾保證向後兼容：用之前的Go語言編寫程序可以用新版本的Go語言編譯器和標準 庫直接構建而不需要脩改代碼。

Go語言有足夠的類型繫統以避免動態語言中那些粗心的類型錯誤，但是Go語言的類型繫統相 比傳統的強類型語言又要簡潔很多。雖然有時候這會導致一個“無類型”的抽象類型概念，但是 Go語言程序員併不需要像C++或Haskell程序員那樣糾結於具體類型的安全屬性。在實踐中Go 語言簡潔的類型繫統給了程序員帶來了更多的安全性和更好的運行時性能。

Go語言鼓勵當代計算機繫統設計的原則，特别是局部的重要性。它的內置數據類型和大多數 的準庫數據結構都經過精心設計而避免顯式的初始化或隱式的構造函數，因爲很少的內存分 配和內存初始化代碼被隱藏在庫代碼中了。Go語言的聚合類型（結構體和數組）可以直接操 作它們的元素，隻需要更少的存儲空間、更少的內存分配，而且指針操作比其他間接操作的 語言也更有效率。由於現代計算機是一個併行的機器，Go語言提供了基於CSP的併發特性支 持。Go語言的動態棧使得輕量級線程goroutine的初始棧可以很小，因此創建一個goroutine的 代價很小，創建百萬級的goroutine完全是可行的。

Go語言的標準庫（通常被稱爲語言自帶的電池），提供了清晰的構建模塊和公共接口，包含 I/O操作、文本處理、圖像、密碼學、網絡和分布式應用程序等，併支持許多標準化的文件格 式和編解碼協議。庫和工具使用了大量的約定來減少額外的配置和解釋，從而最終簡化程序

Go語言項目

13

Go 语言圣经 中文版

的邏輯，而且每個Go程序結構都是如此的相似，因此Go程序也很容易學習。使用Go語言自 帶工具構建Go語言項目隻需要使用文件名和標識符名稱, 一個偶爾的特殊註釋來確定所有的 庫、可執行文件、測試、基準測試、例子、以及特定於平台的變量、項目的文檔等；Go語言 源代碼本身就包含了構建規范。

Go語言項目

14

Go 语言圣经 中文版

本書的組織

我們假設你已經有一個或多個其他編程語言的使用經歷，不管是類似C、c++或Java的編譯型 語言，還是類似Python、Ruby、JavaScript的腳本語言，因此我們不會像對完全的編程語言 初學者那樣解釋所有的細節。因爲Go語言的 變量、常量、表達式、控製流和函數等基本語法 也是類似的。

第一章包含了本敎程的基本結構，通過十幾個程序介紹了用Go語言如何實現 類似讀寫文件、 文本格式化、創建圖像、網絡客⼾端和服務器通訊等日常工作。

第二章描述了一個Go語言程序的基本元素結構、變量、定義新的類型、包和文件、以及作用 域的概念。第三章討論了數字、布爾值、字符串和常量，併演示了如何顯示和處理Unicode字 符。第四章描述了複合類型，從簡單的數組、字典、切片到動態列表。第五章涵蓋了函數， 併討論了錯誤處理、panic和recover，還有defer語句。

第一章到第五章是基礎部分，對於任何主流命令式編程語言這個部分都是類似的。雖然有時 候Go語言的語法和風格會有自己的特色，但是大多數程序員將能很快地適應。剩下的章節是 Go語言中特有地方：方法、接口、併發、包、測試和反射等語言特性。

Go語言的面向對象是不同尋常的。它沒有類層次結構，甚至可以説沒有類；僅僅是通過組合 （而不是繼承）簡單的對象來構建複雜的對象。方法不僅僅可以定義在結構體上, 而且可以定 義在任何用⼾自己定義的類型上；併且具體類型和抽象類型（接口）之間的關繫是隱式的， 所以很多類型的設計者可能併不知道該類型到底滿足了哪些接口。方法將在第六章討論，接 口將在第七章將討論。

第八章討論了基於順序通信進程(CSP)概念的併發編程，通過使用goroutines和channels處理 併發編程。第九章則討論了更爲傳統的基於共享變量的併發編程。

第十章描述了包機製和包的組織結構。這一章還展示了如何有效的利用Go自帶的工具，通過 一個命令提供了編譯、測試、基準測試、代碼格式化、文檔和許多其他任務。

第十一章討論了單元測試，Go語言的工具和標準庫中集成的輕量級的測試功能，從而避免了 采用強大但複雜的測試框架。測試庫提供一些基本的構件，如果有必要可以用來構建更複雜 的測試構件。

第十二章討論了反射，一個程序在運行期間來審視自己的能力。反射是一個強大的編程工 具，不過要謹慎地使用；這一章通過用利用反射機製實現一些重要的Go語言庫函數來展示了 反射的強大用法。第十三章解釋了底層編程的細節，通過使用unsafe包來繞過Go語言安全的 類型繫統，當然有時這是必要的。

有些章節的後面可能會有一些練習，你可以根據你對Go語言的理解，然後脩改書中的例子來 探索Go語言的其他用法。

本書的組織

15

Go 语言圣经 中文版

書中所有的代碼都可以從 http://gopl.io 上的Git倉庫下載。go get命令可以根據每個例子的其 導入路徑智能地獲取、構建併安裝。你隻需要選擇一個目録作爲工作空間，然後將GOPATH 環境指向這個工作目録。

Go語言工具將在必要時創建的相應的目録。例如：

$ export GOPATH=$HOME/gobook	# 選擇工作目録
$ go get gopl.io/ch1/helloworld	# 獲取/編譯/安裝
$ $GOPATH/bin/helloworld	# 運行程序
Hello, 世界	# 這是中文

要運行這些例子, 你需要安裝Go1.5以上的版本.

$ go version

go version go1.5 linux/amd64

如果你用的是其他的操作繫統, 請參考 https://golang.org/doc/install 提供的説明安裝。

本書的組織

16

Go 语言圣经 中文版

更多的信息

最佳的幫助信息來自Go語言的官方網站，https://golang.org ，它提供了完善的參考文檔，包 括編程語言規范和標準庫等諸多權威的幫助信息。同時也包含了如何編寫更地道的Go程序的 基本敎程，還有各種各樣的在線文本資源和視頻資源，它們是本書最有價值的補充。Go語言 的官方博客 https://blog.golang.org 會不定期發布一些Go語言最好的實踐文章，包括當前語言 的發展狀態、未來的計劃、會議報告和Go語言相關的各種會議的主題等信息（譯註： http://talks.golang.org/ 包含了官方收録的各種報告的講稿）。

在線訪問的一個有價值的地方是可以從web頁面運行Go語言的程序（而紙質書則沒有這麽便 利了）。這個功能由來自 https://play.golang.org 的 Go Playground 提供，併且可以方便地嵌 入到其他頁面中，例如 https://golang.org 的主頁，或 godoc 提供的文檔頁面中。

Playground可以簡單的通過執行一個小程序來測試對語法、語義和對程序庫的理解，類似其 他很多語言提供的REPL卽時運行的工具。同時它可以生成對應的url，非常適合共享Go語言 代碼片段，滙報bug或提供反饋意見等。

基於 Playground 構建的 Go Tour，https://tour.golang.org ，是一個繫列的Go語言入門敎程， 它包含了諸多基本概念和結構相關的併可在線運行的互動小程序。

當然，Playground 和 Tour 也有一些限製，它們隻能導入標準庫，而且因爲安全的原因對一些 網絡庫做了限製。如果要在編譯和運行時需要訪問互聯網，對於一些更複製的實驗，你可能 需要在自己的電腦上構建併運行程序。幸運的是下載Go語言的過程很簡單，從 https://golang.org 下載安裝包應該不超過幾分鐘（譯註：感謝偉大的長城，讓大陸的Gopher 們都學會了自己打洞的基本生活技能，下載時間可能會因爲洞的大小等因素從幾分鐘到幾天 或更久），然後就可以在自己電腦上編寫和運行Go程序了。

Go語言是一個開源項目，你可以在 https://golang.org/pkg 閲讀標準庫中任意函數和類型的實 現代碼，和下載安裝包的代碼完全一致。這樣你可以知道很多函數是如何工作的， 通過挖掘 找出一些答案的細節，或者僅僅是出於欣賞專業級Go代碼。

更多的信息

17

Go 语言圣经 中文版

致謝

Rob Pike和Russ Cox，以及很多其他Go糰隊的核心成員多次仔細閲讀了本書的手稿，他們對 本書的組織結構和表述用詞等給出了很多寶貴的建議。在準備日文版翻譯的時候，Yoshiki Shibata更是仔細地審閲了本書的每個部分，及時發現了諸多英文和代碼的錯誤。我們非常感 謝本書的每一位審閲者，併感謝對本書給出了重要的建議的Brian Goetz、Corey Kosak、 Arnold Robbins、Josh Bleecher Snyder和Peter Weinberger等人。

我們還感謝Sameer Ajmani、Ittai Balaban、David Crawshaw、Billy Donohue、Jonathan Feinberg、Andrew Gerrand、Robert Griesemer、John Linderman、Minux Ma（譯註：中国 人，Go糰隊成員。）、Bryan Mills、Bala Natarajan、Cosmos Nicolaou、Paul Staniforth、 Nigel Tao（譯註：好像是陶哲軒的兄弟）以及Howard Trickey給出的許多有價值的建議。我 們還要感謝David Brailsford和Raph Levien關於類型設置的建議。

我們的來自Addison-Wesley的編輯Greg Doench收到了很多幫助，從最開始就得到了越來越 多的幫助。來自AW生産糰隊的John Fuller、Dayna Isley、Julie Nahil、Chuti Prasertsith到 Barbara Wood，感謝你們的熱心幫助。

Alan Donovan特别感謝：Sameer Ajmani、Chris Demetriou、Walt Drummond和Google公司

的Reid Tatge允許他有充裕的時間去寫本書；感謝Stephen Donovan的建議和始終如一的鼓 勵，以及他的妻子Leila Kazemi併沒有讓他爲了家庭瑣事而分心，併熱情堅定地支持這個項 目。

Brian Kernighan特别感謝：朋友和同事對他的耐心和寬容，讓他慢慢地梳理本書的寫作思 路。同時感謝他的妻子Meg和其他很多朋友對他寫作事業的支持。

2015年 10月 於 紐約

致謝

18

Go 语言圣经 中文版

第1章 入門

本章會介紹Go語言里的一些基本組件。我們希望用信息和例子盡快帶你入門。本章和之後章 節的例子都是針對眞實的開發案例給出。本章我們隻是簡單地爲你介紹一些Go語言的入門例 子，從簡單的文件處理、圖像處理到互聯網併發客⼾端和服務端程序。當然，在第一章我們 不會詳盡地一一去説明細枝末節，不過用這些程序來學習一門新語言肯定是很有效的。

當你學習一門新語言時，你會用這門新語言去重寫自己以前熟悉語言例子的傾向。在學習Go 語言的過程中，盡量避免這麽做。我們會向你演示如何才能寫出好的Go語言程序，所以請使 用這里的代碼作爲你寫自己的Go程序時的指南。

入門

19

Go 语言圣经 中文版

1.1. Hello, World

我們以1978年出版的C語言聖經《The C Programming Language》中經典的“hello world”案 例來開始吧（譯註：本書作者之一Brian W. Kernighan也是C語言聖經一書的作者）。C語言 對Go語言的設計産生了很多影響。用這個例子，我們來講解一些Go語言的核心特性：

gopl.io/ch1/helloworld package main

import "fmt"

func main() { fmt.Println("Hello, 世界")

}

Go是一門編譯型語言，Go語言的工具鏈將源代碼和其依賴一起打包，生成機器的本地指令 (譯註：靜態編譯)。Go語言提供的工具可以通過go命令下的一繫列子命令來調用。最簡單的 一個子命令就是run。這個命令會將一個或多個文件名以.go結尾的源文件，和關聯庫鏈接到一 起，然後運行最終的可執行文件。（本書將用$表示命令行的提示符。）

$ go run helloworld.go

毫無意外，這個命令會輸出：

Hello, 世界

Go語言原生支持Unicode標準，所以你可以用Go語言處理世界上的任何自然語言。

如果你希望自己的程序不隻是簡單的一次性實驗，那麽你一定會希望能夠編譯這個程序，併 且能夠將編譯結果保存下來以備將來之用。這個可以用build子命令來實現：

$ go build helloworld.go

這會創建一個名爲helloworld的可執行的二進製文件（譯註：在Windows繫統下生成的可執行 文件是helloworld.exe，增加了.exe後綴名），之後你可以在任何時間去運行這個二進製文 件，不需要其它的任何處理(譯註：因爲是靜態編譯，所以也不用擔心在繫統庫更新的時候衝 突，幸福感滿滿)。

下面是運行我們的編譯結果樣例（譯註：在Windows繫統下在命令行直接輸入helloworld.exe 命令運行）：

Hello, World

20

Go 语言圣经 中文版

$./helloworld Hello, 世界

本書中我們所有的例子都做了一個特殊標記，你可以通過這些標記在 http://gopl.io 在線網站 上找到這些樣例代碼，比如這個

gopl.io/ch1/helloworld

如果你執行 go get gopl.io/ch1/helloworld 命令，go命令能夠自己從網上獲取到這些代碼

（譯註：需要先安裝Git或Hg之類的版本管理工具，併將對應的命令添加到PATH環境變量 中），併且將這些代碼放到對應的目録中（譯註：序言已經提及，需要先設置好GOPATH環 境變量，下載的代碼會放在 $GOPATH/src/gopl.io/ch1/helloworld 目録）。更詳細的介紹在 2.6和10.7章節中。

我們來討論一下程序本身。Go語言的代碼是通過package來組織的，package的概念和你知道 的其它語言里的libraries或者modules概念比較類似。一個package會包含一個或多個.go結束 的源代碼文件。每一個源文件都是以一個package xxx的聲明語句開頭的，比如我們的例子里 就是package main。這行聲明語句表示該文件是屬於哪一個package，緊跟着是一繫列import 的package名，表示這個文件中引入的package。再之後是本文件本身的代碼。

Go的標準庫已經提供了100多個package，用來完成一門程序語言的一些常見的基本任務，比 如輸入、輸出、排序或者字符串/文本處理。比如fmt這個package，就包括接收輸入、格式化 輸出的各種函數。Println是其中的一個常用的函數，可以用這個函數來打印一個或多個值，該 函數會將這些參數用空格隔開進行輸出，併在輸出完畢之後在行末加上一個換行符。

package main是一個比較特殊的package。這個package里會定義一個獨立的程序，這個程序 是可以運行的，而不是像其它package一樣對應一個library。在main這個package里，main函 數也是一個特殊的函數，這是我們整個程序的入口（譯註：其實C繫語言差不多都是這樣）。 main函數所做的事情就是我們程序做的事情。當然了，main函數一般是通過是調用其它 packge里的函數來完成自己的工作，比如fmt.Println。

我們必鬚告訴編譯器如何要正確地執行這個源文件，需要用到哪些package，這就是import在 這個文件里扮演的角色。上述的hello world例子隻用到了一個其它的package，就是fmt。一 般情況下，需要import的package可能不隻一個。

這也正是因爲go語言必鬚引入所有要用到的package的原則，假如你沒有在代碼里import需要 用到的package，程序將無法編譯通過，同時當你import了沒有用到的package，也會無法編 譯通過（譯註：Go語言編譯過程沒有警告信息，爭議特性之一）。

import聲明必鬚跟在文件的package聲明之後。在import語句之後，則是各種方法、變量、常 量、類型的聲明語句(分别用關鍵字func, var, const, type來進行定義)。這些內容的聲明順序併 沒有什麽規定，可以隨便調整順序(譯註：最好還是定一下規范)。我們例子里的程序比較簡

Hello, World

21

Go 语言圣经 中文版

單，隻包含了一個函數。併且在該函數里也隻調用了一個其它函數。爲了節省空間，有些時 候的例子我們會省略package和import聲明，但是讀者需要註意這些聲明是一定要包含在源文 件里的。

一個函數的聲明包含func這個關鍵字、函數名、參數列表、返迴結果列表（我們例子里的 main函數參數列表和返迴值都是空的）以及包含在大括號里的函數體。關於函數的更詳細描 述在第五章。

Go語言是一門不需要分號作爲語句或者聲明結束的語言，除非要在一行中將多個語句、聲明 隔開。然而在編譯時，編譯器會主動在一些特定的符號（譯註：比如行末是，一個標識符、 一個整數、浮點數、虛數、字符或字符串文字、關鍵字break、continue、fallthrough或return 中的一個、運算符和分隔符++、--、)、]或}中的一個） 後添加分號，所以在哪里加分號合適 是取決於Go語言代碼的。例如：在Go語言中的函數聲明和 { 大括號必鬚在同一行，而在x + y 這樣的表達式中，在+號後換行可以，但是在+號前換行則會有問題（譯註：以+結尾的話不會 被插入分號分隔符，但是以x結尾的話則會被分號分隔符，從而導致編譯錯誤）。

Go語言在代碼格式上采取了很強硬的態度。gofmt工具會將你的代碼格式化爲標準格式（譯 註：這個格式化工具沒有任何可以調整代碼格式的參數，Go語言就是這麽任性），併且go工 具中的fmt子命令會自動對特定package下的所有.go源文件應用gofmt工具格式化。如果不指 定package，則默認對當前目録下的源文件進行格式化。本書中的所有代碼已經是執行過 gofmt後的標準格式代碼。你應該在自己的代碼上也執行這種格式化。規定一種標準的代碼格 式可以規避掉無盡的無意義的撕逼（譯註：也導致了Go語言的TIOBE排名較低，因爲缺少撕 逼的話題）。當然了，這可以避免由於代碼格式導致的邏輯上的歧義。

很多文本編輯器都可以設置爲保存文件時自動執行gofmt，所以你的源代碼應該總是會被格式 化。這里還有一個相關的工具，goimports，會自動地添加你代碼里需要用到的import聲明以 及需要移除的import聲明。這個工具併沒有包含在標準的分發包中，然而你可以自行安裝：

$ go get golang.org/x/tools/cmd/goimports

對於大多數用⼾來説，下載、build package、運行測試用例、顯示Go語言的文檔等等常用功 能都是可以用go的工具來實現的。這些工具的詳細介紹我們會在10.7節中提到。

Hello, World

22

Go 语言圣经 中文版

1.2.命令行參數

大多數的程序都是處理輸入，産生輸出；這也正是“計算”的定義。但是一個程序要如何獲取輸 入呢？一些程序會生成自己的數據，但通常情況下，輸入都來自於程序外部：比如文件、網 絡連接、其它程序的輸出、用⼾的鍵盤、命令行的參數或其它類似輸入源。下面幾個例子會 討論其中的一些輸入類型，首先是命令行參數。

os這個package提供了操作繫統無關（跨平台）的，與繫統交互的一些函數和相關的變量，運 行時程序的命令行參數可以通過os包中一個叫Args的這個變量來獲取；當在os包外部使用該 變量時，需要用os.Args來訪問。

os.Args這個變量是一個字符串（string）的slice（譯註：slice和Python語言中的切片類似， 是一個簡版的動態數組），slice在Go語言里是一個基礎的數據結構，之後我們很快會提到。 現在可以先把slice當一個簡單的元素序列，可以用類似s[i]的下標訪問形式獲取其內容，併且 可以用形如s[m:n]的形式來獲取到一個slice的子集(譯註：和python里的語法差不多)。其長度 可以用len(s)函數來獲取。和其它大多數編程語言類似，Go語言里的這種索引形式也采用了左 閉右開區間，包括m~n的第一個元素，但不包括最後那個元素（譯註：比如a = [1, 2, 3, 4, 5], a[0:3] = [1, 2, 3]，不包含最後一個元素）。這樣可以簡化我們的處理邏輯。比如s[m:n]這個 slice，0 ≤ m ≤ n ≤ len(s)，包含n-m個元素。

os.Args的第一個元素，卽os.Args[0]是命令行執行時的命令本身；其它的元素則是執行該命令 時傳給這個程序的參數。前面提到的切片表達式，s[m:n]會返迴第m到第n-1個元素，所以下 一個例子里需要用到的os.Args[1:len(os.Args)]卽是除了命令本身外的所有傳入參數。如果我 們省略s[m:n]里的m和n，那麽默認這個表達式會填入0:len(s)，所以這里我們還可以省略掉 n，寫成os.Args[1:]。

下面是一個Unix里echo命令的實現，這個命令會在單行內打印出命令行參數。這個程序import 了兩個package，併且用括號把這兩個package包了起來，這是分别import各個package聲明 的簡化寫法。當然了你分開來寫import也沒有什麽問題，隻是一般爲了方便我們都會像下面這 樣來導入多個package。我們自己寫的導入順序併不重要，因爲gofmt工具會幫助我們按照字 母順序來排列好這些導入包名。（本書中如果一個例子有多種版本時，我們會用編號標記出 來）

命令行參數

23

Go 语言圣经 中文版

gopl.io/ch1/echo1

//Echo1 prints its command-line arguments. package main

import ( "fmt" "os"

)

func main() {

var s, sep string

for i := 1; i < len(os.Args); i++ { s += sep + os.Args[i]

sep = " "

}

fmt.Println(s)

}

Go語言里的註釋是以//來表示。//之後的內容一直到行末都是這條註釋的一部分，併且這些註 釋會被編譯器忽略。

按照慣例，我們會在每一個package前面放上這個package的詳盡的註釋對其進行説明；對於 一個main package來説，一般這段評論會包含幾句話來説明這個項目/程序整體是做什麽用 的。

var關鍵字用來做變量聲明。這個程序聲明了s和sep兩個string變量。變量可以在聲明期間直 接進行初始化。如果沒有顯式地初始化的話，Go語言會隱式地給這些未初始化的變量賦予對 應其類型的零值，比如數值類型就是0，字符串類型就是空字符串“”。在這個例子里的s和sep 被隱式地賦值爲了空字符串。在第2章中我們會更詳細地講解變量和聲明。

對於數字類型，Go語言提供了常規的數值計算和邏輯運算符。而對於string類型，+號表示字 符串的連接（譯註：和C++或者js是一樣的）。所以下面這個表達式：

sep + os.Args[i]

表示將sep字符串和os.Args[i]字符串進行連接。我們在程序里用的另外一個表達式：

s += sep + os.Args[i]

會將sep與os.Args[i]連接，然後再將得到的結果與s進行連接併賦值運給s，這種方式和下面的 表達是等價的：

s = s + sep + os.Args[i]

命令行參數

24

Go 语言圣经 中文版

運算符+=是一個賦值運算符(assignment operator)，每一種數值和邏輯運算符，例如*或者+都 有其對應的賦值運算符。

echo程序可以每循環一次輸出一個參數，不過我們這里的版本是不斷地將其結果連接到一個 字符串的末尾。s這個字符串在聲明的時候是一個空字符串，而之後循環每次都會被在末尾添 加一段字符串；第一次迭代之後，一個空格會被插入到字符串末尾，所以每插入一個新值， 都會和前一個中間有一個空格隔開。這是一種非線性的操作，當我們的參數數量變得龐大的 時候（當然不是説這里的echo，一般echo也不會有太多參數）其運行開銷也會變得龐大。下 面我們會介紹一繫列的echo改進版，來應對這里説到的運行效率低下。

在for循環中，我們用到了i來做下標索引，可以看到我們用了:=符號來給i進行初始化和賦值， 這是var xxx=yyy的一種簡寫形式，Go語言會根據等號右邊的值的類型自動判斷左邊的值類 型，下一章會對這一點進行詳細説明。

自增表達式i++會爲i加上1；這和i += 1以及i = i + 1都是等價的。對應的還有i--是給i減去1。這 些在Go語言里是語句，而不像C繫的其它語言里是表達式。所以在Go語言里j = i++是非法 的，而且++和--都隻能放在變量名後面，因此--i也是非法的。

在Go語言里隻有for循環一種循環。當然了爲了滿足需求，Go的for循環有很多種形式，下面 是其中的一種：

for initialization; condition; post {

// zero or more statements

}

這里需要註意，for循環的兩邊是不需要像其它語言一樣寫括號的。併且左大括號需要和for語 句在同一行。

initialization部分是可選的，如果你寫了這部分的話，在for循環之前這部分的邏輯會被執行。 需要註意的是這部分必鬚是一個簡單的語句，也就是説是一個簡短的變量聲明，一個賦值語 句，或是一個函數調用。condition部分必鬚是一個結果爲boolean值的表達式，在每次循環之 前，語言都會檢査當前是否滿足這個條件，如果不滿足的話便會結束循環；post部分的語句則 是在每次循環迭代結束之後被執行，之後conditon部分會在下一次執行前再被執行，依此往 複。當condition條件里的判斷結果變爲false之後，循環卽結束。

上面提到是for循環里的三個部分都是可以被省略的，如果你把initialization和post部分都省略 的話，那麽連中間隔離他們的分號也是可以被省略的，比如下面這種for循環，就和傳統的 while循環是一樣的：

//a traditional "while" loop for condition {

//...

}

命令行參數

25

Go 语言圣经 中文版

當然了，如果你連唯一的條件都省了，那麽for循環就會變成一個無限循環，像下面這樣：

//a traditional infinite loop for {

//...

}

在無限循環中，你還是可以靠break或者return語句來終止掉循環。

如果你的遍歷對象是string或者slice類型值的話，還有另外一種循環的寫法，我們來看看另一 個版本的echo：

gopl.io/ch1/echo2

//Echo2 prints its command-line arguments. package main

import ( "fmt"

)

func main() {

s, sep := "", ""

for _, arg := range os.Args[1:] { s += sep + arg

sep = " "

}

fmt.Println(s)

}

每一次循環迭代，range都會返迴一對結果；當前迭代的下標以及在該下標處的元素的值。在 這個例子里，我們不需要這個下標，但是因爲range的處理要求我們必鬚要同時處理下標和 值。我們可以在這里聲明一個接收index的臨時變量來解決這個問題，但是Go語言又不允許隻 聲明而在後續代碼里不使用這個變量，如果你這樣做了編譯器會返迴一個編譯錯誤。

在Go語言中，應對這種情況的解決方法是用空白標識符，對，就是上面那個下劃線_。空白標 識符可以在任何你接收自己不需要處理的值時使用。在這里，我們用它來忽略掉range返迴的 那個沒用的下標值。大多數的Go程序員都會像上面這樣來寫類似的os.Args遍歷，由於遍歷 os.Args的下標索引是隱式自動生成的，可以避免因顯式更新索引導致的錯誤。

上面這個版本將s和sep的聲明和初始化都放到了一起，但是我們可以等價地將聲明和賦值分 開來寫，下面這些寫法都是等價的

s := ""

var s string

var s = ""

var s string = ""

命令行參數

26

Go 语言圣经 中文版

那麽這些等價的形式應該怎麽做選擇呢？這里提供一些建議：第一種形式，隻能用在一個函 數內部，而package級别的變量，禁止用這樣的聲明方式。第二種形式依賴於string類型的內 部初始化機製，被初始化爲空字符串。第三種形式使用得很少，除非同時聲明多個變量。第 四種形式會顯式地標明變量的類型，在多變量同時聲明時可以用到。實踐中你應該隻使用上 面的前兩種形式，顯式地指定變量的類型，讓編譯器自己去初始化其值，或者直接用隱式初 始化，表明初始值怎麽樣併不重要。

像上面提到的，每次循環迭代中字符串s都會得到一個新內容。+=語句會分配一個新的字符 串，併將老字符串連接起來的值賦予給它。而目標字符串的老字面值在得到新值以後就失去 了用處，這些臨時值會被Go語言的垃圾收集器榦掉。

如果不斷連接的數據量很大，那麽上面這種操作就是成本非常高的操作。更簡單併且有效的 一種方式是使用strings包提供的Join函數，像下面這樣：

gopl.io/ch1/echo3

func main() {

fmt.Println(strings.Join(os.Args[1:], " "))

}

最後，如果我們對輸出的格式也不是很關心，隻是想簡單地輸出值得的話，還可以像下面這 麽寫，Println函數會爲我們自動格式化輸出。

fmt.Println(os.Args[1:])

這個輸出結果和前面的string.Join得到的結果很相似，隻是被自動地放到了一個方括號里，對 slice調用Println函數都會被打印成這樣形式的結果。

練習 1.1： 脩改echo程序，使其能夠打印os.Args[0]。

練習 1.2： 脩改echo程序，使其打印value和index，每個value和index顯示一行。

練習 1.3： 上手實踐前面提到的strings.Join和直接Println，併觀察輸出結果的區别。

命令行參數

27

Go 语言圣经 中文版

1.3.査找重複的行

文件拷貝、文件打印、文件蒐索、文件排序、文件統計類的程序一般都會有比較相似的程序 結構：一個處理輸入的循環，在每一個輸入元素上執行計算處理，在處理的同時或者處理完 成之後進行結果輸出。我們會展示一個叫dup程序的三個版本；這個程序的靈感來自於linux的 uniq命令，我們的程序將會找到相鄰的重複的行。這個程序提供的模式可以很方便地被脩改來 完成不同的需求。

第一個版本的dup會輸出標準輸入流中的出現多次的行，在行內容前會有其出現次數的計數。 這個程序將引入if表達式，map內置數據結構和bufio的package。

gopl.io/ch1/dup1

//Dup1 prints the text of each line that appears more than

//once in the standard input, preceded by its count. package main

import ( "bufio" "fmt" "os"

)

func main() {

counts := make(map[string]int) input := bufio.NewScanner(os.Stdin) for input.Scan() {

counts[input.Text()]++

}

//NOTE: ignoring potential errors from input.Err() for line, n := range counts {

if n > 1 { fmt.Printf("%d\t%s\n", n, line)

}

}

}

和我們前面提到的for循環一樣，在if條件的兩邊，我們也不需要加括號，但是if表達式後的邏 輯體的花括號是不能省略的。如果需要的話，像其它編程語言一樣，這個if表達式也可以有 else部分，這部分邏輯會在if中的條件結果爲false時被執行。

map是Go語言內置的key/value型數據結構，這個數據結構能夠提供常數時間的存儲、獲取、 測試操作。key可以是任意數據類型，隻要該類型能夠用==運算符來進行比較，string是最常 用的key類型。而value類型的范圍就更大了，基本上什麽類型都是可以的。這個例子中的key 都是string類型，value用的是int類型。我們用內置make函數來創建一個空的map，當然了， make方法還可以有别的用處。在4.3章中我們還會對map進行更深入的討論。

査找重複的行

28

Go 语言圣经 中文版

dup程序每次讀取輸入的一行，這一行的內容會被當做一個map的key，而其value值會被+1。 counts[input.Text()]++這個語句和下面的兩句是等價的：

line := input.Text()

counts[line] = counts[line] + 1

當然了，在這個例子里我們併不用擔心map在沒有當前的key時就對其進行++操作會有什麽問 題，因爲Go語言在碰到這種情況時，會自動將其初始化爲0，然後再進行操作。

在這里我們又用了一個range的循環來打印結果，這次range是被用在map這個數據結構之 上。這一次的情況和上次比較類似，range會返迴兩個值，一個key和在map對應這個key的 value。對map進行range循環時，其迭代順序是不確定的，從實踐來看，很可能每次運行都會 有不一樣的結果（譯註：這是Go語言的設計者有意爲之的，因爲其底層實現不保證插入順序 和遍歷順序一致，也希望程序員不要依賴遍歷時的順序，所以榦脆直接在遍歷的時候做了隨 機化處理，醉了。補充：好像説隨機序可以防止某種類型的攻擊，雖然不太明白，但是感覺 還蠻厲害的），來避免程序員在業務中依賴遍歷時的順序。

然後輪到我們例子中的bufio這個package了，這個package主要的目的是幫助我們更方便有效 地處理程序的輸入和輸出。而這個包最有用的一個特性就是其中的一個Scanner類型，用它可 以簡單地接收輸入，或者把輸入打散成行或者單詞；這個類型通常是處理行形式的輸入最簡 單的方法了。

本程序中用了一個短變量聲明，來創建一個buffio.Scanner對象：

input := bufio.NewScanner(os.Stdin)

scanner對象可以從程序的標準輸入中讀取內容。對input.Scanner的每一次調用都會調入一個 新行，併且會自動將其行末的換行符去掉；其結果可以用input.Text()得到。Scan方法在讀到 了新行的時候會返迴true，而在沒有新行被讀入時，會返迴false。

例子中還有一個fmt.Printf，這個函數和C繫的其它語言里的那個printf函數差不多，都是格式 化輸出的方法。fmt.Printf的第一個參數卽是輸出內容的格式規約，每一個參數如何格式化是取 決於在格式化字符串里出現的“轉換字符”，這個字符串是跟着%號後的一個字母。比如%d表 示以一個整數的形式來打印一個變量，而%s，則表示以string形式來打印一個變量。

Printf有一大堆這種轉換，Go語言程序員把這些叫做verb（動詞）。下面的表格列出了常用的 動詞，當然了不是全部，但基本也夠用了。

査找重複的行

29

Go 语言圣经 中文版

%d	int變量
%x, %o, %b	分别爲16進製，8進製，2進製形式的int
%f, %g, %e	浮點數： 3.141593 3.141592653589793 3.141593e+00
%t	布爾變量：true 或 false
%c	rune (Unicode碼點)，Go語言里特有的Unicode字符類型
%s	string
%q	帶雙引號的字符串 "abc" 或 帶單引號的 rune 'c'
%v	會將任意變量以易讀的形式打印出來
%T	打印變量的類型
%%	字符型百分比標誌（%符號本身，沒有其他操作）

dup1中的程序還包含了一個\t和\n的格式化字符串。在字符串中會以這些特殊的轉義字符來表 示不可見字符。Printf默認不會在輸出內容後加上換行符。按照慣例，用來格式化的函數都會 在末尾以f字母結尾（譯註：f後綴對應format或fmt縮寫），比如log.Printf，fmt.Errorf，同時還 有一繫列對應以ln結尾的函數（譯註：ln後綴對應line縮寫），這些函數默認以%v來格式化他 們的參數，併且會在輸出結束後在最後自動加上一個換行符。

許多程序從標準輸入中讀取數據，像上面的例子那樣。除此之外，還可能從一繫列的文件中 讀取。下一個dup程序就是從標準輸入中讀到一些文件名，用os.Open函數來打開每一個文件 獲取內容的。

査找重複的行

30

Go 语言圣经 中文版

gopl.io/ch1/dup2

//Dup2 prints the count and text of lines that appear more than once

//in the input. It reads from stdin or from a list of named files. package main

import ( "bufio" "fmt" "os"

)

func main() {

counts := make(map[string]int) files := os.Args[1:]

if len(files) == 0 { countLines(os.Stdin, counts)

}else {

for _, arg := range files { f, err := os.Open(arg) if err != nil {

fmt.Fprintf(os.Stderr, "dup2: %v\n", err) continue

}

countLines(f, counts) f.Close()

}

}

for line, n := range counts { if n > 1 {

fmt.Printf("%d\t%s\n", n, line)

}

}

}

func countLines(f *os.File, counts map[string]int) { input := bufio.NewScanner(f)

for input.Scan() { counts[input.Text()]++

}

// NOTE: ignoring potential errors from input.Err()

}

os.Open函數會返迴兩個值。第一個值是一個打開的文件類型(*os.File)，這個對象在下面的程 序中被Scanner讀取。

os.Open返迴的第二個值是一個Go語言內置的error類型。如果這個error和內置值的nil（譯 註：相當於其它語言里的NULL）相等的話，説明文件被成功的打開了。之後文件被讀取，一 直到文件的最後，文件的Close方法關閉該文件，併釋放相應的占用一切資源。另一方面，如 果err的值不是nil的話，那説明在打開文件的時候出了某種錯誤。這種情況下，error類型的值

査找重複的行

31

Go 语言圣经 中文版

會描述具體的問題。我們例子里的簡單錯誤處理會在標準錯誤流中用Fprintf和%v來格式化該 錯誤字符串。然後繼續處理下一個文件；continue語句會直接跳過之後的語句，直接開始執行 下一個循環迭代。

我們在本書中早期的例子中做了比較詳盡的錯誤處理，當然了，在實際編碼過程中，像 os.Open這類的函數是一定要檢査其返迴的error值的；爲了減少例子程序的代碼量，我們姑且 簡化掉這些不太可能返迴錯誤的處理邏輯。後面的例子里我們會跳過錯誤檢査。在5.4節中我 們會對錯誤處理做更詳細的闡述。

讀者可以再觀察一下上面的例子，我們的countLines函數是在其聲明之前就被調用了。在Go 語言里，函數和包級别的變量可以以任意的順序被聲明，併不影響其被調用。（譯註：最好 還是遵循一定的規范）

再來講講map這個數據結構，map是用make函數創建的數據結構的一個引用。當一個map被 作爲參數傳遞給一個函數時，函數接收到的是一份引用的拷貝，雖然本身併不是一個東西， 但因爲他們指向的是同一塊數據對象（譯註：類似於C++里的引用傳遞），所以你在函數里對 map里的值進行脩改時，原始的map內的值也會改變。在我們的例子中，我們在countLines函 數中插入到counts這個map里的值，在主函數中也是看得到的。

上面這個版本的dup是以流的形式來處理輸入，併將其打散爲行。理論上這些程序也是可以以 二進製形式來處理輸入的。我們也可以一次性的把整個輸入內容全部讀到內存中，然後再把其 分割爲多行，然後再去處理這些行內的數據。下面的dup3這個例子就是以這種形式來進行操 作的。這個例子引入了一個新函數ReadFile（從io/ioutil包提供），這個函數會把一個指定名 字的文件內容一次性調入，之後我們用strings.Split函數把文件分割爲多個子字符串，併存儲 到slice結構中。（Split函數是strings.Join的逆函數，Join函數之前提到過）

我們簡化了dup3這個程序。首先，它隻讀取命名的文件，而不去讀標準輸入，因爲ReadFile 函數需要一個文件名參數。其次，我們將行計數邏輯移迴到了main函數，因爲現在這個邏輯 隻有一個地方需要用到。

査找重複的行

32

Go 语言圣经 中文版

gopl.io/ch1/dup3 package main

import ( "fmt" "io/ioutil" "os" "strings"

)

func main() {

counts := make(map[string]int)

for _, filename := range os.Args[1:] { data, err := ioutil.ReadFile(filename) if err != nil {

fmt.Fprintf(os.Stderr, "dup3: %v\n", err) continue

}

for _, line := range strings.Split(string(data), "\n") { counts[line]++

}

}

for line, n := range counts { if n > 1 {

fmt.Printf("%d\t%s\n", n, line)

}

}

}

ReadFile函數返迴一個byte的slice，這個slice必鬚被轉換爲string，之後才能夠用string.Split 方法來進行處理。我們在3.5.4節中會更詳細地講解string和byte slice（字節數組）。

在更底層一些的地方，bufio.Scanner，ioutil.ReadFile和ioutil.WriteFile使用的是*os.File的 Read和Write方法，不過一般程序員併不需要去直接了解到其底層實現細節，在bufio和 io/ioutil包中提供的方法已經足夠好用。

練習 1.4： 脩改dup2，使其可以打印重複的行分别出現在哪些文件。

査找重複的行

33

Go 语言圣经 中文版

1.4. GIF動畵

下面的程序會演示Go語言標準庫里的image這個package的用法，我們會用這個包來生成一繫 列的bit-mapped圖，然後將這些圖片編碼爲一個GIF動畵。我們生成的圖形名字叫利薩如圖形 (Lissajous figures)，這種效果是在1960年代的老電影里出現的一種視覺特效。它們是協振子 在兩個緯度上振動所産生的麴線，比如兩個sin正絃波分别在x軸和y軸輸入會産生的麴線。圖

1.1是這樣的一個例子：

譯註：要看這個程序的結果，需要將標準輸出重定向到一個GIF圖像文件（使用 ./lissajous

>output.gif 命令）。下面是GIF圖像動畵效果：

這段代碼里我們用了一些新的結構，包括const聲明，struct結構體類型，複合聲明。和我們舉 的其它的例子不太一樣，這一個例子包含了浮點數運算。這些概念我們隻在這里簡單地説明 一下，之後的章節會更詳細地講解。

gopl.io/ch1/lissajous

//Lissajous generates GIF animations of random Lissajous figures. package main

import ( "image" "image/color" "image/gif" "io"

GIF動畵

34

Go 语言圣经 中文版

"math"

"math/rand"

"os"

)

var palette = []color.Color{color.White, color.Black}

const (

whiteIndex = 0 // first color in palette blackIndex = 1 // next color in palette

)

func main() {

lissajous(os.Stdout)

}

func lissajous(out io.Writer) {

const (

cycles

=

5

// number of complete x oscillator revolutions

res

=

0.001 // angular resolution

size

=

100

// image canvas covers [-size..+size]

nframes =

64

// number of animation frames

delay

=

8

// delay between frames in 10ms units

)

freq := rand.Float64() * 3.0 // relative frequency of y oscillator

anim := gif.GIF{LoopCount: nframes}

phase := 0.0 // phase difference

for i := 0; i < nframes; i++ {

rect := image.Rect(0, 0, 2*size+1, 2*size+1)

img := image.NewPaletted(rect, palette)

for t := 0.0; t < cycles*2*math.Pi; t += res {

x := math.Sin(t)

y := math.Sin(t*freq + phase)

img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5),

bla

kIndex)

}

phase += 0.1

anim.Delay = append(anim.Delay, delay) anim.Image = append(anim.Image, img)

}

gif.EncodeAll(out, &anim) // NOTE: ignoring encoding errors

}

當我們import了一個包路徑包含有多個單詞的package時，比如image/color（image和color兩 個單詞），通常我們隻需要用最後那個單詞表示這個包就可以。所以當我們寫color.White 時，這個變量指向的是image/color包里的變量，同理gif.GIF是屬於image/gif包里的變量。

這個程序里的常量聲明給出了一繫列的常量值，常量是指在程序編譯後運行時始終都不會變 化的值，比如圈數、幀數、延遲值。常量聲明和變量聲明一般都會出現在包級别，所以這些 常量在整個包中都是可以共享的，或者你也可以把常量聲明定義在函數體內部，那麽這種常

GIF動畵

35

Go 语言圣经 中文版

量就隻能在函數體內用。目前常量聲明的值必鬚是一個數字值、字符串或者一個固定的 boolean值。

[]color.Color{...}和gif.GIF{...}這兩個表達式就是我們説的複合聲明（4.2和4.4.1節有説明）。這

是實例化Go語言里的複合類型的一種寫法。這里的前者生成的是一個slice切片，後者生成的 是一個struct結構體。

gif.GIF是一個struct類型（參考4.4節）。struct是一組值或者叫字段的集合，不同的類型集合 在一個struct可以讓我們以一個統一的單元進行處理。anim是一個gif.GIF類型的struct變量。 這種寫法會生成一個struct變量，併且其內部變量LoopCount字段會被設置爲nframes；而其它 的字段會被設置爲各自類型默認的零值。struct內部的變量可以以一個點(.)來進行訪問，就像 在最後兩個賦值語句中顯式地更新了anim這個struct的Delay和Image字段。

lissajous函數內部有兩層嵌套的for循環。外層循環會循環64次，每一次都會生成一個單獨的 動畵幀。它生成了一個包含兩種顔色的201&201大小的圖片，白色和黑色。所有像素點都會 被默認設置爲其零值（也就是palette里的第0個值），這里我們設置的是白色。每次外層循環 都會生成一張新圖片，併將一些像素設置爲黑色。其結果會append到之前結果之後。這里我 們用到了append(參考4.2.1)這個內置函數，將結果appen到anim中的幀列表末尾，併會設置 一個默認的80ms的延遲值。最終循環結束，所有的延遲值也被編碼進了GIF圖片中，併將結 果寫入到輸出流。out這個變量是io.Writer類型，這個類型讓我們可以可以讓我們把輸出結果 寫到很多目標，很快我們就可以看到了。

內存循環設置了兩個偏振。x軸偏振使用的是一個sin函數。y軸偏振也是一個正絃波，但是其 其相對x軸的偏振是一個0-3的隨機值，併且初始偏振值是一個零值，併隨着動畵的每一幀逐漸 增加。循環會一直跑到x軸完成五次完整的循環。每一步它都會調用SetColorIndex來爲(x, y) 點來染黑色。

main函數調用了lissajous函數，併且用它來向標準輸出中打印信息，所以下面這個命令會像 圖1.1中産生一個GIF動畵。

$go build gopl.io/ch1/lissajous

$./lissajous >out.gif

練習 1.5： 脩改前面的Lissajous程序里的調色闆，由緑色改爲黑色。我們可以用 color.RGBA{0xRR, 0xGG, 0xBB}來得到#RRGGBB這個色值，三個十六進製的字符串分别代 表紅、緑、藍像素。

練習 1.6： 脩改Lissajous程序，脩改其調色闆來生成更豐富的顔色，然後脩改SetColorIndex 的第三個參數，看看顯示結果吧。

GIF動畵

36

Go 语言圣经 中文版

1.5. 獲取URL

對於很多現代應用來説，訪問互聯網上的信息和訪問本地文件繫統一樣重要。Go語言在net這 個強大package的幫助下提供了一繫列的package來做這件事情，使用這些包可以更簡單地用 網絡收發信息，還可以建立更底層的網絡連接，編寫服務器程序。在這些情景下，Go語言原 生的併發特性（在第八章中會介紹）就顯得尤其好用了。

爲了最簡單地展示基於HTTP獲取信息的方式，下面給出一個示例程序fetch，這個程序將獲取 對應的url，併將其源文本打印出來；這個例子的靈感來源於curl工具（譯註：unix下的一個網 絡相關的工具）。當然了，curl提供的功能更爲複雜豐富，這里我們隻編寫最簡單的樣例。之 後我們還會在本書中經常用到這個例子。

gopl.io/ch1/fetch

//Fetch prints the content found at a URL. package main

import ( "fmt" "io/ioutil" "net/http" "os"

)

func main() {

for _, url := range os.Args[1:] { resp, err := http.Get(url) if err != nil {

fmt.Fprintf(os.Stderr, "fetch: %v\n", err) os.Exit(1)

}

b, err := ioutil.ReadAll(resp.Body) resp.Body.Close()

if err != nil {

fmt.Fprintf(os.Stderr, "fetch: reading %s: %v\n", url, err) os.Exit(1)

}

fmt.Printf("%s", b)

}

}

這個程序從兩個package中導入了函數，net/http和io/ioutil包，http.Get函數是創建HTTP請求 的函數，如果獲取過程沒有出錯，那麽會在resp這個結構體中得到訪問的請求結果。resp的 Body字段包括一個可讀的服務器響應流。這之後ioutil.ReadAll函數從response中讀取到全部 內容；其結果保存在變量b中。resp.Body.Close這一句會關閉resp的Body流，防止資源洩 露，Printf函數會將結果b寫出到標準輸出流中。

獲取URL

37

Go 语言圣经 中文版

$go build gopl.io/ch1/fetch

$./fetch http://gopl.io <html>

<head>

<title>The Go Programming Language</title>title>

...

HTTP請求如果失敗了的話，會得到下面這樣的結果：

$ ./fetch http://bad.gopl.io

fetch: Get http://bad.gopl.io: dial tcp: lookup bad.gopl.io: no such host

譯註：在大兲朝的網絡環境下很容易重現這種錯誤，下面是Windows下運行得到的錯誤信 息：

$ go run main.go http://gopl.io

fetch: Get http://gopl.io: dial tcp: lookup gopl.io: getaddrinfow: No such host is known.

無論哪種失敗原因，我們的程序都用了os.Exit函數來終止進程，併且返迴一個status錯誤碼， 其值爲1。

練習 1.7： 函數調用io.Copy(dst, src)會從src中讀取內容，併將讀到的結果寫入到dst中，使用 這個函數替代掉例子中的ioutil.ReadAll來拷貝響應結構體到os.Stdout，避免申請一個緩衝區 （例子中的b）來存儲。記得處理io.Copy返迴結果中的錯誤。

練習 1.8： 脩改fetch這個范例，如果輸入的url參數沒有 http:// 前綴的話，爲這個url加上該 前綴。你可能會用到strings.HasPrefix這個函數。

練習 1.9： 脩改fetch打印出HTTP協議的狀態碼，可以從resp.Status變量得到該狀態碼。

獲取URL

38

Go 语言圣经 中文版

1.6.併發獲取多個URL

Go語言最有意思併且最新奇的特性就是其對併發編程的支持了。併發編程是一個大話題，在 第八章和第九章中會專門講到。這里我們隻淺嚐輒止地來體驗一下Go語言里的goroutine和 channel。

下面的例子fetchall，和上面的fetch程序所要做的工作是一致的，但是這個fetchall的特别之處 在於它會同時去獲取所有的URL，所以這個程序的獲取時間不會超過執行時間最長的那一個 任務，而不會像前面的fetch程序一樣，執行時間是所有任務執行時間之和。這次的fetchall程 序隻會打印獲取的內容大小和經過的時間，不會像上面那樣打印出獲取的內容。

併發獲取多個URL

39

Go 语言圣经 中文版

gopl.io/ch1/fetchall

//Fetchall fetches URLs in parallel and reports their times and sizes. package main

import ( "fmt" "io"

"io/ioutil"

"net/http"

"os"

"time"

)

func main() {

start := time.Now()

ch := make(chan string)

for _, url := range os.Args[1:] {

go fetch(url, ch) // start a goroutine

}

for range os.Args[1:] {

fmt.Println(<-ch) // receive from channel ch

}

fmt.Printf("%.2fs elapsed\n", time.Since(start).Seconds())

}

func fetch(url string, ch chan<- string) { start := time.Now()

resp, err := http.Get(url) if err != nil {

ch <- fmt.Sprint(err) // send to channel ch return

}

nbytes, err := io.Copy(ioutil.Discard, resp.Body) resp.Body.Close() // don't leak resources

if err != nil {

ch <- fmt.Sprintf("while reading %s: %v", url, err) return

}

secs := time.Since(start).Seconds()

ch <- fmt.Sprintf("%.2fs %7d %s", secs, nbytes, url)

}

下面是一個使用的例子

$ go build gopl.io/ch1/fetchall

$./fetchall https://golang.org http://gopl.io https://godoc.org

0.14s 6852 https://godoc.org

0.16s 7261 https://golang.org

0.48s 2475 http://gopl.io

0.48s elapsed

併發獲取多個URL

40

Go 语言圣经 中文版

goroutine是一種函數的併發執行方式，而channel是用來在goroutine之間進行參數傳遞。 main函數也是運行在一個goroutine中，而go function則表示創建一個新的goroutine，併在這 個這個新的goroutine里執行這個函數。

main函數中用make函數創建了一個傳遞string類型參數的channel，對每一個命令行參數，我 們都用go這個關鍵字來創建一個goroutine，併且讓函數在這個goroutine異步執行http.Get方 法。這個程序里的io.Copy會把響應的Body內容拷貝到ioutil.Discard輸出流中（譯註：這是一 個垃圾桶，可以向里面寫一些不需要的數據），因爲我們需要這個方法返迴的字節數，但是 又不想要其內容。每當請求返迴內容時，fetch函數都會往ch這個channel里寫入一個字符串， 由main函數里的第二個for循環來處理併打印channel里的這個字符串。

當一個goroutine嚐試在一個channel上做send或者receive操作時，這個goroutine會阻塞在調 用處，直到另一個goroutine往這個channel里寫入、或者接收了值，這樣兩個goroutine才會繼 續執行操作channel完成之後的邏輯。在這個例子中，每一個fetch函數在執行時都會往 channel里發送一個值(ch <- expression)，主函數接收這些值(<-ch)。這個程序中我們用main 函數來所有fetch函數傳迴的字符串，可以避免在goroutine異步執行時同時結束。

練習 1.10： 找一個數據量比較大的網站，用本小節中的程序調研網站的緩存策略，對每個 URL執行兩遍請求，査看兩次時間是否有較大的差别，併且每次獲取到的響應內容是否一 致，脩改本節中的程序，將響應結果輸出，以便於進行對比。

併發獲取多個URL

41

Go 语言圣经 中文版

1.7. Web服務

Go語言的內置庫讓我們寫一個像fetch這樣例子的web服務器變得異常地簡單。在本節中，我 們會展示一個微型服務器，這個服務的功能是返迴當前用⼾正在訪問的URL。也就是説比如 用⼾訪問的是 http://localhost:8000/hello ，那麽響應是URL.Path = "hello"。

gopl.io/ch1/server1

//Server1 is a minimal "echo" server. package main

import ( "fmt" "log"

"net/http"

)

func main() {

http.HandleFunc("/", handler) // each request calls handler log.Fatal(http.ListenAndServe("localhost:8000", nil))

}

//handler echoes the Path component of the request URL r. func handler(w http.ResponseWriter, r *http.Request) {

fmt.Fprintf(w, "URL.Path = %q\n", r.URL.Path)

}

我們隻用了八九行代碼就實現了一個個Web服務程序，這都是多虧了標準庫里的方法已經幫 我們處理了大量的工作。main函數會將所有發送到/路徑下的請求和handler函數關聯起來，/ 開頭的請求其實就是所有發送到當前站點上的請求，我們的服務跑在了8000端口上。發送到 這個服務的“請求”是一個http.Request類型的對象，這個對象中包含了請求中的一繫列相關字 段，其中就包括我們需要的URL。當請求到達服務器時，這個請求會被傳給handler函數來處 理，這個函數會將/hello這個路徑從請求的URL中解析出來，然後把其發送到響應中，這里我 們用的是標準輸出流的fmt.Fprintf。Web服務會在第7.7節中詳細闡述。

讓我們在後台運行這個服務程序。如果你的操作繫統是Mac OS X或者Linux，那麽在運行命 令的末尾加上一個&符號，卽可讓程序簡單地跑在後台，而在windows下，你需要在另外一個 命令行窗口去運行這個程序了。

$ go run src/gopl.io/ch1/server1/main.go &

現在我們可以通過命令行來發送客⼾端請求了：

Web服務

42

Go 语言圣经 中文版

$ go build gopl.io/ch1/fetch

$./fetch http://localhost:8000 URL.Path = "/"

$./fetch http://localhost:8000/help URL.Path = "/help"

另外我們還可以直接在瀏覽器里訪問這個URL，然後得到返迴結果，如圖1.2：

在這個服務的基礎上疊加特性是很容易的。一種比較實用的脩改是爲訪問的url添加某種狀 態。比如，下面這個版本輸出了同樣的內容，但是會對請求的次數進行計算；對URL的請求 結果會包含各種URL被訪問的總次數，直接對/count這個URL的訪問要除外。

Web服務

43

Go 语言圣经 中文版

gopl.io/ch1/server2

//Server2 is a minimal "echo" and counter server. package main

import ( "fmt" "log"

"net/http"

"sync"

)

var mu sync.Mutex var count int

func main() { http.HandleFunc("/", handler) http.HandleFunc("/count", counter) log.Fatal(http.ListenAndServe("localhost:8000", nil))

}

//handler echoes the Path component of the requested URL. func handler(w http.ResponseWriter, r *http.Request) {

mu.Lock()

count++

mu.Unlock()

fmt.Fprintf(w, "URL.Path = %q\n", r.URL.Path)

}

//counter echoes the number of calls so far.

func counter(w http.ResponseWriter, r *http.Request) { mu.Lock()

fmt.Fprintf(w, "Count %d\n", count) mu.Unlock()

}

這個服務器有兩個請求處理函數，請求的url會決定具體調用哪一個：對/count這個url的請求 會調用到count這個函數，其它所有的url都會調用默認的處理函數。如果你的請求pattern是 以/結尾，那麽所有以該url爲前綴的url都會被這條規則匹配。在這些代碼的背後，服務器每一 次接收請求處理時都會另起一個goroutine，這樣服務器就可以同一時間處理多數請求。然而 在併發情況下，假如眞的有兩個請求同一時刻去更新count，那麽這個值可能併不會被正確地 增加；這個程序可能會被引發一個嚴重的bug：競態條件（參見9.1）。爲了避免這個問題， 我們必鬚保證每次脩改變量的最多隻能有一個goroutine，這也就是代碼里的mu.Lock()和 mu.Unlock()調用將脩改count的所有行爲包在中間的目的。第九章中我們會進一步講解共享變 量。

下面是一個更爲豐富的例子，handler函數會把請求的http頭和請求的form數據都打印出來， 這樣可以讓檢査和調試這個服務更爲方便：

Web服務

44

Go 语言圣经 中文版

gopl.io/ch1/server3

// handler echoes the HTTP request.

func handler(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "%s %s %s\n", r.Method, r.URL, r.Proto) for k, v := range r.Header {

fmt.Fprintf(w, "Header[%q] = %q\n", k, v)

}

fmt.Fprintf(w, "Host = %q\n", r.Host) fmt.Fprintf(w, "RemoteAddr = %q\n", r.RemoteAddr) if err := r.ParseForm(); err != nil {

log.Print(err)

}

for k, v := range r.Form { fmt.Fprintf(w, "Form[%q] = %q\n", k, v)

}

}

我們用http.Request這個struct里的字段來輸出下面這樣的內容：

GET /?q=query HTTP/1.1

Header["Accept-Encoding"] = ["gzip, deflate, sdch"] Header["Accept-Language"] = ["en-US,e Header["Connection"] = ["keep-alive"]

Header["Accept"] = ["text/html,application/xhtml+xml,application/xml;..."] Header["User-A RemoteAddr = "127.0.0.1:59911"

Form["q"] = ["query"]

可以看到這里的ParseForm被嵌套在了if語句中。Go語言允許這樣的一個簡單的語句結果作爲 循環的變量聲明出現在if語句的最前面，這一點對錯誤處理很有用處。我們還可以像下面這樣 寫（當然看起來就長了一些）：

err := r.ParseForm()

if err != nil {

log.Print(err)

}

用if和ParseForm結合可以讓代碼更加簡單，併且可以限製err這個變量的作用域，這麽做是很 不錯的。我們會在2.7節中講解作用域。

在這些程序中，我們看到了很多不同的類型被輸出到標準輸出流中。比如前面的fetch程序， 就把HTTP的響應數據拷貝到了os.Stdout，或者在lissajous程序里我們輸出的是一個文件。 fetchall程序則完全忽略到了HTTP的響應體，隻是計算了一下響應體的大小，這個程序中把響 應體拷貝到了ioutil.Discard。在本節的web服務器程序中則是用fmt.Fprintf直接寫到了

http.ResponseWriter中。

Web服務

45

Go 语言圣经 中文版

盡管這三種具體的實現流程併不太一樣，他們都實現一個共同的接口，卽當它們被調用需要 一個標準流輸出時都可以滿足。這個接口叫作io.Writer，在7.1節中會詳細討論。

Go語言的接口機製會在第7章中講解，爲了在這里簡單説明接口能做什麽，讓我們簡單地將這 里的web服務器和之前寫的lissajous函數結合起來，這樣GIF動畵可以被寫到HTTP的客⼾端， 而不是之前的標準輸出流。隻要在web服務器的代碼里加入下面這幾行。

handler := func(w http.ResponseWriter, r *http.Request) {

lissajous(w)

}

http.HandleFunc("/", handler)

或者另一種等價形式：

http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {

lissajous(w)

})

HandleFunc函數的第二個參數是一個函數的字面值，也就是一個在使用時定義的匿名函數。 這些內容我們會在5.6節中講解。

做完這些脩改之後，在瀏覽器里訪問 http://localhost:8000 。每次你載入這個頁面都可以看到 一個像圖1.3那樣的動畵。

練習 1.12： 脩改Lissajour服務，從URL讀取變量，比如你可以訪問 http://localhost:8000/? cycles=20 這個URL，這樣訪問可以將程序里的cycles默認的5脩改爲20。字符串轉換爲數字 可以調用strconv.Atoi函數。你可以在dodoc里査看strconv.Atoi的詳細説明。

Web服務

46

Go 语言圣经 中文版

Web服務

47

Go 语言圣经 中文版

1.8.本章要點

本章中對Go語言做了一些介紹，實際上Go語言還有很多方面在這有限的篇幅中還沒有覆蓋 到。這里我們會把沒有講到的內容也做一些簡單的介紹，這樣讀者在之後看到完整的內容之 前，也可以有個簡單印象。

控製流： 在本章我們隻介紹了if控製和for，但是沒有提到switch多路選擇。這里是一個簡單的 switch的例子：

switch coinflip() {

case "heads":

heads++

case "tails":

tails++

default:

fmt.Println("landed on edge!")

}

在翻轉硬幣的時候，例子里的coinflip函數返迴幾種不同的結果，每一個case都會對應個返迴 結果，這里需要註意，Go語言併不需要顯式地去在每一個case後寫break，語言默認執行完 case後的邏輯語句會自動退出。當然了，如果你想要相鄰的幾個case都執行同一邏輯的話， 需要自己顯式地寫上一個fallthrough語句來覆蓋這種默認行爲。不過fallthrough語句在一般的 編程中用到得很少。

Go語言里的switch還可以不帶操作對象（譯註：switch不帶操作對象時默認用true值代替，然 後將每個case的表達式和true值進行比較）；可以直接羅列多種條件，像其它語言里面的多個 if else一樣，下面是一個例子：

func Signum(x int) int { switch {

case x > 0: return +1

default: return 0

case x < 0: return -1

}

}

這種形式叫做無tag switch(tagless switch)；這和switch true是等價的。

像for和if控製語句一樣，switch也可以緊跟一個簡短的變量聲明，一個自增表達式、賦值語 句，或者一個函數調用。

本章要點

48

Go 语言圣经 中文版

break和continue語句會改變控製流。和其它語言中的break和continue一樣，break會中斷當 前的循環，併開始執行循環之後的內容，而continue會中跳過當前循環，併開始執行下一次循 環。這兩個語句除了可以控製for循環，還可以用來控製switch和select語句(之後會講到)，在 1.3節中我們看到，continue會跳過是內層的循環，如果我們想跳過的是更外層的循環的話， 我們可以在相應的位置加上label，這樣break和continue就可以根據我們的想法來continue和 break任意循環。這看起來甚至有點像goto語句的作用了。當然，一般程序員也不會用到這種 操作。這兩種行爲更多地被用到機器生成的代碼中。

命名類型： 類型聲明使得我們可以很方便地給一個特殊類型一個名字。因爲struct類型聲明通 常非常地長，所以我們總要給這種struct取一個名字。本章中就有這樣一個例子，二維點類 型：

type Point struct { X, Y int

}

var p Point

類型聲明和命名類型會在第二章中介紹。

指針： Go語言提供了指針。指針是一種直接存儲了變量的內存地址的數據類型。在其它語言 中，比如C語言，指針操作是完全不受約束的。在另外一些語言中，指針一般被處理爲“引 用”，除了到處傳遞這些指針之外，併不能對這些指針做太多事情。Go語言在這兩種范圍中取 了一種平衡。指針是可見的內存地址，&操作符可以返迴一個變量的內存地址，併且*操作符可 以獲取指針指向的變量內容，但是在Go語言里沒有指針運算，也就是不能像c語言里可以對指 針進行加或減操作。我們會在2.3.2中進行詳細介紹。

方法和接口： 方法是和命名類型關聯的一類函數。Go語言里比較特殊的是方法可以被關聯到 任意一種命名類型。在第六章我們會詳細地講方法。接口是一種抽象類型，這種類型可以讓 我們以同樣的方式來處理不同的固有類型，不用關心它們的具體實現，而隻需要關註它們提 供的方法。第七章中會詳細説明這些內容。

包（packages）： Go語言提供了一些很好用的package，併且這些package是可以擴展的。 Go語言社區已經創造併且分享了很多很多。所以Go語言編程大多數情況下就是用已有的 package來寫我們自己的代碼。通過這本書，我們會講解一些重要的標準庫內的package，但 是還是有很多我們沒有篇幅去説明，因爲我們沒法在這樣的厚度的書里去做一部代碼大全。

在你開始寫一個新程序之前，最好先去檢査一下是不是已經有了現成的庫可以幫助你更高效 地完成這件事情。你可以在 https://golang.org/pkg 和 https://godoc.org 中找到標準庫和社區 寫的package。godoc這個工具可以讓你直接在本地命令行閲讀標準庫的文檔。比如下面這個 例子。

本章要點

49

Go 语言圣经 中文版

$go doc http.ListenAndServe package http // import "net/http"

func ListenAndServe(addr string, handler Handler) error ListenAndServe listens on the TCP network address addr and then calls Serve with handler to handle requests on incoming connections.

...

註釋： 我們之前已經提到過了在源文件的開頭寫的註釋是這個源文件的文檔。在每一個函數 之前寫一個説明函數行爲的註釋也是一個好習慣。這些慣例很重要，因爲這些內容會被像 godoc這樣的工具檢測到，併且在執行命令時顯示這些註釋。具體可以參考10.7.4。

多行註釋可以用 /* ... */ 來包裹，和其它大多數語言一樣。在文件一開頭的註釋一般都是 這種形式，或者一大段的解釋性的註釋文字也會被這符號包住，來避免每一行都需要加//。在 註釋中//和/*是沒什麽意義的，所以不要在註釋中再嵌入註釋。

本章要點

50

Go 语言圣经 中文版

第2章 程序結構

Go語言和其他編程語言一樣，一個大的程序是由很多小的基礎構件組成的。變量保存值，簡 單的加法和減法運算被組合成較複雜的表達式。基礎類型被聚合爲數組或結構體等更複雜的 數據結構。然後使用if和for之類的控製語句來組織和控製表達式的執行流程。然後多個語句被 組織到一個個函數中，以便代碼的隔離和複用。函數以源文件和包的方式被組織。

我們已經在前面章節的例子中看到了很多例子。在本章中，我們將深入討論Go程序基礎結構 方面的一些細節。每個示例程序都是刻意寫的簡單，這樣我們可以減少複雜的算法或數據結 構等不相關的問題帶來的榦擾，從而可以專註於Go語言本身的學習。

程序結構

51

Go 语言圣经 中文版

2.1.命名

Go語言中的函數名、變量名、常量名、類型名、語句標號和包名等所有的命名，都遵循一個 簡單的命名規則：一個名字必鬚以一個字母（Unicode字母）或下劃線開頭，後面可以跟任意 數量的字母、數字或下劃線。大寫字母和小寫字母是不同的：heapSort和Heapsort是兩個不 同的名字。

Go語言中類似if和switch的關鍵字有25個；關鍵字不能用於自定義名字，隻能在特定語法結構 中使用。

break	default	func	interface	select
case	defer	go	map	struct
chan	else	goto	package	switch
const	fallthrough	if	range	type
continue	for	import	return	var

此外，還有大約30多個預定義的名字，比如int和true等，主要對應內建的常量、類型和函數。

內建常量: true false iota nil

內建類型: int int8 int16 int32 int64

uint uint8 uint16 uint32 uint64 uintptr float32 float64 complex128 complex64 bool byte rune string error

內建函數: make len cap new append copy close delete complex real imag

panic recover

這些內部預先定義的名字併不是關鍵字，你可以再定義中重新使用它們。在一些特殊的場景 中重新定義它們也是有意義的，但是也要註意避免過度而引起語義混亂。

如果一個名字是在函數內部定義，那麽它的就隻在函數內部有效。如果是在函數外部定義，那 麽將在當前包的所有文件中都可以訪問。名字的開頭字母的大小寫決定了名字在包外的可見 性。如果一個名字是大寫字母開頭的（譯註：必鬚是在函數外部定義的包級名字；包級函數 名本身也是包級名字），那麽它將是導出的，也就是説可以被外部的包訪問，例如fmt包的 Printf函數就是導出的，可以在fmt包外部訪問。包本身的名字一般總是用小寫字母。

名字的長度沒有邏輯限製，但是Go語言的風格是盡量使用短小的名字，對於局部變量尤其是 這樣；你會經常看到i之類的短名字，而不是冗長的theLoopIndex命名。通常來説，如果一個 名字的作用域比較大，生命週期也比較長，那麽用長的名字將會更有意義。

命名

52

Go 语言圣经 中文版

在習慣上，Go語言程序員推薦使用 駝峯式 命名，當名字有幾個單詞組成的時優先使用大小寫 分隔，而不是優先用下劃線分隔。因此，在標準庫有QuoteRuneToASCII和parseRequestLine 這樣的函數命名，但是一般不會用quote_rune_to_ASCII和parse_request_line這樣的命名。

而像ASCII和HTML這樣的縮略詞則避免使用大小寫混合的寫法，它們可能被稱爲 htmlEscape、HTMLEscape或escapeHTML，但不會是escapeHtml。

命名

53

Go 语言圣经 中文版

2.2.聲明

聲明語句定義了程序的各種實體對象以及部分或全部的屬性。Go語言主要有四種類型的聲明 語句：var、const、type和func，分别對應變量、常量、類型和函數實體對象的聲明。這一章 我們重點討論變量和類型的聲明，第三章將討論常量的聲明，第五章將討論函數的聲明。

一個Go語言編寫的程序對應一個或多個以.go爲文件後綴名的源文件中。每個源文件以包的聲 明語句開始，説明該源文件是屬於哪個包。包聲明語句之後是import語句導入依賴的其它包， 然後是包一級的類型、變量、常量、函數的聲明語句，包一級的各種類型的聲明語句的順序 無關緊要（譯註：函數內部的名字則必鬚先聲明之後才能使用）。例如，下面的例子中聲明 了一個常量、一個函數和兩個變量：

gopl.io/ch2/boiling

//Boiling prints the boiling point of water. package main

import "fmt"

const boilingF = 212.0

func main() {

var f = boilingF

var c = (f - 32) * 5 / 9

fmt.Printf("boiling point = %g°F or %g°C\n", f, c)

//Output:

//boiling point = 212°F or 100°C

}

其中常量boilingF是在包一級范圍聲明語句聲明的，然後f和c兩個變量是在main函數內部聲明 的聲明語句聲明的。在包一級聲明語句聲明的名字可在整個包對應的每個源文件中訪問，而 不是僅僅在其聲明語句所在的源文件中訪問。相比之下，局部聲明的名字就隻能在函數內部 很小的范圍被訪問。

一個函數的聲明由一個函數名字、參數列表（由函數的調用者提供參數變量的具體值）、一 個可選的返迴值列表和包含函數定義的函數體組成。如果函數沒有返迴值，那麽返迴值列表 是省略的。執行函數從函數的第一個語句開始，依次順序執行直到遇到renturn返迴語句，如 果沒有返迴語句則是執行到函數末尾，然後返迴到函數調用者。

我們已經看到過很多函數聲明和函數調用的例子了，在第五章將深入討論函數的相關細節， 這里隻簡單解釋下。下面的fToC函數封裝了溫度轉換的處理邏輯，這樣它隻需要被定義一 次，就可以在多個地方多次被使用。在這個例子中，main函數就調用了兩次fToC函數，分别 是使用在局部定義的兩個常量作爲調用函數的參數。

聲明

54

Go 语言圣经 中文版

gopl.io/ch2/ftoc

//Ftoc prints two Fahrenheit-to-Celsius conversions. package main

import "fmt"

func main() {

const freezingF, boilingF = 32.0, 212.0

fmt.Printf("%g°F = %g°C\n", freezingF, fToC(freezingF)) // "32°F = 0°C" fmt.Printf("%g°F = %g°C\n", boilingF, fToC(boilingF)) // "212°F = 100°C"

}

func fToC(f float64) float64 { return (f - 32) * 5 / 9

}

聲明

55

Go 语言圣经 中文版

2.3.變量

var聲明語句可以創建一個特定類型的變量，然後給變量附加一個名字，併且設置變量的初始 值。變量聲明的一般語法如下：

var 變量名字 類型 = 表達式

其中“類型”或“= 表達式”兩個部分可以省略其中的一個。如果省略的是類型信息，那麽將根據 初始化表達式來推導變量的類型信息。如果初始化表達式被省略，那麽將用零值初始化該變 量。 數值類型變量對應的零值是0，布爾類型變量對應的零值是false，字符串類型對應的零 值是空字符串，接口或引用類型（包括slice、map、chan和函數）變量對應的零值是nil。數 組或結構體等聚合類型對應的零值是每個元素或字段都是對應該類型的零值。

零值初始化機製可以確保每個聲明的變量總是有一個良好定義的值，因此在Go語言中不存在 未初始化的變量。這個特性可以簡化很多代碼，而且可以在沒有增加額外工作的前提下確保 邊界條件下的合理行爲。例如：

var s string

fmt.Println(s) // ""

這段代碼將打印一個空字符串，而不是導致錯誤或産生不可預知的行爲。Go語言程序員應該 讓一些聚合類型的零值也具有意義，這樣可以保證不管任何類型的變量總是有一個合理有效 的零值狀態。

也可以在一個聲明語句中同時聲明一組變量，或用一組初始化表達式聲明併初始化一組變 量。如果省略每個變量的類型，將可以聲明多個類型不同的變量（類型由初始化表達式推 導）：

var i, j, k int

// int, int, int

var b, f, s = true, 2.3, "four" // bool, float64, string

初始化表達式可以是字面量或任意的表達式。在包級别聲明的變量會在main入口函數執行前 完成初始化（§2.6.2），局部變量將在聲明語句被執行到的時候完成初始化。

一組變量也可以通過調用一個函數，由函數返迴的多個返迴值初始化：

var f, err = os.Open(name) // os.Open returns a file and an error

2.3.1.簡短變量聲明

變量

56

Go 语言圣经 中文版

在函數內部，有一種稱爲簡短變量聲明語句的形式可用於聲明和初始化局部變量。它以“名字 := 表達式”形式聲明變量，變量的類型根據表達式來自動推導。下面是lissajous函數中的三個 簡短變量聲明語句（§1.4）：

anim := gif.GIF{LoopCount: nframes}

freq := rand.Float64() * 3.0

t := 0.0

因爲簡潔和靈活的特點，簡短變量聲明被廣泛用於大部分的局部變量的聲明和初始化。var形 式的聲明語句往往是用於需要顯式指定變量類型地方，或者因爲變量稍後會被重新賦值而初 始值無關緊要的地方。

i := 100// an int

var boiling float64 = 100 // a float64 var names []string

var err error var p Point

和var形式聲明變語句一樣，簡短變量聲明語句也可以用來聲明和初始化一組變量：

i, j := 0, 1

但是這種同時聲明多個變量的方式應該限製隻在可以提高代碼可讀性的地方使用，比如for語 句的循環的初始化語句部分。

請記住“:=”是一個變量聲明語句，而“=‘是一個變量賦值操作。也不要混淆多個變量的聲明和元 組的多重賦值（§2.4.1），後者是將右邊各個的表達式值賦值給左邊對應位置的各個變量：

i, j = j, i // 交換 i 和 j 的值

和普通var形式的變量聲明語句一樣，簡短變量聲明語句也可以用函數的返迴值來聲明和初始 化變量，像下面的os.Open函數調用將返迴兩個值：

f, err := os.Open(name) if err != nil {

return err

}

//...use f...

f.Close()

這里有一個比較微妙的地方：簡短變量聲明左邊的變量可能併不是全部都是剛剛聲明的。如 果有一些已經在相同的詞法域聲明過了（§2.7），那麽簡短變量聲明語句對這些已經聲明過 的變量就隻有賦值行爲了。

變量

57

Go 语言圣经 中文版

在下面的代碼中，第一個語句聲明了in和err兩個變量。在第二個語句隻聲明了out一個變量， 然後對已經聲明的err進行了賦值操作。

in, err := os.Open(infile)

// ...

out, err := os.Create(outfile)

簡短變量聲明語句中必鬚至少要聲明一個新的變量，下面的代碼將不能編譯通過：

f, err := os.Open(infile)

// ...

f, err := os.Create(outfile) // compile error: no new variables

解決的方法是第二個簡短變量聲明語句改用普通的多重賦值語言。

簡短變量聲明語句隻有對已經在同級詞法域聲明過的變量才和賦值操作語句等價，如果變量 是在外部詞法域聲明的，那麽簡短變量聲明語句將會在當前詞法域重新聲明一個新的變量。 我們在本章後面將會看到類似的例子。

2.3.2.指針

一個變量對應一個保存了變量對應類型值的內存空間。普通變量在聲明語句創建時被綁定到 一個變量名，比如叫x的變量，但是還有很多變量始終以表達式方式引入，例如x[i]或x.f變量。 所有這些表達式一般都是讀取一個變量的值，除非它們是出現在賦值語句的左邊，這種時候 是給對應變量賦予一個新的值。

一個指針的值是另一個變量的地址。一個指針對應變量在內存中的存儲位置。併不是每一個 值都會有一個內存地址，但是對於每一個變量必然有對應的內存地址。通過指針，我們可以直 接讀或更新對應變量的值，而不需要知道該變量的名字（如果變量有名字的話）。

如果用“var x int”聲明語句聲明一個x變量，那麽&x表達式（取x變量的內存地址）將産生一個 指向該整數變量的指針，指針對應的數據類型是 *int ，指針被稱之爲“指向int類型的指針”。 如果指針名字爲p，那麽可以説“p指針指向變量x”，或者説“p指針保存了x變量的內存地址”。 同時 *p 表達式對應p指針指向的變量的值。一般 *p 表達式讀取指針指向的變量的值，這里 爲int類型的值，同時因爲 *p 對應一個變量，所以該表達式也可以出現在賦值語句的左邊，表 示更新指針所指向的變量的值。

x := 1
p := &x	// p, of type *int, points to x
fmt.Println(*p)	// "1"
*p = 2	// equivalent to x = 2
fmt.Println(x)	// "2"

變量

58

Go 语言圣经 中文版

對於聚合類型每個成員——比如結構體的每個字段、或者是數組的每個元素——也都是對應 一個變量，因此可以被取地址。

變量有時候被稱爲可尋址的值。卽使變量由表達式臨時生成，那麽表達式也必鬚能接受 & 取 地址操作。

任何類型的指針的零值都是nil。如果 p != nil 測試爲眞，那麽p是指向某個有效變量。指針 之間也是可以進行相等測試的，隻有當它們指向同一個變量或全部是nil時才相等。

var x, y int

fmt.Println(&x == &x, &x == &y, &x == nil) // "true false false"

在Go語言中，返迴函數中局部變量的地址也是安全的。例如下面的代碼，調用f函數時創建局 部變量v，在局部變量地址被返迴之後依然有效，因爲指針p依然引用這個變量。

var p = f()

func f() *int { v := 1 return &v

}

每次調用f函數都將返迴不同的結果：

fmt.Println(f() == f()) // "false"

因爲指針包含了一個變量的地址，因此如果將指針作爲參數調用函數，那將可以在函數中通 過該指針來更新變量的值。例如下面這個例子就是通過指針來更新變量的值，然後返迴更新 後的值，可用在一個表達式中（譯註：這是對C語言中 ++v 操作的模擬，這里隻是爲了説明 指針的用法，incr函數模擬的做法併不推薦）：

func incr(p *int) int {

*p++ // 非常重要：隻是增加p指向的變量的值，併不改變p指針！！！ return *p

}

v := 1

incr(&v)// side effect: v is now 2 fmt.Println(incr(&v)) // "3" (and v is 3)

每次我們對一個變量取地址，或者複製指針，我們都是爲原變量創建了新的别名。例

如， *p 就是是 變量v的别名。指針特别有價值的地方在於我們可以不用名字而訪問一個變

量，但是這是一把雙刃劍：要找到一個變量的所有訪問者併不容易，我們必鬚知道變量全部

變量

59

Go 语言圣经 中文版

的别名（譯註：這是Go語言的垃圾迴收器所做的工作）。不僅僅是指針會創建别名，很多其 他引用類型也會創建别名，例如slice、map和chan，甚至結構體、數組和接口都會創建所引 用變量的别名。

指針是實現標準庫中flag包的關鍵技術，它使用命令行參數來設置對應變量的值，而這些對應 命令行標誌參數的變量可能會零散分布在整個程序中。爲了説明這一點，在早些的echo版本 中，就包含了兩個可選的命令行參數： -n 用於忽略行尾的換行符， -s sep 用於指定分隔字 符（默認是空格）。下面這是第四個版本，對應包路徑爲gopl.io/ch2/echo4。

gopl.io/ch2/echo4

//Echo4 prints its command-line arguments. package main

import ( "flag" "fmt" "strings"

)

var n = flag.Bool("n", false, "omit trailing newline") var sep = flag.String("s", " ", "separator")

func main() { flag.Parse() fmt.Print(strings.Join(flag.Args(), *sep)) if !*n {

fmt.Println()

}

}

調用flag.Bool函數會創建一個新的對應布爾型標誌參數的變量。它有三個屬性：第一個是的命 令行標誌參數的名字“n”，然後是該標誌參數的默認值（這里是false），最後是該標誌參數對 應的描述信息。如果用⼾在命令行輸入了一個無效的標誌參數，或者輸入 -h 或 -help 參數， 那麽將打印所有標誌參數的名字、默認值和描述信息。類似的，調用flag.String函數將於創建 一個對應字符串類型的標誌參數變量，同樣包含命令行標誌參數對應的參數名、默認值、和 描述信息。程序中的 sep 和 n 變量分别是指向對應命令行標誌參數變量的指針，因此必鬚 用 *sep 和 *n 形式的指針語法間接引用它們。

當程序運行時，必鬚在使用標誌參數對應的變量之前調用先flag.Parse函數，用於更新每個標 誌參數對應變量的值（之前是默認值）。對於非標誌參數的普通命令行參數可以通過調用 flag.Args()函數來訪問，返迴值對應對應一個字符串類型的slice。如果在flag.Parse函數解析 命令行參數時遇到錯誤，默認將打印相關的提示信息，然後調用os.Exit(2)終止程序。

讓我們運行一些echo測試用例：

變量

60

Go 语言圣经 中文版

$go build gopl.io/ch2/echo4

$./echo4 a bc def a bc def

$./echo4 -s / a bc def a/bc/def

$./echo4 -n a bc def a bc def$

$./echo4 -help

Usage of ./echo4:

-n omit trailing newline -s string

separator (default " ")

2.3.3. new函數

另一個創建變量的方法是調用用內建的new函數。表達式new(T)將創建一個T類型的匿名變 量，初始化爲T類型的零值，然後返迴變量地址，返迴的指針類型爲 *T 。

p := new(int) // p, *int 類型, 指向匿名的 int 變量

fmt.Println(*p) // "0"

*p = 2 // 設置 int 匿名變量的值爲 2

fmt.Println(*p) // "2"

用new創建變量和普通變量聲明語句方式創建變量沒有什麽區别，除了不需要聲明一個臨時變 量的名字外，我們還可以在表達式中使用new(T)。換言之，new函數類似是一種語法醣，而 不是一個新的基礎概念。

下面的兩個newInt函數有着相同的行爲：

func newInt() *int {	func newInt() *int {
return new(int)		var dummy int
}		return &dummy
	}

每次調用new函數都是返迴一個新的變量的地址，因此下面兩個地址是不同的：

p := new(int)

q := new(int)

fmt.Println(p == q) // "false"

當然也可能有特殊情況：如果兩個類型都是空的，也就是説類型的大小是0，例

如struct{} 和 [0]int , 有可能有相同的地址（依賴具體的語言實現）（譯註：請謹慎使用大 小爲0的類型，因爲如果類型的大小位0好話，可能導致Go語言的自動垃圾迴收器有不同的行

爲，具體請査看 runtime.SetFinalizer 函數相關文檔）。

變量

61

Go 语言圣经 中文版

new函數使用常見相對比較少，因爲對應結構體來説，可以直接用字面量語法創建新變量的方 法會更靈活（§4.4.1）。

由於new隻是一個預定義的函數，它併不是一個關鍵字，因此我們可以將new名字重新定義爲 别的類型。例如下面的例子：

func delta(old, new int) int { return new - old }

由於new被定義爲int類型的變量名，因此在delta函數內部是無法使用內置的new函數的。

2.3.4.變量的生命週期

變量的生命週期指的是在程序運行期間變量有效存在的時間間隔。對於在包一級聲明的變量 來説，它們的生命週期和整個程序的運行週期是一致的。而相比之下，在局部變量的聲明週 期則是動態的：從每次創建一個新變量的聲明語句開始，直到該變量不再被引用爲止，然後 變量的存儲空間可能被迴收。函數的參數變量和返迴值變量都是局部變量。它們在函數每次 被調用的時候創建。

例如，下面是從1.4節的Lissajous程序摘録的代碼片段：

for t := 0.0; t < cycles*2*math.Pi; t += res { x := math.Sin(t)

y := math.Sin(t*freq + phase) img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5),

blackIndex)

}

譯註：函數的有右小括弧也可以另起一行縮進，同時爲了防止編譯器在行尾自動插入分號而 導致的編譯錯誤，可以在末尾的參數變量後面顯式插入逗號。像下面這樣：

for t		:= 0.0; t < cycles*2*math.Pi; t += res {
	x	:= math.Sin(t)
	y := math.Sin(t*freq + phase)
	img.SetColorIndex(
		size+int(x*size+0.5), size+int(y*size+0.5),
		blackIndex, // 最後插入的逗號不會導致編譯錯誤，這是Go編譯器的一個特性
)		// 小括弧另起一行縮進，和大括弧的風格保存一致
}

在每次循環的開始會創建臨時變量t，然後在每次循環迭代中創建臨時變量x和y。

那麽垃Go語言的自動圾收集器是如何知道一個變量是何時可以被迴收的呢？這里我們可以避 開完整的技術細節，基本的實現思路是，從每個包級的變量和每個當前運行函數的每一個局 部變量開始，通過指針或引用的訪問路徑遍歷，是否可以找到該變量。如果不存在這樣的訪

變量

62

Go 语言圣经 中文版

問路徑，那麽説明該變量是不可達的，也就是説它是否存在併不會影響程序後續的計算結 果。

因爲一個變量的有效週期隻取決於是否可達，因此一個循環迭代內部的局部變量的生命週期 可能超出其局部作用域。同時，局部變量可能在函數返迴之後依然存在。

編譯器會自動選擇在棧上還是在堆上分配局部變量的存儲空間，但可能令人驚訝的是，這個 選擇併不是由用var還是new聲明變量的方式決定的。

var global *int
func f() {		func g() {
	var x int		y := new(int)
	x = 1		*y = 1
	global = &x	}
}

這里的x變量必鬚在堆上分配，因爲它在函數退出後依然可以通過包一級的global變量找到， 雖然它是在函數內部定義的；用Go語言的術語説，這個x局部變量從函數f中逃逸了。相反， 當g函數返迴時，變量 *y 將是不可達的，也就是説可以馬上被迴收的。因此， *y 併沒有從 函數g中逃逸，編譯器可以選擇在棧上分配 *y 的存儲空間（譯註：也可以選擇在堆上分配， 然後由Go語言的GC迴收這個變量的內存空間），雖然這里用的是new方式。其實在任何時 候，你併不需爲了編寫正確的代碼而要考慮變量的逃逸行爲，要記住的是，逃逸的變量需要 額外分配內存，同時對性能的優化可能會産生細微的影響。

Go語言的自動垃圾收集器對編寫正確的代碼是一個鉅大的幫助，但也併不是説你完全不用考 慮內存了。你雖然不需要顯式地分配和釋放內存，但是要編寫高效的程序你依然需要了解變量 的生命週期。例如，如果將指向短生命週期對象的指針保存到具有長生命週期的對象中，特 别是保存到全局變量時，會阻止對短生命週期對象的垃圾迴收（從而可能影響程序的性

能）。

變量

63

Go 语言圣经 中文版

2.4.賦值

使用賦值語句可以更新一個變量的值，最簡單的賦值語句是將要被賦值的變量放在=的左邊， 新值的表達式放在=的右邊。

	x = 1	// 命令變量的賦值
	*p = true	// 通過指針間接賦值
	person.name = "bob"	// 結構體字段賦值

count[x] = count[x] * scale // 數組、slice或map的元素賦值

特定的二元算術運算符和賦值語句的複合操作有一個簡潔形式，例如上面最後的語句可以重 寫爲：

count[x] *= scale

這樣可以省去對變量表達式的重複計算。

數值變量也可以支持 ++ 遞增和 -- 遞減語句（譯註：自增和自減是語句，而不是表達式，因 此 x = i++ 之類的表達式是錯誤的）：

v := 1
v++	// 等價方式 v = v + 1；v 變成 2
v--	// 等價方式 v = v - 1；v 變成 1

2.4.1.元組賦值

元組賦值是另一種形式的賦值語句，它允許同時更新多個變量的值。在賦值之前，賦值語句 右邊的所有表達式將會先進行求值，然後再統一更新左邊對應變量的值。這對於處理有些同 時出現在元組賦值語句左右兩邊的變量很有幫助，例如我們可以這樣交換兩個變量的值：

x, y = y, x

a[i], a[j] = a[j], a[i]

或者是計算兩個整數值的的最大公約數（GCD）（譯註：GCD不是那個敏感字，而是 greatest common divisor的縮寫，歐幾里德的GCD是最早的非平凡算法）：

賦值

64

Go 语言圣经 中文版

func gcd(x, y int) int { for y != 0 {

x, y = y, x%y

}

return x

}

或者是計算斐波納契數列（Fibonacci）的第N個數：

func fib(n int) int {

x, y := 0, 1

for i := 0; i < n; i++ {

x, y = y, x+y

}

return x

}

元組賦值也可以使一繫列瑣碎賦值更加緊湊（譯註: 特别是在for循環的初始化部分），

i, j, k = 2, 3, 5

但如果表達式太複雜的話，應該盡量避免過度使用元組賦值；因爲每個變量單獨賦值語句的 寫法可讀性會更好。

有些表達式會産生多個值，比如調用一個有多個返迴值的函數。當這樣一個函數調用出現在 元組賦值右邊的表達式中時（譯註：右邊不能再有其它表達式），左邊變量的數目必鬚和右 邊一致。

f, err = os.Open("foo.txt") // function call returns two values

通常，這類函數會用額外的返迴值來表達某種錯誤類型，例如os.Open是用額外的返迴值返迴 一個error類型的錯誤，還有一些是用來返迴布爾值，通常被稱爲ok。在稍後我們將看到的三 個操作都是類似的用法。如果map査找（§4.3）、類型斷言（§7.10）或通道接收（§8.4.2） 出現在賦值語句的右邊，它們都可能會産生兩個結果，有一個額外的布爾結果表示操作是否 成功：

v, ok = m[key]	// map lookup
v, ok = x.(T)	// type assertion
v, ok = <-ch	// channel receive

譯註：map査找（§4.3）、類型斷言（§7.10）或通道接收（§8.4.2）出現在賦值語句的右邊 時，併不一定是産生兩個結果，也可能隻産生一個結果。對於值産生一個結果的情形，map 査找失敗時會返迴零值，類型斷言失敗時會發送運行時panic異常，通道接收失敗時會返迴零

賦值

65

Go 语言圣经 中文版

值（阻塞不算是失敗）。例如下面的例子：

v = m[key]	// map査找，失敗時返迴零值
v = x.(T)	// type斷言，失敗時panic異常
v = <-ch	// 管道接收，失敗時返迴零值（阻塞不算是失敗）
_, ok = m[key]	// map返迴2個值
_, ok = mm[""], false	// map返迴1個值
_ = mm[""]	// map返迴1個值

和變量聲明一樣，我們可以用下劃線空白標識符 _ 來丟棄不需要的值。

_, err = io.Copy(dst, src) // 丟棄字節數

_, ok = x.(T)

// 隻檢測類型，忽略具體值

2.4.2.可賦值性

賦值語句是顯式的賦值形式，但是程序中還有很多地方會發生隱式的賦值行爲：函數調用會 隱式地將調用參數的值賦值給函數的參數變量，一個返迴語句將隱式地將返迴操作的值賦值 給結果變量，一個複合類型的字面量（§4.2）也會産生賦值行爲。例如下面的語句：

medals := []string{"gold", "silver", "bronze"}

隱式地對slice的每個元素進行賦值操作，類似這樣寫的行爲：

medals[0] = "gold"

medals[1] = "silver"

medals[2] = "bronze"

map和chan的元素，雖然不是普通的變量，但是也有類似的隱式賦值行爲。

不管是隱式還是顯式地賦值，在賦值語句左邊的變量和右邊最終的求到的值必鬚有相同的數 據類型。更直白地説，隻有右邊的值對於左邊的變量是可賦值的，賦值語句才是允許的。

可賦值性的規則對於不同類型有着不同要求，對每個新類型特殊的地方我們會專門解釋。對 於目前我們已經討論過的類型，它的規則是簡單的：類型必鬚完全匹配，nil可以賦值給任何 指針或引用類型的變量。常量（§3.6）則有更靈活的賦值規則，因爲這樣可以避免不必要的 顯式的類型轉換。

對於兩個值是否可以用 == 或 != 進行相等比較的能力也和可賦值能力有關繫：對於任何類型 的值的相等比較，第二個值必鬚是對第一個值類型對應的變量是可賦值的，反之依然。和前 面一樣，我們會對每個新類型比較特殊的地方做專門的解釋。