go 學習筆記之有意思的變數和不安分的常量

• 2019 年 10 月 3 日
• 筆記

首先希望學習 Go 語言的愛好者至少擁有其他語言的編程經驗,如果是完全零基礎的小白用戶,本教程可能並不適合閱讀或嘗試閱讀看看,系列筆記的目標是站在其他語言的角度學習新的語言,理解 Go 語言,進而寫出真正的 Go 程式.

程式語言中一般都有變數和常量的概念,對於學習新語言也是一樣,變數指的是不同程式語言的特殊之處,而常量就是程式語言的共同點.

學習 Go 語言時儘可能站在宏觀角度上分析變數,而常量可能一笑而過或者程式語言不夠豐富,所謂的常量其實也是變數,不管怎麼樣現在讓我們開始 Go 語言的學習之旅吧,本教程涉及到的源碼已託管於 github,如需獲取源碼,請直接訪問 https://github.com/snowdreams1006/learn-go

編寫第一個 Hello World 程式

學習程式語言的第一件事就是編寫出 Hello World,現在讓我們用 Go 語言開發出第一個可運行的命令行程式吧!

環境前提準備可以參考 走進Goland編輯器

新建 main 目錄,並新建 hello_world.go 文件,其中文件類型選擇 Simple Application ,編輯器會幫助我們創建 Go 程式骨架.

首先輸入 fmt 後觸發語法提示選擇 fmt.Println ,然後會自動導入 fmt 包.

完整內容如下,僅供參考:

package main    import "fmt"    func main() {      fmt.Println("Hello World")  }

點擊左側綠色啟動按鈕,可以直接運行程式或者利用程式自帶的 Terminal 終端選項卡運行程式,當然也可以用外部命令行工具運行程式.

go run 命令直接運行,而 go build 命令產生可執行文件,兩種方式都能如願以償輸出 Hello World .

知識點歸納

Go 應用程式入口的有以下要求:

• 必須是 main 包 :package main
• 必須是 main 方法 : func main()
• 文件名任意不一定是 main.go,目錄名也任意不一定是 main 目錄.

以上規則可以很容易在編輯器中得到驗證,任意一條不符合規則,程式都會報錯提示,這也是使用編輯器而不是命令行進行學習的原因,能夠幫助我們及時發現錯誤,方便隨時驗證猜想.

總結來說,main 包不一定在 main 目錄下,main 方法可以在任意文件中.

這也意味著程式入口所在的目錄不一定叫做 main 目錄卻一定要聲明為 main 包,雖然不理解為什麼這麼設計,這一點至少和 Java 完全不一樣,至少意味著 Go文件可以直接遷移目錄而不需要語言層面的重構,可能有點方面,同時也有點疑惑?!

main 函數值得注意的不同之處:

• main 函數不支援返回值,但可以通過 os.Exit 返回退出狀態

main 函數,不支援返回值,若此時強行運行 main 方法,則會報錯: func main must have no arguments and no return values

main 函數可以藉助 os.Exit(-1) 返回程式退出時狀態碼,外界可以根據不同狀態碼識別相應狀態.

• main 函數不支援傳入參數,但可以通過 os.Args 獲取參數

在 Terminal 終端選項卡中運行 go run hello_world.go snowdreams1006 命令 os.Args 輸出命令路徑和參數值.

在測試用例中邊學邊練基礎語法

The master has failed more times than the beginner has tried

電腦編程不是理科而是工科,動手親自實踐一遍才能更好地掌握知識技能,幸運的是,Go 語言本身內置提供了測試框架,不用載入第三方類庫擴展,非常有利於學習練習.

剛剛接觸 Go 語言,暫時不需要深入講解如何編寫規範的測試程式,畢竟基礎語法還沒開始正式練習呢!

但是,簡單的規則還是要說的,總體來說,只有兩條規則:

• 測試文件名以 _test 結尾 : XXX_test.go

命令習慣和不同, Java 中的文件名一般是大駝峰命名法,相應的測試文件是 XXXTest

• 測試方法名以 Test 開頭 : TestXXX

命名習慣和其他程式語言不同,Java 中的測試方法命名是一般是小駝峰命名法,相應的測試方法是 testXXX

• 測試方法有著固定的參數 : t *testing.T

其他程式語言中一般沒有參數,Java 中的測試方法一定沒有參數,否則拋出異常 java.lang.Exception: Method testXXX should have no parameters

新建 Go 文件,類型選擇 Empty File ,文件名命名為 hello_world_test ,編輯器新建一個空白的測試文件.

