wangyishuaideMacBook-Pro:goStu wangyishuai$ rm hello
wangyishuaideMacBook-Pro:goStu wangyishuai$ ls
hello.go
wangyishuaideMacBook-Pro:goStu wangyishuai$ go run hello.go
hello world!
wangyishuaideMacBook-Pro:goStu wangyishuai$ ls
hello.go

有一個小坑，如果import的包不用，編譯會報錯。比如，fmt包匯入了就必須使用，類似的包括變數等。當註釋掉第8行程式碼，在執行會報錯，這點嚴謹性，比Java強多了。

wangyishuaideMacBook-Pro:goStu wangyishuai$ go run hello.go
# command-line-arguments
./hello.go:2:8: imported and not used: "fmt"

go的常用關鍵字（25個）

• var和const ：變數和常量的宣告
• var varName type  或者 varName : = value
• package and import: 匯入
• func： 用於定義函式和方法
• return ：用於從函式返回
• defer someCode ：在函式退出之前執行
• go : 用於並行
• select 用於選擇不同型別的通訊
• interface 用於定義介面
• struct 用於定義抽象資料型別
• break、case、continue、for、fallthrough、else、if、switch、goto、default 流程控制
• chan用於channel通訊
• type用於宣告自定義型別
• map用於宣告map型別資料
• range用於讀取slice、map、channel資料

如上，其實和其他大部分語言都差不多。其中go、chan、以及select是go的特色和重點，又比如map類似Java的hashmap……其他的也沒什麼新鮮的，接下來快速過。

go程式的組織模式

go程式類似Java，都是通過package組織，然後每個獨立的、可執行的go程式的入口必須都是main函式，也就是main包裡的main函式。

變數和常量

使用var關鍵字

var是go最基本的定義變數方式 ，但是它的變數型別是放在了變數名後面。

如下，格式化列印語句

Printf

和C語言非常像，其實go就是C語言衍生改進而來，這也是為什麼稱它為網際網路世界中的C語言的原因。

package main 

import (
	"fmt"
)

func main() {
	var x int;
	x = 1;
	fmt.Printf("%d", x);
}

簡潔的定義

有時候會覺得總是多寫一個var比較煩，那麼可以用:=來定義變數（個人感覺也不是想象中的那麼簡潔……）

package main 

import (
    "fmt"
)

func main() {
    var x int;
    x = 1;
    fmt.Printf("%d", x);
    
    a, b, c := 1, 2, 3; // 自動判斷型別，類似Python
    fmt.Println(a, b, c);
}

這種方式類似Python，省去了寫型別的步驟，在go程式中十分常見。但是這樣的寫法有一個缺點：:= 無法用於函式體外部，而var可以。故var也是有存在的必要的。

eclipse直接提示變數y的定義錯誤，而變數x是ok的。

注意：

1、package和import必須挨著，也就是它們中間不能有其他程式碼，否則報錯。

2、對於沒有顯式初始化的變數，Go語言總是將零值賦值給該變數。

3、在Go語言中，宣告變數的時候，型別名總是在變數名的後面。

const常量

沒什麼可說的，和C語言一樣的用法，唯一不同的就是定義常量時，加型別或者不加都可以，但是注意，最好養成習慣，型別加在常量名後面。

func main() {    
    fmt.Println(x);
    const dashuai string = "dashuai";
    const gogogo = 888;
}

而且，字串資料型別和Java不太一樣，是完全小寫的string。下面會說到。

注意：

1、當需要設定多個常量的時候，不必重複使用const，可以使用小括號設定 (var同理)

package main

import (
    "fmt"
)

func main() {
    var (
        a int;
        b string;
        c bool;
    )
    
    fmt.Println(a, b, c) // 0  false
    
    const (
        aa = 1
        bb = "dada"
        cc = true
    )
    
    fmt.Println(aa, bb, cc) 
}

資料型別

bool byte complex64 complex128 error float32 float64
int int8 int16 int32 int64 rune string
uint uint8 uint16 uint32 uint64 uintptr

無型別的數值常量可以相容go內建的任何型別的數值

在不同型別數值之間進行運算或者比較操作，需要進行型別轉換。型別轉換採用type(value)的方式，只要合法就能轉換成功，即使會導致資料精度丟失。

快速過一下，和Java對比，如下常用的幾個：

整型

1、go獨有的 rune，其實就是代表了無符號32位整型 unit32。

2、有符號整型 int （依賴於os，可能是int32或者int64）

1. int8 [-128, 127]
2. int16 [-32768, 32767]
3. int32 [-2147483648, 2147483647]
4. int64 [-9223372036854775808, 9223372036854775807]

也就是說，go是見名知意，go中可以直接定義xxx位的整型。

