關於Go語言，這5種學習訣竅幫你省去50%精力！

CSDN學院發表於2020-04-04
Go

文章轉自：bboyHan  （文末有彩蛋）

 

Go 是一個開源的程式語言，它能讓構造簡單、可靠且高效的軟體變得容易。

Go是從2007年末由Robert Griesemer, Rob Pike, Ken Thompson主持開發，後來還加入了Ian Lance Taylor, Russ Cox等人，並最終於2009年11月開源，在2012年早些時候釋出了Go 1穩定版本。現在Go的開發已經是完全開放的，並且擁有一個活躍的社群。

Go作為一種簡便靈巧的語言，深受開發者的喜愛。但對於初學者來說，要想輕鬆駕馭它，還得做好細節學習工作。

 

首先，先提供給大家一個api官網，開發者必備手冊，地址：https://golang.org/cmd/api/

當然，可能有的朋友沒有VPN，連線不上官網，有一個本地檢視文件的方式，如下：

也為大家推薦了技術教程：

跟寧哥學Go語言

GO語言視訊教程

Go語言實戰合集

Go語言-進階篇


 

  1. $> go help doc

  2. usage: go doc [-u] [-c] [package|[package.]symbol[.method]]

  3. Doc prints the documentation comments associated with the item identified by its

  4. arguments (a package, const, func, type, var, or method) followed by a one-line

  5. summary of each of the first-level items "under" that item (package-level

  6. declarations for a package, methods for a type, etc.).

  7. Flags:

  8. -c

  9. Respect case when matching symbols.

  10. -cmd

  11. Treat a command (package main) like a regular package.

  12. Otherwise package main's exported symbols are hidden

  13. when showing the package's top-level documentation.

  14. -u

  15. Show documentation for unexported as well as exported

  16. symbols and methods.

或者使用http，瀏覽器方式檢視

$> godoc -http=:8080

接下來，你就可以使用 http://localhost:8080 或 http://127.0.0.1:8080 在本地使用瀏覽器進行瀏覽api文件了。

 

1、什麼是包（package）？

我們在使用其它語言的情況，比如Java（本主是Java開發出身，0rz，以此為例），是有“包”這個概念的，其實，就可以簡單的理解為是便於管理和組織所有的檔案所使用的，比如java中常用的類String，它就隸屬於“java.lang”包下的類。（當然，新手不理解也沒有關係）。在Go當中，也是類似的概念，它將我們的go檔案（檔案的字尾名為“.go”）組織起來，可以方便進行歸類、複用等。 

 

你會看到這樣的一些檔案結構，比如encoding包，下面就有base32、base64、hex、json等等，當需要使用時，則


 

  1. //使用“import”關鍵字進行匯入，比如：

  2.  

  3. import "fmt"

 

在開篇《入門篇》中，所講到的編寫“hello world”使用了“fmt”，就使用這樣的匯入方式，當需要匯入多個包時，可以使用


 

  1. import （

  2. "fmt"

  3. "os"

  4. ）

 

包的命名

go語言的包的命名，遵循簡潔、小寫、和go檔案所在目錄同名的原則，這樣就便於我們引用，書寫以及快速定位查詢。對於在企業當中開發的程式而言，我們一般採用域名作為頂級包名的方式，這樣就不用擔心和其他開發者包名重複的問題了，比如公司的域名是`www.bboyHan.com`，那麼開發的go程式都以`bboyHan.com`作為全路徑中的最頂層部分，匯入開發的工具包則可以寫為:


 

  1. package main

  2.  

  3. import "bboyHan.com/utils"

 

------------------------------------------------------------

2、Main

我們知道，在java當中，有一個主程式的入口main（）方法，而Go語言程式，也是類似。當把一個go檔案的包名宣告為main時，就等於告訴go編譯程式，這是一個可執行程式，那麼go編譯程式就會嘗試把它編譯為一個二進位制的可執行檔案。如果沒有這個函式，程式就無法執行。


 

  1. //注意點：在go語言裡，同時要滿足main包和包含main()函式，才會被編譯成一個可執行檔案。

  2.  

  3. package main

  4.  

  5. import "fmt"

  6.  

  7. func main(){

  8. fmt.Println("接下來，請在這裡搞事情。")

  9. }

 

那麼，思考一個問題：Go編譯器又是如何去尋找各個檔案、包之間的依賴關係而構建程式的呢？

在上一文當中，我們提到了環境變數GOROOT和GOPATH兩個概念,這是兩個定義路徑的環境變數，GOROOT是安裝Go的路徑，比如 C:\go ；GOPATH是我們自己定義的開發者個人的工作空間，比如C:\workspace\src\bbboyHan。

