Go 程式的基本結構和要素

示例

package main

import "fmt"

func main() {
    fmt.Println("hello, world")
}
           

包的概念、導入與可見性

包是結構化代碼的一種方式：每個程式都由包（通常簡稱為 pkg）的概念組成，可以使用自身的包或者從其它包中導入内容。

如同其它一些程式設計語言中的類庫或命名空間的概念，每個 Go 檔案都屬于且僅屬于一個包。一個包可以由許多以 .go 為擴充名的源檔案組成，是以檔案名和包名一般來說都是不相同的。

你必須在源檔案中非注釋的第一行指明這個檔案屬于哪個包，如：package main。package main表示一個可獨立執行的程式，每個 Go 應用程式都包含一個名為 main 的包。

一個應用程式可以包含不同的包，而且即使你隻使用 main 包也不必把所有的代碼都寫在一個巨大的檔案裡：你可以用一些較小的檔案，并且在每個檔案非注釋的第一行都使用 package main 來指明這些檔案都屬于 main 包。如果你打算編譯包名不是為 main 的源檔案，如 pack1，編譯後産生的對象檔案将會是 pack1.a 而不是可執行程式。另外要注意的是，所有的包名都應該使用小寫字母。

标準庫

在 Go 的安裝檔案裡包含了一些可以直接使用的包，即标準庫。在 Windows 下，标準庫的位置在 Go 根目錄下的子目錄 pkg\windows_386 中；在 Linux 下，标準庫在 Go 根目錄下的子目錄 pkg\linux_amd64 中（如果是安裝的是 32 位，則在 linux_386 目錄中）。一般情況下，标準包會存放在 $GOROOT/pkg/$GOOS_$GOARCH/ 目錄下。

Go 的标準庫包含了大量的包（如：fmt 和 os），但是你也可以建立自己的包。

如果想要建構一個程式，則包和包内的檔案都必須以正确的順序進行編譯。包的依賴關系決定了其建構順序。

屬于同一個包的源檔案必須全部被一起編譯，一個包即是編譯時的一個單元，是以根據慣例，每個目錄都隻包含一個包。

如果對一個包進行更改或重新編譯，所有引用了這個包的用戶端程式都必須全部重新編譯。

Go 中的包模型采用了顯式依賴關系的機制來達到快速編譯的目的，編譯器會從字尾名為 .o 的對象檔案（需要且隻需要這個檔案）中提取傳遞依賴類型的資訊。

如果 A.go 依賴 B.go，而 B.go 又依賴 C.go：

編譯 C.go, B.go, 然後是 A.go.

為了編譯 A.go, 編譯器讀取的是 B.o 而不是 C.o.

這種機制對于編譯大型的項目時可以顯著地提升編譯速度。

每一段代碼隻會被編譯一次

一個 Go 程式是通過 import 關鍵字将一組包連結在一起。

import "fmt" 告訴 Go 編譯器這個程式需要使用 fmt 包（的函數，或其他元素），fmt 包實作了格式化 IO（輸入/輸出）的函數。包名被封閉在半角雙引号 "" 中。如果你打算從已編譯的包中導入并加載公開聲明的方法，不需要插入已編譯包的源代碼。

如果需要多個包，它們可以被分别導入：

import "fmt"
import "os"
           

或：

import "fmt"; import "os"
           

但是還有更短且更優雅的方法（被稱為因式分解關鍵字，該方法同樣适用于 const、var 和 type 的聲明或定義）：

import (
   "fmt"
   "os"
)
           

它甚至還可以更短的形式，但使用 gofmt 後将會被強制換行：

import ("fmt"; "os")
           

當你導入多個包時，最好按照字母順序排列包名，這樣做更加清晰易讀。

如果包名不是以 . 或 / 開頭，如 "fmt" 或者 "container/list"，則 Go 會在全局檔案進行查找；如果包名以 ./ 開頭，則 Go 會在相對目錄中查找；如果包名以 / 開頭（在 Windows 下也可以這樣使用），則會在系統的絕對路徑中查找。

導入包即等同于包含了這個包的所有的代碼對象。

除了符号 _，包中所有代碼對象的辨別符必須是唯一的，以避免名稱沖突。但是相同的辨別符可以在不同的包中使用，因為可以使用包名來區分它們。