3、位元組 byte，等價於 uint8

4、無符號整型 uint ，依賴於不同os實現，可以是uint32或者uint64

1. uint8 [0, 255]
2. uint16 [0, 65535]
3. uint32 [0, 4294967295]
4. uint64 [0, 18446744073709551615]
5. uintptr 一個可以恰好容納指標值的無符號整型（對32位平臺是uint32, 對64位平臺是uint64）

可以通過unsafe.Sizeof函式實現類似C語言裡sizeof操作符的功能，檢視型別的位元組長度。

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    str := "dashuai"
    fmt.Println(unsafe.Sizeof(str)) // 16

    a := 1
    fmt.Println(unsafe.Sizeof(a)) // 8

    var b int8 = 1
    fmt.Println(unsafe.Sizeof(b)) // 1

    var c int32 = 1
    fmt.Println(unsafe.Sizeof(c)) // 4

    var d int64 = 1
    fmt.Println(unsafe.Sizeof(d)) // 8
}

unsafe包含了用於獲取Go語言型別資訊的方法。

浮點型別

1、float32 ，±3.402 823 466 385 288 598 117 041 834 845 169 254 40x1038 計算精度大概是小數點後7個十進位制數

2、float64，±1.797 693 134 862 315 708 145 274 237 317 043 567 981x1038 計算精度大概是小數點後15個十進位制數

布林型別 bool（取值true false）

注意區分Java的boolean/Boolean寫法，其實是和C語言一樣，這裡也說下，學習go，就對比著C語言和Java語言，這樣用起來是很快的。

布林值使用內建的true和false。Go語言支援標準的邏輯和比較操作，這些操作的結果都是布林值。還可以通過!b的方式反轉變數b的真假。也就是邏輯非。

go可直接定義複數

這也是go獨有的， complex32、complex64，在針對一些演算法的實現時，非常方便，比如傅立葉變換。

func main() {    
    var x complex64 = 10 + 9i;
    fmt.Print(x + x);    
}

complex32複數，實部和虛部都是float32

complex64複數，實部和虛部都是float64

字串

常用是string定義，Go語言中的字串是 UTF-8編碼格式（當字元為 ASCII 碼時則佔用 1 個位元組，其它字元根據需要佔用 2-4 個位元組）。

UTF-8 是被廣泛使用的編碼格式，是文字檔案的標準編碼，其它包括 XML 和 JSON 在內，也都使用該編碼。由於該編碼對佔用位元組長度的不定性，Go 中的字串也可能根據需要佔用 1 至 4 個位元組，這與C++、Java 或者 Python 不同。

Go 這樣做的好處是：不僅減少了記憶體和硬碟空間佔用，同時也不用像其它語言那樣需要對使用 UTF-8 字符集的文字進行編碼和解碼。

