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.go WORK=/tmp/go-build267589647 Let'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中的一樣。

$ ./tese Let's Go

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

main包和main函數

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

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

如果你愿意，可以試著修改一下package后面的main關鍵字，然后go run和go build都運行一下。再試著修改一下func main的main關鍵字，go run和go 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.go exit status 1$ go run test.go a b exit status 1$ go run test.go a Arg0: /tmp/go-build730099388/command-line-arguments/_obj/exe/test Arg1: a

上面的import導入了兩個標準包：fmt和os，還使用了另一個內置函數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 doc go 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 intx=10fmt.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:=10fmt.Println("x =",x)x:=11fmt.Println("x =",x) }

錯誤如下：

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

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

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

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

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

例如，下面將報錯：

weight,name := 90,80

錯誤信息：

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

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

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

錯誤信息：

.\test.go:11:2: weight declared and not used

函數定義

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

// 該函數有一個參數，沒有返回值 func log(message string){...CODE... }// 該函數有兩個參數，一個返回值，返回值的類型為int func add(a int,b int) int {...CODE... }// 該函數一個參數，兩個返回值，分別是int和bool func 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... }

轉載于:https://www.cnblogs.com/f-ck-need-u/p/9832577.html

總結

以上是生活随笔為你收集整理的go基础系列：简介的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。