編譯器會使用我們設定的這兩個路徑，再加上import匯入的相對全路徑來查詢磁碟上的包，比如我們匯入的fmt包，編譯器最終找到的是 C:\go\fmt 這個位置。對於包的查詢，是有優先順序的，編譯器會優先在GOROOT裡搜尋，其次是GOPATH,一旦找到，就會馬上停止搜尋。如果最終都沒找到，就會報編譯異常了。

------------------------------------------------------------

3、變數

Go中使用全新的關鍵字var來宣告變數。var我們並不陌生，在Javascript 和C#中均有出現。不同的是Go和C#中變數屬於強型別，在宣告變數後就不允許改變其資料型別。記住，Go屬於強資料型別

宣告及初始化


 

  1. var a int //宣告一個int型別的變數

  2.  

  3. var b struct { //宣告一個結構體

  4.  

  5. i string

  6.  

  7. }

  8.  

  9. var a = 1 //宣告變數的同時賦值，編譯器自動推導其資料型別

  10.  

  11. a := 1 //這種方式，含義同上,不書寫型別，編譯時會根據value自動推導型別進行匹配

  12.  

  13. var a int = 2 //宣告變數的同時賦值

  14.  

  15. var { //批量宣告變數，簡潔

  16. a int

  17. b string

  18. }

 

值得注意的一點，賦值時如果要確定你想要的型別，在Go中是不支援隱式轉換的。如果是定義個float64型別的變數，請寫為


 

  1. //前提：需要定義一個float型別的變數時：

  2. //正確寫法

  3. v1 := 3.0

  4. //錯誤寫法

  5. v1 := 3

------------------------------------------------------------

4、常量

使用constant關鍵字進行定義，官方文件內容


 

  1. const a = 2 + 3.0 // a == 5.0 (untyped floating-point constant)

  2. const b = 15 / 4 // b == 3 (untyped integer constant)

  3. const c = 15 / 4.0 // c == 3.75 (untyped floating-point constant)

  4. const Θ float64 = 3/2 // Θ == 1.0 (type float64, 3/2 is integer division)

  5. const Π float64 = 3/2. // Π == 1.5 (type float64, 3/2. is float division)

  6. const d = 1 << 3.0 // d == 8 (untyped integer constant)

  7. const e = 1.0 << 3 // e == 8 (untyped integer constant)

  8. const f = int32(1) << 33 // illegal (constant 8589934592 overflows int32)

  9. const g = float64(2) >> 1 // illegal (float64(2) is a typed floating-point constant)

  10. const h = "foo" > "bar" // h == true (untyped boolean constant)

  11. const j = true // j == true (untyped boolean constant)

  12. const k = 'w' + 1 // k == 'x' (untyped rune constant)

  13. const l = "hi" // l == "hi" (untyped string constant)

  14. const m = string(k) // m == "x" (type string)

  15. const Σ = 1 - 0.707i // (untyped complex constant)

  16. const Δ = Σ + 2.0e-4 // (untyped complex constant)

  17. const Φ = iota*1i - 1/1i // (untyped complex constant)

------------------------------------------------------------

有趣的一點，就是Go在一些情況下，會做一些調整，比如：


 

  1. func main(){

  2. a :=8

  3. a =8.5 // 將編譯錯誤:constant 8.5 truncated to integer

  4. fmt.Println(a)

  5. }


 

  1. func main(){

  2. a := 3

  3. a = 3.0 // 編譯可通過，執行無錯誤

  4. fmt.Println(a)

  5. }

 

也就是說，Go在不損失精度的情況下會把3.0這類浮點數視作整數3，如果型別顯式指定了，在表示式當中就不會產生變化。在使用的時候會根據上下文需要的型別轉化為實際型別，比如uint8(0) + 1.0就是uint8(1)，但是uint8(0)+2.2就會由於2.2無法轉化為uint8而報錯。

當多個常量需要定義時，也可以使用簡易寫法：


 

  1. //相同型別的情況：

  2. const c_name1, c_name2 = value1, value2

  3. //可以用作列舉

  4. const (

  5. Unknown = 0

  6. Female = 1

  7. Male = 2

  8. )

-----------------------------------------------------------

5、iota

iota，特殊常量，可以認為是一個可以被編譯器修改的常量。在每一個const關鍵字出現時，被重置為0，然後再下一個const出現之前，每出現一次iota，其所代表的數字會自動增加1。


 

  1. const (

  2. a = iota //a = 0

  3. b = iota //b = 1

  4. c = iota //c = 2

  5. )

  6. //可簡寫為：

  7. const (

  8. a = iota

  9. b

  10. c

  11. )

  12. //進階用法：

  13. const (

  14. i = 1<<iota //i = 1

  15. j = 3<<iota //j = 6

  16. k //k = 12

  17. l //l = 24

  18. )

-----------------------------------------------------------

6、陣列


 

  1. var array [5]int //宣告

  2. array = [5]int{1,2,3,4,5} //初始化

  3. array := [5]int{1,2,3,4,5} //宣告並初始化

  4. array := [...]int{1,2,3,4,5} //不指定長度進行宣告及初始化

  5. array := [5]int{1:1,3:4} //只對索引為1和3的值初始化，其餘使用預設初始化值0

 