包通過下面這個被編譯器強制執行的規則來決定是否将自身的代碼對象暴露給外部檔案：

可見性規則

當辨別符（包括常量、變量、類型、函數名、結構字段等等）以一個大寫字母開頭，如：Group1，那麼使用這種形式的辨別符的對象就可以被外部包的代碼所使用（用戶端程式需要先導入這個包），這被稱為導出（像面向對象語言中的 public）；辨別符如果以小寫字母開頭，則對包外是不可見的，但是他們在整個包的内部是可見并且可用的（像面向對象語言中的 private ）。

（大寫字母可以使用任何 Unicode 編碼的字元，比如希臘文，不僅僅是 ASCII 碼中的大寫字母）。

是以，在導入一個外部包後，能夠且隻能夠通路該包中導出的對象。

假設在包 pack1 中我們有一個變量或函數叫做 Thing（以 T 開頭，是以它能夠被導出），那麼在目前包中導入 pack1 包，Thing 就可以像面向對象語言那樣使用點标記來調用：pack1.Thing（pack1 在這裡是不可以省略的）。

是以包也可以作為命名空間使用，幫助避免命名沖突（名稱沖突）：兩個包中的同名變量的差別在于他們的包名，例如 pack1.Thing 和 pack2.Thing。

你可以通過使用包的别名來解決包名之間的名稱沖突，或者說根據你的個人喜好對包名進行重新設定，如：import fm "fmt"。下面的代碼展示了如何使用包的别名：

alias.go

package main

import fm "fmt" // alias3

func main() {
   fm.Println("hello, world")
}
           

注意事項

如果你導入了一個包卻沒有使用它，則會在建構程式時引發錯誤，如 imported and not used: os，這正是遵循了 Go 的格言：“沒有不必要的代碼！“。

包的分級聲明和初始化

你可以在使用 import 導入包之後定義或聲明 0 個或多個常量（const）、變量（var）和類型（type），這些對象的作用域都是全局的（在本包範圍内），是以可以被本包中所有的函數調用（如 gotemplate.go 源檔案中的 c 和 v），然後聲明一個或多個函數（func）。

函數

這是定義一個函數最簡單的格式：

func functionName()
           

你可以在括号 () 中寫入 0 個或多個函數的參數（使用逗号 , 分隔），每個參數的名稱後面必須緊跟着該參數的類型。

main 函數是每一個可執行程式所必須包含的，一般來說都是在啟動後第一個執行的函數（如果有 init() 函數則會先執行該函數）。如果你的 main 包的源代碼沒有包含 main 函數，則會引發建構錯誤 undefined: main.main。main 函數既沒有參數，也沒有傳回類型（與 C 家族中的其它語言恰好相反）。如果你不小心為 main 函數添加了參數或者傳回類型，将會引發建構錯誤：

func main must have no arguments and no return values results.
           

在程式開始執行并完成初始化後，第一個調用（程式的入口點）的函數是 main.main()（如：C 語言），該函數一旦傳回就表示程式已成功執行并立即退出。

函數裡的代碼（函數體）使用大括号 {} 括起來。

左大括号 { 必須與方法的聲明放在同一行，這是編譯器的強制規定，否則你在使用 gofmt 時就會出現錯誤提示：

build-error: syntax error: unexpected semicolon or newline before {

（這是因為編譯器會産生 func main() ; 這樣的結果，很明顯這錯誤的）

Go 語言雖然看起來不使用分号作為語句的結束，但實際上這一過程是由編譯器自動完成，是以才會引發像上面這樣的錯誤

右大括号 } 需要被放在緊接着函數體的下一行。如果你的函數非常簡短，你也可以将它們放在同一行：

func Sum(a, b int) int { return a + b }
           

對于大括号 {} 的使用規則在任何時候都是相同的（如：if 語句等）。

是以符合規範的函數一般寫成如下的形式：

func functionName(parameter_list) (return_value_list) {
   …
}
           

其中：

parameter_list

的形式為

(param1 type1, param2 type2, …)

return_value_list 的形式為 (ret1 type1, ret2 type2, …)

隻有當某個函數需要被外部包調用的時候才使用大寫字母開頭，并遵循 Pascal 命名法；否則就遵循駱駝命名法，即第一個單詞的首字母小寫，其餘單詞的首字母大寫。

下面這一行調用了 fmt 包中的 Println 函數，可以将字元串輸出到控制台，并在最後自動增加換行字元 \n：

fmt.Println（"hello, world"）
           

使用

fmt.Print("hello, world\n")

可以得到相同的結果。

Print 和 Println 這兩個函數也支援使用變量，如：fmt.Println(arr)。如果沒有特别指定，它們會以預設的列印格式将變量 arr 輸出到控制台。

單純地列印一個字元串或變量甚至可以使用預定義的方法來實作，如：print、println：print("ABC")、println("ABC")、println(i)（帶一個變量 i）。

這些函數隻可以用于調試階段，在部署程式的時候務必将它們替換成 fmt 中的相關函數。

當被調用函數的代碼執行到結束符 } 或傳回語句時就會傳回，然後程式繼續執行調用該函數之後的代碼。