此時編寫測試方法簽名,利用編輯器自動提示功能輸入 t.Log 隨便輸出些內容,這樣就完成了第一個測試文件.

和 main 程式一樣,測試方法也是可執行的,編輯器窗口的左側也會出現綠色啟動按鈕,運行測試用例在編輯器下方的控制台窗口輸出 PASS 證明測試邏輯正確!

測試文件源碼示例:

package main    import "testing"    func TestHelloWorld(t *testing.T){      t.Log("Hello Test")  }

現在已經學習了兩種基本方式,一種是把程式寫在 main 方法中,另一種是把程式寫在測試方法中.

兩種方式都可以隨時測試驗證我們的學習成果,如果寫在 main 方法中,知識點一般要包裝成單獨的方法,然後再在 main 方法中運行該方法.

如果寫在測試方法中,可以單獨運行測試方法,而不必在 main 方法中一次性全部運行.

當然,這兩種方式都可以,只不過個人傾向於測試用例方式.

實現 Fibonacci 數列

形如 1,1,2,3,5,8,13,... 形式的數列就是斐波那契數列,特點是從三個元素開始,下一個元素的值就是前兩兩個元素值的總和,子子孫孫無窮盡也!

記得學習初中歷史時,關於昭君出塞的故事廣為人知,王昭君的美貌不是此次討論的重點,而此次關注點是放到了昭君的悲慘人生.

漢朝和匈奴和親以換取邊境和平,漢朝皇帝不願意自己的親閨女遠嫁塞北,於是從後宮中挑選了一名普通宮女充當和親對象,誰成想這名宮女竟長得如此美貌,"沉魚落雁閉月羞花",堪稱古代中國四大美女之一!

昭君擔負著和親重任,從此開始了遠離他鄉的悲慘生活,一路上,黃沙飛揚,燥熱憂傷,情之所至,昭君拿出隨性的琵琶,演奏出感人淚下的<<琵琶怨>>!

"千載琵琶作胡語,分明怨恨曲中論",可能情感過於哀傷,竟然連天上的大雁都忘記了飛翔,因此收穫落雁之美!

老單于這個肥波納了個如花似玉的妾,做夢都能了醒吧,遺憾的是,命不久矣!

如此一來,昭君卻滿心歡喜,異族老公死了,使命完成了,應該能回到朝思夢想的大漢朝故土了吧?

命運弄人,匈奴文化,父死子繼,肥波已逝,但還有小肥波啊,放到漢朝倫理綱常來看,都不能叫做近親結婚了簡直是亂倫好嗎!

小肥波+昭君=小小肥波 ,只要昭君不死,而昭君的現任老公不幸先死,那麼小小肥波又會繼續納妾生娃,理論上真的是子子孫孫無窮盡也!

肥波納妾故事可能長成這個樣子:

• 肥波,昭君,小肥波

昭君的第一任老公: 肥波+昭君=小肥波,此時昭君剛生一個娃

• 肥波,小肥波,昭君,小小肥波

昭君的第二任老公: 小肥波+昭君=小小肥波,昭君的娃娶了自己的媽?難怪昭君苦楚悲慘,有苦難言,幸運的是,這次昭君沒有生娃,兩個女孩!

• 肥波,小肥波,小小肥波,昭君

昭君的第三任老公,小小肥波+昭君=小小小肥波 ,兄終弟及,還是亂倫好嗎,這輩分我是算不出來了.

肥波納妾系列,理論上和愚公移山有的一拼,生命不息,子承父業也好,兄終弟及也罷,數量越來越多,肚子越來越大.

以上故事,純屬虛構,昭君出塞是一件偉大的事情,換來了百年和平,值得尊敬.

回歸正題,下面讓我們用 Go 語言實現斐波那契數列吧!

func TestFib(t *testing.T) {      var a = 1      var b = 1        fmt.Print(a)      for i := 0; i < 6; i++ {          fmt.Print(" ", b)            temp := a          a = b          b = temp + b      }      fmt.Println()  }

上述簡單示例,展示了變數的基本使用,簡單總結如下:

• 變數聲明關鍵字用 var ,類型名在前,變數類型在後,其中變數類型可以省略.

// 聲明變數a和變數b  var a = 1  var b = 1

上述變數語法咋一看像是 Js 賦值,嚴格來說其實並不是那樣,上面變數賦值形式只是下面這種的簡化

// 聲明變數a並指定類型為 int,同理聲明變數b並指定類型為int  var a int = 1  var b int = 1

