1. 認識HelloWorld

在前面的《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)
}

若我們在宣告變數時，不給變數賦初始值，則這些變數會被賦予“零值”。

這些零值為：

1. 數值型別為0
2. 布林型別為false
3. 字串為""（即空字串）

如果上例中的程式碼中的變數不進行初始化，即：

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
其他結果

如有錯誤，還請指正。

文章首發於公眾號『行人觀學』