程式正常退出的代碼為 0 即 Program exited with code 0；如果程式因為異常而被終止，則會傳回非零值，如：1。這個數值可以用來測試是否成功執行一個程式。

注釋

hello_world2.go

package main

import "fmt" // Package implementing formatted I/O.

func main() {
   fmt.Printf("Καλημέρα κόσμε; or こんにちは 世界\n")
}
           

上面這個例子通過列印

Καλημέρα κόσμε; or こんにちは 世界

展示了如何在 Go 中使用國際化字元，以及如何使用注釋。

注釋不會被編譯，但可以通過 godoc 來使用。

單行注釋是最常見的注釋形式，你可以在任何地方使用以 // 開頭的單行注釋。多行注釋也叫塊注釋，均已以 /* 開頭，并以 */ 結尾，且不可以嵌套使用，多行注釋一般用于包的文檔描述或注釋成塊的代碼片段。

每一個包應該有相關注釋，在 package 語句之前的塊注釋将被預設認為是這個包的文檔說明，其中應該提供一些相關資訊并對整體功能做簡要的介紹。一個包可以分散在多個檔案中，但是隻需要在其中一個進行注釋說明即可。當開發人員需要了解包的一些情況時，自然會用 godoc 來顯示包的文檔說明，在首行的簡要注釋之後可以用成段的注釋來進行更詳細的說明，而不必擁擠在一起。另外，在多段注釋之間應以空行分隔加以區分。

示例：

// Package superman implements methods for saving the world.
//
// Experience has shown that a small number of procedures can prove
// helpful when attempting to save the world.
package superman
           

幾乎所有全局作用域的類型、常量、變量、函數和被導出的對象都應該有一個合理的注釋。如果這種注釋（稱為文檔注釋）出現在函數前面，例如函數 Abcd，則要以 "Abcd..." 作為開頭。

// enterOrbit causes Superman to fly into low Earth orbit, a position
// that presents several possibilities for planet salvation.
func enterOrbit() error {
   ...
}
           

godoc 工具會收集這些注釋并産生一個技術文檔。

類型

可以包含資料的變量（或常量），可以使用不同的資料類型或類型來儲存資料。使用 var 聲明的變量的值會自動初始化為該類型的零值。類型定義了某個變量的值的集合與可對其進行操作的集合。

類型可以是基本類型，如：int、float、bool、string；結構化的（複合的），如：struct、array、slice、map、channel；隻描述類型的行為的，如：interface。

結構化的類型沒有真正的值，它使用 nil 作為預設值（在 Objective-C 中是 nil，在 Java 中是 null，在 C 和 C++ 中是NULL或 0）。值得注意的是，Go 語言中不存在類型繼承。

函數也可以是一個确定的類型，就是以函數作為傳回類型。這種類型的聲明要寫在函數名和可選的參數清單之後，例如：

func FunctionName (a typea, b typeb) typeFunc
           

你可以在函數體中的某處傳回使用類型為 typeFunc 的變量 var：

return var
           

一個函數可以擁有多傳回值，傳回類型之間需要使用逗号分割，并使用小括号 () 将它們括起來，如：

func FunctionName (a typea, b typeb) (t1 type1, t2 type2)
           

示例： 函數 Atoi：

func Atoi(s string) (i int, err error)
           

傳回的形式：

return var1, var2
           

這種多傳回值一般用于判斷某個函數是否執行成功（true/false）或與其它傳回值一同傳回錯誤消息（詳見之後的并行指派）。

