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 main
func 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 main
import (
"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 main
import ( "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 main
import ("fmt")
func main(){
x:=10
fmt.Println("x =",x)
x:=11
fmt.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",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
錯誤信息：
.\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
可以一次性聲明、聲明並賦值多個變量：
var x, y, z int
x, y, z := 10, 20, 30
var (
x = 10
y = 20
z = 30
)
函數定義
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...
}