第一種寫法省略了 int 類型,由賦值 1 自動推斷為 int 在一定程度上簡化了書寫,當然這種形式還可以繼續簡化.

// 省略相同的 var,增加一對小括弧 (),將變數放到小括弧裡面  var (      a = 1      b = 1  )

可能問,還能不能繼續簡化下,畢竟其餘語言的簡化形式可不是那樣的,答案是可以的!

// 連續聲明變數並賦值  var a, b = 1, 1

當然,其餘語言也有類似的寫法,這並不值得驕傲,下面這種形式才是 Go 語言特有的精簡版形式.

// 省略了關鍵字var,賦值符號=改成了:=,表示聲明變數並賦值  a, b := 1, 1

就問你服不服?一個小小的變數賦值都能玩出五種花樣,厲害了,我的 Go !

• 變數類型可以省略,由編譯器自動進行類型推斷

類似 Js 的書寫習慣,但本質上仍然是強類型,不會進行不同類型的自動轉換,還會說像 Js 的變數嗎?

• 同一個變數語句可以對不同變數進行同時賦值

仍然以斐波那契數列為例,Go 官網的示例中使用到的就是變數同時賦值的特性,完整程式碼如下:

package main    import "fmt"    // fib returns a function that returns  // successive Fibonacci numbers.  func fib() func() int {      a, b := 0, 1      return func() int {          a, b = b, a+b          return a      }  }    func main() {      f := fib()      // Function calls are evaluated left-to-right.      fmt.Println(f(), f(), f(), f(), f())  }

如果對該特性認識不夠清晰,可能覺得這並不是什麼大不了的事情嘛!

實際上,俗話說,沒有對比就沒有傷害,舉一個簡單的例子: 交換變數

func TestExchange(t *testing.T) {      a, b := 1, 2      t.Log(a,b)        a, b = b, a      t.Log(a,b)        temp := a      a = b      b = temp      t.Log(a,b)  }

其他語言中如果需要交換兩個變數,一般都是引入第三個臨時變數的寫法,而 Go 實現變數交換則非常簡單清晰,也符合人的思考而不是電腦的思考.

雖然不清楚底層會不會仍然是採用臨時變數交換,但不管怎麼說,使用該特性交換變數確實很方便!

同時對多個變數進行賦值是 Go 特有的語法,其他語言可以同時聲明多個變數但不能同時賦值.

• 常量同樣很有意思,也有關鍵字聲明 const.

有些程式語言對常量和變數沒有強制規定,常量可以邏輯上被視為不會修改的變數,一般用全大寫字母提示用戶是常量,為了防止常量被修改,有的程式語言可能會有額外的關鍵字進行約束.

幸運的是,Go 語言的常量提供了關鍵字 const 約束,並且禁止重複賦值,這一點很好,簡單方便.