使用 type 關鍵字可以定義你自己的類型，你可能想要定義一個結構體，但是也可以定義一個已經存在的類型的别名，如：

type IZ int
           

這裡并不是真正意義上的别名，因為使用這種方法定義之後的類型可以擁有更多的特性，且在類型轉換時必須顯式轉換。

然後我們可以使用下面的方式聲明變量：

var a IZ = 5
           

這裡我們可以看到 int 是變量 a 的底層類型，這也使得它們之間存在互相轉換的可能。

如果你有多個類型需要定義，可以使用因式分解關鍵字的方式，例如：

type (
   IZ int
   FZ float64
   STR string
)
           

每個值都必須在經過編譯後屬于某個類型（編譯器必須能夠推斷出所有值的類型），因為 Go 語言是一種靜态類型語言。

Go 程式的一般結構

下面的程式可以被順利編譯但什麼都做不了，不過這很好地展示了一個 Go 程式的首選結構。這種結構并沒有被強制要求，編譯器也不關心 main 函數在前還是變量的聲明在前，但使用統一的結構能夠在從上至下閱讀 Go 代碼時有更好的體驗。

所有的結構将在這一章或接下來的章節中進一步地解釋說明，但總體思路如下：

• 在完成包的 import 之後，開始對常量、變量和類型的定義或聲明。
• 如果存在 init 函數的話，則對該函數進行定義（這是一個特殊的函數，每個含有該函數的包都會首先執行這個函數）。
• 如果目前包是 main 包，則定義 main 函數。
• 然後定義其餘的函數，首先是類型的方法，接着是按照 main 函數中先後調用的順序來定義相關函數，如果有很多函數，則可以按照字母順序來進行排序。

示例 gotemplate.go

package main

import (
   "fmt"
)

const c = "C"

var v int = 5

type T struct{}

func init() { // initialization of package
}

func main() {
   var a int
   Func1()
   // ...
   fmt.Println(a)
}

func (t T) Method1() {
   //...
}

func Func1() { // exported function Func1
   //...
}
           

Go 程式的執行（程式啟動）順序如下：

1. 按順序導入所有被 main 包引用的其它包，然後在每個包中執行如下流程：
2. 如果該包又導入了其它的包，則從第一步開始遞歸執行，但是每個包隻會被導入一次。
3. 然後以相反的順序在每個包中初始化常量和變量，如果該包含有 init 函數的話，則調用該函數。
4. 在完成這一切之後，main 也執行同樣的過程，最後調用 main 函數開始執行程式。

類型轉換

在必要以及可行的情況下，一個類型的值可以被轉換成另一種類型的值。由于 Go 語言不存在隐式類型轉換，是以所有的轉換都必須顯式說明，就像調用一個函數一樣（類型在這裡的作用可以看作是一種函數）：

valueOfTypeB = typeB(valueOfTypeA)

類型 B 的值 = 類型 B(類型 A 的值)

a := 5.0
b := int(a)
           

但這隻能在定義正确的情況下轉換成功，例如從一個取值範圍較小的類型轉換到一個取值範圍較大的類型（例如将 int16 轉換為 int32）。當從一個取值範圍較大的轉換到取值範圍較小的類型時（例如将 int32 轉換為 int16 或将 float32 轉換為 int），會發生精度丢失（截斷）的情況。當編譯器捕捉到非法的類型轉換時會引發編譯時錯誤，否則将引發運作時錯誤。

具有相同底層類型的變量之間可以互相轉換：

var a IZ = 5
c := int(a)
d := IZ(c)
           

Go 命名規範

幹淨、可讀的代碼和簡潔性是 Go 追求的主要目标。通過 gofmt 來強制實作統一的代碼風格。Go 語言中對象的命名也應該是簡潔且有意義的。像 Java 和 Python 中那樣使用混合着大小寫和下劃線的冗長的名稱會嚴重降低代碼的可讀性。名稱不需要指出自己所屬的包，因為在調用的時候會使用包名作為限定符。傳回某個對象的函數或方法的名稱一般都是使用名詞，沒有 Get... 之類的字元，如果是用于修改某個對象，則使用 SetName。有必須要的話可以使用大小寫混合的方式，如 MixedCaps 或 mixedCaps，而不是使用下劃線來分割多個名稱。