因為陣列的建立在記憶體當中是一段連續的空間，所以通過索引進行直接訪問，訪問的效率非常高


 

  1. func main() {

  2. array := [5]int{1: 1, 3: 4}

  3. for i := 0; i < 5; i++ {

  4. fmt.Printf("索引:%d,值:%d\n", i, array[i])

  5. }

  6. }

-----------------------------------------------------------

看了上面的程式碼，想必會有朋友會問“fmt”還沒有講呢，下面講解一下fmt包的相關知識

7、“fmt”

fmt包實現了格式化的I/O函式，這點類似Ｃ語言中的printf和scanf，但是更加簡單，其中的格式“佔位符”衍生自 C


 

  1. //常用的格式化輸出

  2. fmt.Printf("start at number %v, end count %v\n",start, count)

 

佔位符

一般佔位符

符號 說明
%v 相應值的預設格式
%+v 在列印結構體時，預設格式，會新增欄位名
%#v 相應值的 Go 語法表示
%T 相應值的型別的 Go 語法表示
%% 字面上的百分號，並非值的佔位符

 

布林佔位符

 

符號 說明
%t 單詞 true 或 false

 

整數佔位符

符號 說明
%b 二進位制表示
%c 相應 Unicode 碼點所表示的字元
%d 十進位制表示
%o 八進位制表示
%q 單引號圍繞的字元字面值，由 Go 語法安全地轉義
%x 十六進位制表示，字母形式為小寫 a-f
%X 十六進位制表示，字母形式為大寫 A-F
%U Unicode 格式：U+1234，等同於 "U+%04X"

 

浮點數及其複合構成佔位符

符號 說明
%b 無小數部分的，指數為二的冪的科學計數法，與 strconv.FormatFloat 的 'b' 轉換格式一致。例如 -123456p-78
%e 科學計數法，例如 -1234.456e+78
%E 科學計數法，例如 -1234.456E+78
%f 有小數點而無指數，例如 123.456
%g 根據情況選擇 %e 或 %f 以產生更緊湊的（無末尾的 0）輸出
%G 根據情況選擇 %E 或 %f 以產生更緊湊的（無末尾的 0）輸出

 

字串與位元組切片佔位符

符號 說明
%s 字串或切片的無解譯位元組
%q 雙引號圍繞的字串，由 Go 語法安全地轉義
%x 十六進位制，小寫字母，每位元組兩個字元
%X 十六進位制，大寫字母，每位元組兩個字元

 

指標

符號 說明
%p 十六進位制表示，字首 0x

 

fmt中的方法：

 


 

  1. // Print 將引數列表 a 中的各個引數轉換為字串並寫入到標準輸出中。

  2. // 非字串引數之間會新增空格，返回寫入的位元組數。

  3. func Print(a ...interface{}) (n int, err error)

  4.  

  5. // Println 功能類似 Print，只不過最後會新增一個換行符。

  6. // 所有引數之間會新增空格，返回寫入的位元組數。

  7. func Println(a ...interface{}) (n int, err error)

  8.  

  9. // Printf 將引數列表 a 填寫到格式字串 format 的佔位符中。

  10. // 填寫後的結果寫入到標準輸出中，返回寫入的位元組數。

  11. func Printf(format string, a ...interface{}) (n int, err error)

  12.  

  13. // 功能同上面三個函式，只不過將轉換結果寫入到 w 中。

  14. func Fprint(w io.Writer, a ...interface{}) (n int, err error)

  15. func Fprintln(w io.Writer, a ...interface{}) (n int, err error)

  16. func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)

  17.  

  18. // 功能同上面三個函式，只不過將轉換結果以字串形式返回。

  19. func Sprint(a ...interface{}) string

  20. func Sprintln(a ...interface{}) string

  21. func Sprintf(format string, a ...interface{}) string

  22.  

  23. // 功能同 Sprintf，只不過結果字串被包裝成了 error 型別。

  24. func Errorf(format string, a ...interface{}) error

 

文末彩蛋：

1.CSDN學院助學會員：僅需百元- 1300門課+600次下載特權，一次購買，全年無憂！點選檢視。

2.CSDN學院知識週刊：每週更新學院優惠課程活動及精品上新內容，點選檢視！

3.技術教程推薦：

GO語言視訊教程 https://edu.csdn.net/course/detail/9183?utm_source=blog11xk
Go語言-進階篇 https://edu.csdn.net/course/detail/9179?utm_source=blog11xk
Go語言實戰合集 https://edu.csdn.net/combo/detail/957?utm_source=blog11xk
跟寧哥學Go語言 https://edu.csdn.net/combo/detail/959?utm_source=blog11xk

相關文章