func TestConst(t *testing.T) {      const pi = 3.14      t.Log(pi)        // cannot assign to pi      pi = 2.828      t.Log(pi)  }

除了語言層面的 const 常量關鍵字,Go 語言還要一個特殊的關鍵字 iota ,常常和常量一起搭配使用!

當設置一些連續常量值或者有一定規律的常量值時,iota 可以幫助我們快速設置.

func TestConstForIota(t *testing.T) {      const (          Mon = 1 + iota          Tue          Wed          Thu          Fri          Sat          Sun      )      // 1 2 3 4 5 6 7      t.Log(Mon, Tue, Wed, Thu, Fri, Sat, Sun)  }

大多數程式語言中,星期一代表的數字幾乎都是 0,星期二是 1,以此類推,導致和傳統認識上偏差,為了校準偏差,更加符合國人習慣,因此將星期一代表的數字 0 加一,以此類推,設置初始 iota 後就可以剩餘星期應用該規律,依次 1,2,3,4,5,6,7

如果不使用 iota 的話,可能需要手動進行連續賦值,比較繁瑣,引入了 iota 除了幫助快速設置,還可以進行比特位級別的操作.

func TestConstForIota(t *testing.T) {      const (          Readable = 1 << iota          Writing          Executable      )      // 0001 0010 0100 即 1 2 4      t.Log(Readable, Writing, Executable)  }

第一位比特位為 1 時,表示文件可讀,第二位比特位為 1 時,表示可寫,第三位比特位為 1 時,表示可執行,相應的 10 進位數值依次為 1,2,4 也就是左移一位,左移兩位,左移三位,數學上也可以記成 2^0,2^1,2^2 .

文件的可讀,可寫,可執行三種狀態代表了文件的許可權狀態碼,從而實現了文件的基本許可權操作,常見的許可權碼有 755 和 644.

按位與 & 運算與程式語言無關,"兩位同時為 1 時,按位與的結果才為 1 ,否則結果為 0 ",因此給定許可權碼我們可以很方便判斷該許可權是否擁有可讀,可寫,可執行等許可權.

// 0111 即 7,表示可讀,可寫,可執行  accessCode := 7  t.Log(accessCode&Readable == Readable, accessCode&Writing == Writing, accessCode&Executable == Executable)    // 0110 即 6,表示不可讀,可寫,可執行  accessCode = 6  t.Log(accessCode&Readable == Readable, accessCode&Writing == Writing, accessCode&Executable == Executable)    // 0100 即 4,表示不可讀,不可寫,可執行  accessCode = 4  t.Log(accessCode&Readable == Readable, accessCode&Writing == Writing, accessCode&Executable == Executable)    // 0000 即 0,表示不可讀,不可寫,不可執行  accessCode = 0  t.Log(accessCode&Readable == Readable, accessCode&Writing == Writing, accessCode&Executable == Executable)

accessCode&Readable 表示目標許可權碼和可讀許可權碼進行按位與運算,而可讀許可權碼的二進位表示值為 0001 ,因此只要目標許可權碼的二進位表示值第一位是 1 ,按位與的結果肯定是 0001 ,而 0001 又剛好是可讀許可權碼,所以 accessCode&Readable == Readable 為 true 就意味著目標許可權碼擁有可讀許可權.

如果目標許可權碼的二進位位第一個不是 1 而是 0,則 0&1=0 ,(0|1)^0=0,所以按位與運算結果肯定全是 0 即 0000,此時 0000 == 0001 比較值 false ,也就是該許可權碼不可讀.

同理可自主分析,accessCode&Writing == Writing 結果 true 則意味著可寫,否則不可寫,accessCode&Executable == Executable 結果 true 意味著可執行,false 意味著不可執行.

熟悉了 iota 的數學計算和比特位計算後,我們趁熱打鐵,用文件大小單位繼續練習!

func TestConstForIota(t *testing.T) {      const (          B = 1 << (10 * iota)          Kb          Mb          Gb          Tb          Pb      )      // 1 1024 1048576 1073741824 1099511627776 1125899906842624      t.Log(B, Kb, Mb, Gb, Tb, Pb)        // 62.9 KB (64,411 位元組)      size := 64411.0      t.Log(size, size/Kb)  }

位元組 Byte 與 千位元組 Kilobyte 之間的進位單位是 1024 ,也就是 2^10 ,剛好可以用 iota 左移 10 位來表示,一次只移動一次,直接乘以 10 就好了!

怎麼樣,iota 是不是很神奇?同時是不是和我一樣也有點小困惑,iota 這貨到底是啥?

百度翻譯給我們的解釋是,這貨表示"微量",類似英語單詞的 little 一樣,a little 也表示"一點點".

但是 iota 除了表示一點點之外,好像還擁有自增的能力,這可不是 little 這種量詞能夠傳達的意思.

因此,有可能 iota 並不是原始英語含義,說不定是希臘字母的語言,查詢了標準的 24 個希臘字母表以及對應的英語注釋.

希臘字母常常用於物理,化學,生物,科學等學科,作為常量或者變數,不同於一般的英語變數或常量的是,希臘字母表示的變數或常量一般具有特定的語義!

因此,iota 應該是希臘字母 I 的英語表示,該變數或者說常量表示微小,一點的含義.

翻譯成自然語言就是,這個符號表示一點點,如果表達改變的含義,那就是在原來基礎上多那麼一點點,如果表達不改變的含義,應該是只有一點點,僅此而已.

當然,以上均是個人猜測,更加專業的說法還是應該看下 Go 語言如何定義 iota ,按住 Ctrl 鍵,滑鼠懸停在 iota 上可以點擊進入源碼部分,如下:

// iota is a predeclared identifier representing the untyped integer ordinal  // number of the current const specification in a (usually parenthesized)  // const declaration. It is zero-indexed.  const iota = 0 // Untyped int.

簡短翻譯:

iota 是預定義標識符,代表當前常量中無符號整型的序號,是以 0 作為索引的.

上述注釋看起來晦澀難懂,如果是常量那就就安安靜靜當做常量,不行嗎?怎麼從常量定義中還讀出了循環變數索引的味道?

為了驗證猜想,仍然以最簡單的星期轉換為例,模擬每一步時的 iota 的值.

const (      // iota = 0,Mon = 1 + 0 = 1,符合輸出結果 1,此時 iota  = 1,即 iota 自增1      Mon = 1 + iota      // iota = 1,Tue = 1 + iota = 1 + 1 = 2,符合輸出結果 2,此時 iota = 2      Tue      // iota = 2,Wed = 1 + iota = 1 + 2 = 3,符合輸出結果 3,此時 iota = 3      Wed      Thu      Fri      Sat      Sun  )  // 1 2 3 4 5 6 7  t.Log(Mon, Tue, Wed, Thu, Fri, Sat, Sun)

上述猜想中將 iota 當做常量聲明循環中的變數 i,每聲明一次,i++,因此僅需要定義循環初始條件和循環自增變數即可完成循環賦值.

const (      Mon = 1 + iota      Tue      Wed      Thu      Fri      Sat      Sun  )  // 1 2 3 4 5 6 7  t.Log(Mon, Tue, Wed, Thu, Fri, Sat, Sun)    var days [7]int  for i := 0; i < len(days); i++ {      days[i] = 1 + i  }  // [1 2 3 4 5 6 7]  t.Log(days)

這樣對應是不是覺得 iota 似乎就是循環變數的 i,其中 Mon = 1 + iota 就是循環初始體,Mon~Sun 有限常量就是循環的終止條件,每一個常量就是下一次循環.

如果一個例子不足以驗證該猜想的話,那就再來一個!

const (  Readable = 1 << iota  Writing  Executable  )  // 0001 0010 0100 即 1 2 4  t.Log(Readable, Writing, Executable)    var access [3]int  for i := 0; i < len(access); i++ {      access[i] = 1 << uint(i)  }  // [1 2 4]  t.Log(access)

上述兩個例子已經初步驗證 iota 可能和循環變數 i 具有一定的關聯性,還可以進一步接近猜想.

const (      // iota=0 const=1+0=1 iota=0+1=1      first = 1 + iota        // iota=1 const=1+1=2 iota=1+1=2      second        // iota=2 const=2+2=4 iota=2+1=3      third = 2 + iota        // iota=3 const=2+3=5 iota=3+1=4      forth        // iota=4 const=2*4=8 iota=4+1=5      fifth = 2 * iota        // iota=5 const=2*5=10 iota=5+1=6      sixth        // iota=6 const=6 iota=6+1=7      seventh = iota  )  // 1 2 4 5 8 10 6  t.Log(first, second, third, forth, fifth, sixth, seventh)    const currentIota  = iota  // 0  t.Log(currentIota)    var rank [7]int  for i := 0; i < len(rank); i++ {      if i < 2 {          rank[i] = 1 + i      } else if i < 4 {          rank[i] = 2 + i      } else if i < 6 {          rank[i] = 2 * i      } else {          rank[i] = i      }  }  // [1 2 3 4 5 6 7]  t.Log(rank)

iota 是一組常量初始化中的循環變數索引,當這一組變數全部初始化完畢後,iota 重新開始計算,因此新的變數 currentIota 的值為 0 而不是 7

因此,iota 常常用作一組有規律常量的初始化背後的原因可能就是循環變數進行賦值,按照這個思路理解前面關於 iota 的例子暫時是沒有任何問題的,至於這種理解是否準確,有待繼續學習 Go 作進一步驗證,一家之言,僅供參考!

變數和常量的基本小結

• 變數用 var 關鍵字聲明,常量用 const 關鍵字聲明.
• 變數聲明並賦值的形式比較多,使用時最好統一一種形式,避免風格不統一.
• 變數類型具備自動推斷能力,但本質上仍然是強類型,不同類型之間並不會自動轉換.
• 一組規律的常量可以用 iota 常量進行簡化,可以暫時理解為採用循環方式對變數進行賦值,從而轉化成常量的初始化.
• 變數和常量都具有相似的初始化形式,與其他程式語言不同之處在於一條語句中可以對多個變數進行賦值,一定程度上簡化了程式碼的書寫規則.
• 任何定義但未使用的變數或常量都是不允許存在的,既然用不著,為何要聲明?!禁止冗餘的設計,好壞暫無法評定,既然如何設計,那就遵守吧!

與眾不同的變數和常量

斐波那契數列是一組無窮的遞增數列,形如 1,1,2,3,5,8,13... 這種從第三個數開始,後面的數總是前兩個數之和的數列就是斐波那契數列.

如果從第三個數開始考慮,那麼前兩個數就是斐波那契數列的起始值,以後的數字都符合既定規律,取前兩個數字當做變數 a,b 採用循環的方式不斷向後推進數列得到指定長度的數列.

func TestFib(t *testing.T) {      var a int = 1      var b int = 1        fmt.Print(a)      for i := 0; i < 6; i++ {          fmt.Print(" ", b)            temp := a          a = b          b = temp + b      }      fmt.Println()  }

雖然上述解法比較清晰明了,但還不夠簡潔,至少沒有用到 Go 語言的特性.實際上,我們還可以做得更好,或者說用 Go 語言的特性來實現更加清晰簡單的解法:

func TestFibSimplify(t *testing.T) {      a, b := 0, 1        for i := 0; i < 6; i++ {          fmt.Print(" ", b)            a, b = b, a+b      }        fmt.Println()  }

和第一種解法不同的是,這一次將變數 a 向前移一位,人為製造出虛擬頭節點 0,變數 a 的下一個節點 b 指向斐波那契數列的第一個節點 1,隨著 a 和 b 相繼向後推進,下一個循環中的節點 b 直接符合規定,相比第一種解法縮短了一個節點.

a, b := 0, 1 是循環開始前的初始值,b 是斐波那契數列中的第一個節點,循環進行過程中 a, b = b, a+b 語義非常清楚,節點的 a 變成節點 b,節點 b 是 a+b 的值.

是不是很神奇,這裡既沒有用到臨時變數存儲變數 a 的值,也沒有發生變數覆蓋的情況,直接完成了變數的交換賦值操作.

由此可見, a, b = b, a+b 並不是 a=b 和 b=a+b 的執行結果的累加,而是同時完成的,這一點有些神奇,不知道 Go 是如何實現多個變數同時賦值的操作?

如果有小夥伴知道其中奧妙,還望不吝賜教,大家一起學習進步!

如果你覺得上述操作有點不好理解,那麼接下來的操作,相信你一定會很熟悉,那就是兩個變數的值進行交換.

func TestExchange(t *testing.T) {      a, b := 1, 2      t.Log(a, b)        a, b = b, a      t.Log(a, b)        temp := a      a = b      b = temp      t.Log(a, b)  }

同樣的是,a, b = b, a 多變數同時賦值直接完成了變數的交換,其他程式語言實現類似需求一般都是採用臨時變數提前存儲變數 a 的值以防止變數覆蓋,然而 Go 語言的實現方式竟然和普通人的思考方式一樣,不得不說,這一點確實不錯!

通過簡單的斐波那契數列,引入了變數和常量的基本使用,以及 Go 的源碼文件相應規範,希望能夠帶你入門 Go 語言的基礎,了解和其它程式語言有什麼不同以及這些不同之處對我們實際編碼有什麼便捷之處,如果能用熟悉的程式語言實現 Go 語言的設計思想也未曾不是一件有意思的事情.

下面,簡單總結下本文涉及到的主要知識點,雖然是變數和常量,但重點並不在如何介紹定義上,而是側重於特殊之處以及相應的實際應用.

• 源碼文件所在的目錄和源碼文件的所在包沒有必然聯繫,即 package main 所在的源碼文件並不一定在 main 目錄下,甚至都不一定有 main 目錄.

hello.go 源碼文件位於 hello 目錄下,而 hello_word.go 位於 main 目錄下,但是他們所在的包都是 package main

• 源碼文件命名暫時不知道有沒有什麼規則,但測試文件命名一定是 xxx_test,測試方法命名是 TestXXX ,其中 Go 天生支援測試框架,不用額外載入第三方類庫.

• 聲明變數的關鍵字是 var,聲明常量的關鍵字是 const,無論是變數還是常量,均存在好幾種聲明方式,更是存在自動類型推斷更可以進行簡化.

一般而言,實現其它程式語言中的全局變數聲明用 var,局部變數聲明 := 簡化形式,其中多個變數可以進行同時賦值.

• 一組特定規律的常量值可以巧用 iota 來實現,可以理解為首次使用 iota 的常量是這組常量規律的第一個,其餘的常量按照該規律依次初始化.

Go 語言沒有枚舉類,可以用一組常量值實現枚舉,畢竟枚舉也是特殊的常量.

本文源碼已上傳到 https://github.com/snowdreams1006/learn-go 項目,感興趣的小夥伴可以點擊查看,如果文章中有描述不當之處,懇請指出,謝謝你的評論和轉發.