the little go book學習筆記(1):簡介

發布日期:2019-10-25

1.Go簡介

Go語言是編譯型、靜態類型的類C的語言,并帶有GC(垃圾收集器,garbage collection)。這意味著什么?

另外,Go是一種非常嚴格的語言,它幾乎總是要求我們"以標準答案去答題",在其它語言可以容忍的不規范編碼方式在Go語言中幾乎都會拋異常。例如導入了包卻沒有使用這個包,Go不會去編譯它并報錯。再例如,定義了一個變量但從來沒用過,也會報錯。

初學Go的時候,這可能是件無比的苦惱事情,但習慣了之后,編寫出來的程序自然是無比規范的。這也正是Go和不少語言的區別:其它語言編碼、調試階段可能很快,但維護和優化階段可能會非常長;而Go的編碼周期可能稍長,但編碼完成后幾乎都是足夠優化的,維護和優化周期足夠短。

編譯型

編譯表示的是將你所寫的源代碼轉換為低層次的語言,例如匯編語言(go采用此底層語言),或者其它中間的語言(如Java、C#編譯成字節碼)。

編譯型語言可能不太友好,因為編譯的過程速度很慢。如果一個程序的編譯過程就需要花幾分鐘甚至幾小時,那么程序的版本迭代可能會很難進行下去。編譯速度是Go語言的一個主要設計目標,值得慶幸的是,Go的編譯速度很快,即便對于習慣于使用解釋型語言的人來說,它也還是快。

編譯型語言雖然編譯過程慢,但這類語言在運行階段可能會更快,而且運行時不再需要加載額外的依賴。

靜態類型

靜態語言意味著變量必須要指定數據類型(int,string,bool,[]byte等)。雖然必須指定數據類型,但除了在聲明變量的時候顯式指定數據類型,也可以讓Go自己去推斷數據類型(稍后有示例)。

對于習慣于使用動態型語言的人來說,可能會感覺靜態型語言很笨重,事實確實如此。但靜態有靜態的好處,特別是配合編譯操作的時候。

關于靜態和動態數據類型,要說的內容其實很多很多,畢竟對于一門語言來說,數據類型牽一發而動全身,無論是靜態、還是動態型語言,都因此而衍生出無數的優、缺點。

類C型的語言

當我們說一門語言是類C型(C-like)的語言時,意味著這門語言里有一些語法和特性和C語言是類似的。例如,&&表示布爾的AND,==表示等值比較,數組索引從0開始計算,{...}表示一段代碼塊,也表示它屬于一個作用域范圍,等等。

類C型語言也意味著每行的語句要使用分號";"結束,條件表達式要使用括號包圍。但Go語言不采用這兩種方式,盡管還是可以使用括號包圍條件表達式以改變優先級。例如:

if name == "malongshuai" { print("name rigth!")}

一個更復雜一點的條件表達式,使用括號改變優先級:

if (name == "longshuai" && age > 23) || (name == "xiaofang" && age < 22) { print("yeyeye!!!")}

GC

每當創建一個變量后,這個變量都會有其生命周期。例如,函數內部的本地變量將在函數退出的時候消逝。對于非函數內部的變量生命周期,無論是對程序員還是對編譯器來說,變量的生命周期都沒有那么顯而易見。

沒有garbage collection,意味著要讓程序員自己來決定變量所占用內存的釋放,這是很艱巨的任務,而且很容易出錯導致程序崩潰。

帶有GC的語言可以對變量進行跟蹤,并且在它們不再被需要的時候自動釋放它們。雖然GC帶來了一點點的負載,會影響一點點的性能,但對于現在高性能的計算機來說,這點影響相比它帶來的優點而言,完全可以將其無視。

嘗試寫一個簡單的Go程序

按照國際管理,每一門語言總是以hello world開篇。這里就算了,因為我有我的慣例。

先安裝Go,so easy...

目前還沒有必要涉及Go的工作空間,所以隨意找個地方創建一個test.go文件,內容如下:

package mainfunc main() { println("Let"s Go")}

然后運行:

go run test.go

顯然,它將輸出Let"s Go。但是Go的編譯過程呢?go run命令同時進行了編譯和運行兩個過程:它將使用一個臨時目錄保存構建的程序,然后執行它,最后自動清理構建出來的臨時程序。

可以使用go run --work查看下具體情況:

$ go run --work test.goWORK=/tmp/go-build267589647Let"s Go

構建的臨時目錄位于/tmp/go-buildXXXX中(我這是Linux),在此目錄下會有一個二進制程序(對于Windows則是.exe文件):

$ tree /tmp/go-build267589647//tmp/go-build267589647/├── command-line-arguments│?? └── _obj│?? └── exe│?? └── test # 這是可執行二進制程序└── command-line-arguments.a

那個test文件就是編譯后得到的二進制程序,可以直接用來執行:

$ /tmp/go-build267589647/command-line-arguments/_obj/exe/test Let"s Go

如果要顯式編譯,使用go build命令:

go build test.go

它將在當前目錄下生成一個名為test的二進制文件,可以直接拿來運行,就像前面/tmp中的一樣。

$ ./teseLet"s Go

在開發階段,用go build還是用go run,隨意即可。但在部署的時候,一般先go build,再go run。

main包和main函數

在上面的代碼中,聲明了這個包的名稱為main,然后創建一個函數,并在此函數中使用println輸出了一個字符串,但是go run如何知道要去執行什么?在Go中,程序的入口是main包中的main函數,這兩名稱都是固定的。

對于一個從沒編程過的人,可能不理解程序的入口。它表示程序從此處開始執行,函數main中可能會包含很多其它函數的調用,這些函數可能放在其它文件(包)中。通過一次次、一層層的調用,從而將整個程序的所有代碼、邏輯都連接在一起并運行。

如果你愿意,可以試著修改一下package后面的main關鍵字,然后go rungo build都運行一下。再試著修改一下func mainmain關鍵字,go rungo build再運行一下。

關于包的內容,后面再做介紹。目前來說,需要理解的只是些基礎,對于基礎階段來說,我們將總是在main包中寫代碼。

import

Go有一些內置的函數,例如上面的println,內置函數無需額外的引用就可直接調用。但內置函數畢竟很少,所以得從已經寫好的Go標準庫和其它第三方庫中找出一些工具來使用。

在Go中,import關鍵字用于定義要導入到當前文件的包名,導入某個包后,這個包中的屬性就能在當前文件中去訪問,例如調用屬于這個包的函數。

例如,將前面的代碼改改:

package mainimport ( "fmt" "os")func main (){ if len(os.Args) != 2{ os.Exit(1) } fmt.Println("Arg0: ",os.Args[0]) fmt.Println("Arg1: ",os.Args[1])}

執行一下:

$ go run test.goexit status 1$ go run test.go a bexit status 1$ go run test.go a Arg0: /tmp/go-build730099388/command-line-arguments/_obj/exe/testArg1: a

上面的import導入了兩個標準包:fmtos,還使用了另一個內置函數len()。

len()函數返回字符串的長度、字典的元素個數以及數組的元素個數。上面使用len()判斷了該Go程序的參數個數必須為2,否則就以狀態碼1退出該程序??瓷厦娴倪\行結果,好像只有給一個參數的時候才是正確的,這是因為第一個參數(Args[0])代表的總是當前正在運行的程序名稱,正如上面結果所顯示的那樣。

你可能還注意到了fmt.Println,前綴fmt正好是導入的一個包名,這表示使用fmt包中的Println函數。

本文的開頭就說過了,Go是一門非常嚴格的語言,如果這里導入了fmt包,但卻沒有使用它,它將報錯。

# command-line-arguments./test.go:4:5: imported and not used: "fmt"

關于Go文檔

關于fmt的Println函數詳細用法,可去參考Go的官方文檔:https://golang.org/pkg/fmt/#Println。當然,現階段去看官方手冊,那是在找死。

還可以使用go doc命令去查找各幫助文檔。

例如,查看fmt包的幫助文檔:

go doc fmt

查看fmt.Println函數的用法:

go doc fmt.Println

完整用法:

go docgo doc <pkg>go doc <sym>[.<method>]go doc [<pkg>].<sym>[.<method>]go doc <pkg> <sym>[.<method>]

此外,還可以構建本地的網頁版官方手冊,在斷網的時候可以訪問:

godoc -http=:6060

然后就可以在瀏覽器中通過http://localhost:6060/訪問官方手冊。

變量和變量聲明

很多語言中,要為變量賦值只需一個語句:

x=10

這個語句中實際上包含了兩個過程:變量的聲明和變量的賦值。聲明一般也被稱為"定義"。

在Go中,必須先聲明變量,再賦值或使用變量。最復雜的聲明+賦值操作為:

package mainimport ( "fmt" )func main(){ var x int x=10 fmt.Println("x =",x)}

此處聲明了一個變量x,其數據類型為int。默認情況下,Go在變量的聲明期間會為其做初始化賦值:int類型初始化賦值為0,booleans初始化賦值為false,strings初始化賦值為"",等等。

可以將聲明和賦值操作合并:

var x int = 10

還有一種更方便的聲明+賦值方式:

x := 10

通過這種變量的定義方式,還可以將函數執行結果(返回值)賦值給變量。例如:

func main() { x := getAdd(10)}func getAdd(x int) int { return x+1}

:=在Go中屬于類型推斷操作,它包含了變量聲明和變量賦值兩個過程。

需要注意的是,變量聲明之后不能再次聲明(除非在不同的作用域),之后只能使用=進行賦值。例如,執行下面的代碼將報錯:

package mainimport ("fmt")func main(){ x:=10 fmt.Println("x =",x) x:=11 fmt.Println("x =",x)}

錯誤如下:

# command-line-arguments.est.go:8:3: no new variables on left side of :=

報錯信息很明顯,:=左邊沒有新變量。

如果仔細看上面的報錯信息,會發現no new variables是一個復數。實際上,Go允許我們使用:=一次性聲明、賦值多個變量,而且只要左邊有任何一個新變量,語法就是正確的。

func main(){ name,age := "longshuai",23 fmt.Println("name:",name,"age:",age) // name重新賦值,因為有一個新變量weight weight,name := 90,"malongshuai" fmt.Println("name:",name,"weight:",weight)}

需要注意,name第二次被:=賦值,Go第一次推斷出該變量的數據類型之后,就不允許:=再改變它的數據類型,因為只有第一次:=對name進行聲明,之后所有的:=對name都只是簡單的賦值操作。

例如,下面將報錯:

weight,name := 90,80

錯誤信息:

.est.go:11:14: cannot use 80 (type int) as type string in assignment

另外,變量聲明之后必須使用,否則會報錯,因為Go對規范的要求非常嚴格。例如,下面定義了weight但卻沒使用:

weight,name := 90,"malongshuai"fmt.Println("name:",name)

錯誤信息:

.est.go:11:2: weight declared and not used

函數定義

Go的函數允許有多個返回值。例如:

// 該函數有一個參數,沒有返回值func log(message string){ ...CODE...}// 該函數有兩個參數,一個返回值,返回值的類型為intfunc add(a int,b int) int { ...CODE...}// 該函數一個參數,兩個返回值,分別是int和boolfunc power(name string) (int,bool) { ...CODE...}

既然函數可以有返回值,就可以將其返回值賦值給變量:

value, exists := power("malongshuai")if exists == false { ...CODE...}

有些時候,我們可能并不需要所有的返回值。例如,我們只想要取得power()的第二個返回值。這時可以將不想要的返回值丟給特殊符號下劃線_,它表示丟棄這部分結果。

_,exists := power("longshuai")if exists == false { ...CODE...}

如果函數的參數類型相同,則不同的參數可以共享數據類型。

func (a,b int) int { ...CODE...}

澳洲快乐8数据分析