Go語言中字串的可以使用雙引號( " )或者反引號( ` )來建立。

雙引號用來建立可解析的字串，所謂可解析的是指字串中的一些符號可以被格式化為其他內容，如 "\n" 在輸出時候會被格式化成換行符， 如果需要按照原始字元輸出必須進行轉義。

反引號建立的字串原始是什麼樣，那輸出還是什麼，不需要進行任何轉義。

package main

import (
    "fmt"
)

func main() {
    str := "123"
    str1 := "\n"
    str2 := `\n`
    str3 := "\\n"
    fmt.Println(str) // 123
    fmt.Println(str1) // 換行
    fmt.Println(str2) // \n
    fmt.Println(str3) // \n 
}

注意

1、Go語言中的部分轉義字元
\\ 反斜線

\'  單引號

\" 雙引號

\n 換行符

\uhhhh  4個16進位制數字給定的Unicode字元

2、在Go語言中單個字元可以使用單引號 ' 來建立。而且，一個單一的字元可以用一個單一的rune來表示（rune是uint32型別）。這也是容易理解的，因為Go語言的字串是UTF-8編碼，其底層使用4個位元組表示，也就是32 bit。

格式化字串

目前為止，使用了fmt.Printf和fmt.Prinfln，對於前者的使用，就像C語言中的printf函式一樣，常用的格式化指令如下：

常用的格式化指令修飾符如下：

• 空白 如果輸出的數字為負，則在其前面加上一個減號"-"。如果輸出的是整數，則在前面加一個空格。使用%x或者%X格式化指令輸出時，會在結果之間新增一個空格。例如fmt.Printf("% X", "實")輸出E5 AE 9E
• #
  • %#o 輸出以0開始的八進位制資料
  • %#x 輸出以0x開始的十六進位制資料
• + 讓格式化指令在數值前面輸出+號或者-號，為字串輸出ASCII字元（非ASCII字元會被轉義），為結構體輸出其欄位名
• - 讓格式化指令將值向左對齊（預設值為像右對齊）
• 0 讓格式指令以數字0而非空白進行填充

字串處理包

strings 包提供瞭如查詢字串，分割字串，判斷前後綴，判斷字串包含，字串替換，統計字串出現的次數等常用操作。

strconv 包提供了許多可以在字串和其他型別的資料之間進行轉換的函式。例如可以將數字轉換為字串，將數字樣式的字串轉換為數值（將字串"12345"轉換int型別的整數）

這些直接查文件就可以了。

陣列 array slice

array可以類比Python的元組，slice可以類比Python的列表，Java的list，很好理解。

package main 

import (
    "fmt"
)

/*
array用法
*/
func main() {    
    var x [10]int;
    x[0] = 100;
    x[8] = 800;
    // %v 可以直接遍歷列印陣列，非常方便，C語言是沒有的。非常高階的用法%v，意思是value，同樣陣列也不能越界使用。
    // 如果沒有初值，自動設為0
    fmt.Printf("%v \n", x);    
    // 看長度，和Python的len函式一樣
    fmt.Println(len(x));
    
    var str [5]string;
    str[3] = "aaaa";
    // 預設初值為空串
    fmt.Printf("%v \n", str);
    
    // 如果使用簡潔宣告，那麼可以直接賦值
    y := [3]int{1, 2, 3}
    fmt.Printf("%v \n", y);
}

在看下slice，其實它就是一個動態陣列

    var x [10]int; // 這是一個靜態陣列，array，之前說過了
    var slice_x []int; // 非常明顯，不需要顯式宣告長度

還可以通過從一個數組或在一個已經存在的slice中再次宣告slice

    xx := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // 一個靜態陣列
    z := xx[1:3]; //對xx切片（和Python一樣的道理），切片範圍是前閉後開區間，也就是截取了2，3。然後擷取的結果賦值給陣列z，go的陣列同樣從下標0開始

其實，現在的z就變為了動態陣列slice，類似於指標。

同樣slice也可以用簡潔方式宣告，並且配合關鍵字make去分配記憶體空間，make用於內建型別（map、slice 和channel）的記憶體分配，有些類似C語言的malloc。

package main 

import (
    "fmt"
)

func main() {
    x := make([]int, 3, 8); // 長度為3，容量為8
    fmt.Printf("%v \n", x); // [0 0 0] 
    
    // 會自動擴容
    x = append(x, 1, 2, 3, 4, 5, 6, 7, 8);
    fmt.Printf("%v \n", x); // [0 0 0 1 2 3 4 5 6 7 8] 
    fmt.Printf("%v %v \n", len(x), cap(x)); // 11 16 
}

小結

1、總的來說，如下圖，可以從一個array宣告slice，其實就是指標指向。

2、在Go語言中，字串支援切片操作，但是需要注意的是：

如果字串都是由ASCII字元組成，那可以隨便使用切片進行操作

如果字串中包含其他非ASCII字元，直接使用切片獲取想要的單個字元時需要十分小心，因為對字串直接使用切片時是通過位元組進行索引的，但是非ASCII字元在記憶體中可能不是由一個位元組組成。如果想對字串中字元依次訪問，可以使用range操作符。

另外獲取字串的長度可能有兩種含義，一種是指獲取字串的位元組長度，一種是指獲取字串的字元數量。

3、字串支援以下操作：

指標

通常情況下Go語言中的變數持有相應的值。也就是說，我們可以將一個變數想象成它所持有的值來使用。

其中有些例外：通道、函式、方法、map、切片slice 是引用變數，它們持有的都是引用，也即儲存指標的變數。

在go中，值在傳遞給函式或者方法的時候會被複制一次，對於布林型別和數值型別來說這so easy，但是對於大型變數卻代價很大。而且複製值傳參的方式，修改值只是修改了副本，這能保證原始變數不被修改，但也一定程度上增加了修改原始值的麻煩。（和C語言一樣的道理，同樣go也保留了C語言的指標）

Go語言中有指標，也沒什麼新鮮東西，同樣在每次傳遞給函式或者方法的只是變數的記憶體地址，這是非常高效的。而且一個被指標指向的變數可以通過該指標來修改，這就很方便的在函式或者方法中通過指標修改原始變數。

Go語言中的指標操作符也是使用&和*操作符。

交換兩個變數

func swap1(x, y, p *int) {
    if *x > *y {
        *x, *y = *y, *x
    }

    *p = *x + *y
}

map

類比Java的hashmap，在go中，常用於json解碼等。map和Java的雜湊表一樣，必須申請記憶體，使用make，否則報錯

    var a map[string]int32;
    a["aaaa"] = 111;
    fmt.Printf("%v \n", a); 

執行出錯，nil就是null，零值。