1. 認識HelloWorld
在前面的《Go語言入門系列(一)之Go的安裝和使用》這篇文章中已經寫過HelloWorld.go了，現在就來逐行認識一下它。
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
第1行：我們的Go程序是由包——package構成的，包的聲明形式為：package <包名>。該行的意思是：當前HelloWorld.go文件屬於main包。
第2行：如果你使用過Java或Python，那你對import肯定不陌生。該行的意思是：導入一個名為fmt的包。如果需要導入多個包，有兩種寫法：
import "fmt"
import "math"
或者使用分組形式同時導入多個包
import (
"fmt"
"math/rand"
)
顯然第二種使用括號，以分組的形式導入更加方便。
第3行：我們使用func關鍵字來聲明一個函數，在這個例子中，我們聲明的是main函數。如果你有過其他語言的編程經驗，肯定熟悉main函數的作用：程序的入口。
第4行：我們的函數內容放在函數的{}中，在該例中，調用了fmt包中的打印方法，由此可見，Golang語言調用函數的方法和Java、Python一樣使用小數點：<包名>.<函數名>。
看完這幾行簡單代碼，我們發現：在Go語言中，並不需要分號;來結束語句。
2. 變量
2.1. 命名規范
Go語言要求標識符以一個字母或下划線開頭，后面可以跟任意數量的字母、數字、下划線。不能使用關鍵字作為標識符
區分大小寫，變量num和變量Num是兩個變量。
2.2. 聲明
Go語言的變量聲明方式和其他語言（如C、Java、Python）不太一樣。
比如，我們聲明一個為int類型的變量a：
var a int
可以看出，Go語言聲明變量的方式為：
var <變量名> <變量類型>
我們還可以同時聲明多個類型相同的變量：
var <變量名1>, <變量名2>, <變量名3>, ... <變量類型>
使用分組同時聲明多個類型不同的變量：
var (
<變量名1> <變量類型1>
<變量名2> <變量類型2>
<變量名3> <變量類型3>
...
)
下面是一個具體的例子：
package main
import "fmt"
var i bool//類型在后
func main() {
var a, b, c int//多個
fmt.Println(i, a, b, c)
}
2.3. 初始化
當我們聲明變量時，可以對其進行初始化。當有初始值時，我們可以省略變量的類型，變量會根據對應的初始值獲取正確的類型。見下例：
package main
import "fmt"
var a int = 1
var b, c bool = true, false
func main() {
var i, j, k = 2, false, "行小觀" //省略變量類型
fmt.Println(a, b, c, i, j, k)
k = "行小觀2號" //賦值操作
fmt.Println(k)
}
若我們在聲明變量時，不給變量賦初始值，則這些變量會被賦予“零值”。
這些零值為：
- 數值類型為0
- 布爾類型為false
- 字符串為""（即空字符串）
如果上例中的代碼中的變量不進行初始化，即：
package main
import "fmt"
var a int
var b, c bool
func main() {
var i int
var j bool
var k string
fmt.Println(a, b, c, i, j, k)
}
則打印結果為：0 false false 0 false （變量k由於是空字符串，所以打印出來了但是看不到）
2.4. 短變量聲明
前面介紹了當我們聲明變量時有以下幾種方式：
var i int //聲明一個int變量
var i, j, k int //同時聲明多個int變量
var i int = 1 //聲明一個int變量並初始化
var i, j, k int = 1, 2, 3 //同時聲明多個int變量並分別初始化
var i = 1 //省略類型，聲明一個int變量並初始化
var i, j, k = 1, 2, 3 //省略類型，同時聲明多個int變量並分別初始化
除此之外還有一種更簡潔的聲明變量的方式：
i := 1
i, j, k := 1, 2, 3
當我們使用:=聲明變量時，不用寫var也不用寫類型，但是這種方式只能在函數內部使用，不能在函數外部使用。當在函數外部聲明變量時，只能使用var。
package main
import "fmt"
var a int = 1 //函數外部
func main() {
var i, j int = 2, 3 //函數內部
k := 4 //只能在函數中使用
v1, v2, v3 := true, false, "行小觀"
fmt.Println(a, i, j, k, v1, v2, v3)
}
此外，我們聲明的變量必須要使用，如果聲明了變量，但是沒使用，會在編譯時報錯。比如：
package main
import "fmt"
func main() {
var i bool
var j int //聲明了，但沒使用，會報錯
fmt.Println(i)
}
對於我們導入的包也有此要求，即：導入的包必須使用。
3. 數據類型
3.1. 布爾類型
布爾類型為bool，值可取true或false，默認值為false。
3.2. 字符串類型
字符串類型為string，默認為空字符串""。
3.3. 數值類型
整數類型分為：
-
有符號數：
int、int8、int16、int32 (rune)、int64 -
無符號數：
uint、uint8 (byte)、uint16、uint32、uint64、
其中int和uint的兩種類型的長度相同，取決於具體的編譯器，比如在32位系統上通常為32位，在64位系統上通常為64位。
像int8、uint8這些類型則是Go語言直接定義好位數的類型。rune、byte是int32、uint8的別名。
當我們需要使用整數時，應當盡量使用
int類型。當然，如果你有特殊的理由使用其他整數類型，便另當他論。
浮點數類型有兩種：float32和float64，注意沒有所謂的float類型。
復數類型也有兩種：complex64和complex128
注意：不同類型的變量之間不能直接進行賦值或其他運算（比如加減乘除）
package main
import "fmt"
var (
a int = 1
b int8 = 2
c int16
)
func main() {
c = b //不同類型之間進行賦值操作，[報錯1]
d := a + b //不同類型之間進行相加運算，[報錯2]
fmt.Printf("c = %v, d = %v", c, d)
}
以上代碼在編譯過程中會報錯：
[報錯1]：cannot use b (type int8) as type int16 in assignment
[報錯2]：invalid operation: a + b (mismatched types int and int8)
3.4. 類型轉換
前面一節說過：不同類型的變量之間不能直接進行賦值或其他運算，所以我們可以間接地做。
比如：將int8類型轉換為int類型，這樣就可以間接地進行賦值和其他運算。
使用表達式T(v)將變量v的值的類型轉換為T。注意是轉換的是變量的值，變量本身的類型不變。
package main
import "fmt"
var (
a int = 1
b int8 = 2
c uint
d int64
)
func main() {
c = uint(b) //將變量b的值2的類型從int8轉換為uint
d = int64(a) + int64(b)
fmt.Printf("c(%T):%v = b(%T):%v\n", c, c, b, b)
fmt.Printf("a(%T):%v + b(%T):%v = d(%T):%v\n", a, a, b, b, d, d)
}
注意：Go語言中的類型轉換是顯示的，表達式T()是必須的，不能省略。
4. 常量
常量是固定的值，值在程序運行期間不會改變。
常量可以定義為數值、字符串、布爾類型
常量的聲明方式和變量差不多，區別在於常量需要用const關鍵字修飾，不能使用:=進行聲明。
package main
import "fmt"
const num int = 555
var a int = 1
func main() {
const world = "世界"
const truth = true
fmt.Println("Hello,", world)
fmt.Println("num = ", num)
fmt.Println("a = ", a)
fmt.Println("對嗎?", truth)
}
5. 初識函數
如果你之前學習過C或者Java等語言，肯定已經對函數（方法）有了一定的認識。
簡單地來說，函數是對能完成某個功能的部分代碼的抽象。當以后再需要該功能，我們只需要調用其對用的函數即可，不必再重復編寫代碼。
5.1. 函數的聲明
我們在前面的內容已經使用到了函數，即main()。我們使用func關鍵字聲明函數。
func func_name() {
}
5.2. 函數的參數
Go語言中，函數可以有0個或多個參數。
package main
import "fmt"
func printName(name string, age int) {
fmt.Println("我叫", name, ", 今年", age, "歲了")
}
func sayHello() {
fmt.Println("行小觀說：“你好”")
}
func main() {
printName("行小觀", 1)
sayHello()
}
如果你有多個參數的類型相同，你可以進行簡寫，只需要在這幾個相同的參數最后寫一遍類型即可。
func foo(x int, y int, z int)
可以簡寫為：
func foo(x, y, x int)
5.3. 函數的類型和返回值
函數的類型在函數名之后。（盡快適應Go的這種風格：類型在變量名后）
package main
import "fmt"
func add(x int, y int) int {
return x + y
}
func main() {
fmt.Println(add(1, 2))
}
當函數沒有返回值時，不需要寫函數的類型：
func sayHello() {//沒有返回值，不寫函數類型
fmt.Println("行小觀說：“你好”")
}
函數可以有0個或多個返回值。
多個返回值就意味着該函數有多個返回值類型：
package main
import "fmt"
func sumAndDiff(x, y int) (int, int) { //兩個返回值類型
sum := x + y
diff := x - y
return sum, diff //兩個返回值
}
func main() {
a, b := sumAndDiff(5, 1)
fmt.Println(a, b)
}
注意：和參數不同，有幾個返回值就寫幾個返回值類型，不能簡寫。
Go語言還提供了另一種函數返回的方式：命名返回值。
顧名思義，我們通過給返回值進行命名，使用空return語句，這樣會直接返回已命名的返回值。如上例的sumAndDiff函數可以寫為：
func sumAndDiff(x, y int) (sum int, diff int) {//提前命名返回值
sum = x + y
diff = x - y //返回值在函數中被初始化
return //返回值已經初始化了，不需要再在return語句中寫變量了
}
下面總結一下函數的使用：
func functionName(input1, input11 type1, input2 type2 ...) (type1, type11, type2 ...){
//函數體
return value1, value11, value2 ...
}
或者命名返回值
func functionName(input1, input11 type1, input2 type2 ...) (output1 type1, output11 type11, output2 type2 ...){
//函數體
output1 = ...
output11 = ...
output2 = ...
...
return
}
6. 導出名
前面我們已經使用了import導入功能，比如improt "fmt"，該行代碼可以讓我們在本包中使用其他包里的函數。
那么我們如何讓其他包能夠使用到本包的方法或變量呢？答案是：將方法或變量導出。
在Go語言中，如果一個名字以大寫字母開頭，那么它就是已導出的，這意味着別的包可以使用它。（相當於Java中的public的作用）
比如我們常用的打印函數fmt.Println(...)，可以看到Println()的首字母是大寫的，所以我們能夠導入fmt包后使用該方法。
7. 流程控制語句
7.1. if語句
if語句是條件判斷語句，用來判斷是否滿足某種條件，如果滿足，則執行某段代碼；如果不滿足，則不執行。
if ... {
//代碼
} else if ... {
//代碼
} else {
//代碼
}
注意格式：條件判斷語句不需要使用小括號()。
下面是幾個例子：
if a > 0 {//如果滿足a>0，則打印Hello, World
fmt.Println("Hello, World")
}
if a > 0 {//如果滿足a>0，則打印 Hello, World
fmt.Println("Hello, World!")
} else {//否則（即不滿足a>0),則打印 你好，世界！
fmt.Println("你好，世界！")
}
if a > 5 {//如果滿足a>5，則打印 Hello, World
fmt.Println("Hello, World!")
} else if a <= 5 && a > 0 {//如果滿足0<a<=5，則打印 好好學習，天天向上
fmt.Println("好好學習，天天向上")
} else {//否則（即上面的條件都不滿足），則打印 你好，世界！
fmt.Println("你好，世界！")
}
Go語言的if語句有一個特性：可以在條件表達式前執行一個簡單的語句。下面是一個例子：
package main
import "fmt"
func sum(x, y int) int {
return x + y
}
func main () {
if i := sum(1, 2); i > 0 {
fmt.Println("Hello, World!")//作用域內，能打印i
}
//fmt.Println(i)//作用域外，不能打印i
}
在if語句中，使用sum(x, y int)函數計算出i的值，再進行判斷。注意：變量i的作用域只在if語句中有效。
7.2. for語句
for語句是Go語言中的循環控制語句。它有幾種形式：
（一）基本形式：
for 初始化語句; 條件表達式; 后置語句 {
//循環體代碼
}
- 初始化語句：在第一次循環前之前，且只執行這一次
- 條件表達式：每次循環都會計算該表達式，如果滿足（值為true）則繼續循環；如果不滿足（值為false），則跳出循環
- 后置語句：每次循環執行完都會執行該語句
下面是一個例子，循環打印5次"Hello,World！"
for i := 0; i < 5; i++ {
fmt.Println("Hello, World!", i)
}
注意該例的初始化語句i := 0是一個短變量聲明，變量i只在該for循環中生效。
（二）省略形式：
for循環中的初始化語句和后置語句是可以省略的。
i := 0
for ; i < 5; i++ {
fmt.Println("Hello, World!", i)
}
i := 0
for ; i < 5; {
fmt.Println("Hello, World!", i)
i++
}
從某種意義上來講，上面兩個例子並沒有省略初始化語句或后置語句，只是改變了位置。
（三）while形式
諸如C、Java等語言中都有while循環，但是Go語言中沒有while循環，但是我們可以使用for循環來實現“while循環”。
其實（二）省略形式中的第二個for循環例子就已經可以看做是while循環了。我們再稍做改進：
i := 0
for i < 5 {//去掉兩個分號，只寫條件表達式
fmt.Println("Hello, World!", i)
i++
}
（四）無限循環形式
//打印無限多個Hello, World!
for {
fmt.Println("Hello, World!")
}
7.3. break和continue
上面提到的循環語句只有當條件表達式的值為false時，才會停止循環。但實際開發中，我們可能在條件表達式的值為true的情況下，需要退出循環。這種時候，就需要使用break或continue語句。
break語句用來跳出當前循環，continue語句用來跳過本次循環。
下面是兩個實例（改進上面循環打印5次"Hello,World！"的例子）：
實例1：增加需求，當打印完第2遍Hello,World!時，停止打印
for i := 0; i < 5; i++ {
if i == 2 {
break
}
fmt.Println("Hello, World!", i)
}
實例2：增加需求，不打印第3遍Hello,World!
for i := 0; i < 5; i++ {
if i == 2 {
continue
}
fmt.Println("Hello, World!", i)
}
7.4. switch語句
我們可以使用if...else if...else if...進行一連串的條件判斷，但是這樣過於繁雜。switch語句就是用來簡化這個問題的。
switch 變量 {
case 選項1 :
//操作1代碼
case 選項2 :
//操作2代碼
case 選項3 :
//操作3代碼
case 選項n:
//操作n代碼
default :
//默認操作
}
switch語句中有許多case和一個default，只有當變量和case的選項相匹配時，才會執行對應的操作代碼。如果沒有case的選項可以匹配，則默認執行default的代碼。
下面是一個例子：
package main
import "fmt"
func sum(x, y int) int {
return x + y
}
func main () {
result := sum(3, 2)
switch result {
case 1 :
fmt.Println("結果為1")
case 2, 3, 4: //多種情況聚合在一起
fmt.Println("結果為2或3或4")
case sum(1, 4): //支持表達式
fmt.Println("結果為5")
default:
fmt.Println("其他結果")
}
}
從上面的例子可以看出，Go語言中switch的case支持常量（不必為整數）、表達式、多個值聚合。注意：不論是常量、表達式，還是多個值聚合，都要保證常量、表達式的值、多個值的類型和switch的變量相同。
switch語句的匹配順序是自上到下。Go語言自動為每個case提供了break語句，所以在眾多選項中只能執行1個case或default，然后結束，剩余的不再執行。
但是可以使用fallthrough強制執行剩余的case：
result := sum(1, 1)
switch result {
case 1 :
fmt.Println("結果為1")
fallthrough
case 2, 3, 4:
fmt.Println("結果為2或3或4")
fallthrough
case sum(1, 4):
fmt.Println("結果為5")
fallthrough
default:
fmt.Println("其他結果")
}
還是上面的那個例子，但是在每個case中使用fallthrough，現在的打印結果為：
結果為2或3或4
結果為5
其他結果
如有錯誤，還請指正。
文章首發於公眾號『行人觀學』
