1.常用命令

• go get 獲取遠端包
• go run 直接執行程式
• go build 測試編譯，檢查是否有編譯錯誤
• go fmt 格式化原始碼(部分IDE在儲存時自動呼叫)
• go install 編譯包檔案並編譯整個程式
• go test 執行測試檔案
• go doc 檢視文件

2.第一個go程式

package main

import (
	"fmt"
)

func main() {
	fmt.Println("hello 世界!")
}

控制檯輸出：

➜ go run test.go
hello 世界!

3.基礎知識點

• Go程式是通過package來組織的
• 只有package名稱為main的包可以包含main函式
• 一個可執行程式有且僅有一個main包
• 通過import關鍵字來匯入其他非main包

package main			//當前程式的包名，必須寫在第一行

import "fmt"			//import關鍵字匯入其他的包

import abc "fmt"		//包別名，用abc替換fmt

import(
	"fmt"				//多個包用()
	"time"
)

const PI = 3.14			//常量的定義

var name = "yuanmie"	//全域性變數的宣告與賦值
 


type newType int		//一般型別宣告

type gopher struct{}	//結構的宣告

type golang interface{}	//介面的宣告

func main() {			//由main函式作為程式入口點啟動
	fmt.Println("hello 世界!")
}

匯入包之後，就可以使用 <包名>.<函式名>來對包中的函式進行呼叫，例如：

func main() {			
	fmt.Println("hello 世界!")//fmt是包名，Println是函式名
}

如果匯入包之後未呼叫其中的函式或者型別將會報出編譯錯誤

package
 
 main

import (
	"fmt"
	"time"	//匯入了time包，但是沒呼叫就會報錯
)

func main() {
	fmt.Println("hello 世界!")
}

控制檯：

➜  gogogo go run test.go
# command-line-arguments
./test.go:9: imported and not used: "time"

4.可見性規則

Go語言中，使用大小寫來決定該常量，變數，型別，介面，結構或函式是否可以被外部包所呼叫，根據規定：

1. 函式名首字母小寫，即為private私有的，不可被外部呼叫
2. 函式名首字母大寫，即為public共有的，可以被外部呼叫

5.基本型別

1. 布林型：bool 長度：1位元組
   取值範圍：true, false
   注意事項：不可以用數字代表true或false
2. 整型：int/uint
   根據執行平臺可能為32或64位
3. 8位整型：int8/uint8
   長度：1位元組
   取值範圍：-128 ~ 127 / 0~255
4. 16位整型：int16/uint16
   長度：2位元組
   取值範圍：-32768 ~ 32767 / 0~65535
5. 32位整型：int32（rune別名）/uint32
   長度：4位元組
   取值範圍：-2^32/2 ~ 2^32/2-1 / 0 ~ 2^32-1
6. 64位整型：int64/uint64
   長度：8位元組
   取值範圍：-2^64/2 ~ 2^64/2-1 / 0 ~ 2^64-1
7. 位元組型：byte（uint8別名）
8. 浮點型：float32/float64
   長度：4/8位元組
   小數位：精確到7/15小數位
9. 複數：complex64/complex128
   長度：8/16位元組
10. 足夠儲存指標的 32 位或 64 位整數型：uintptr
11. 其它值型別：array、struct、string（陣列，結構，字串）
12. 引用型別：slice、map、chan（切片，類似於雜湊表，通道：用於併發）
13. 介面型別：inteface
14. 函式型別：func

型別零值 :

零值並不等於空值，而是當變數被宣告為某種型別後的預設值， 通常情況下值型別的預設值為0，bool為false，string為空字串

func main() {
	var a int
	var b bool
	fmt.Println(math.MaxInt8)	//127
	fmt.Println(a)	//0
	fmt.Println(b)	//false
}

類型別名

type (
	byte int8
	rune int32
	xxx  string	//xxx替代string
)
func main() {
	var a xxx;	//變數a就是字串型別
	a = "hahaha"
	fmt.Println(a)//0
}

6.變數

單個變數的宣告與賦值

var a int;	//變數的宣告
a = 1;		//變數的賦值
var b int = 123; //宣告同時賦值
var c = 234; //省略變數型別，由系統推斷
d := 456//簡寫，全域性宣告變數不可以簡寫，只有方法內宣告才可以簡寫

多個變數的宣告與賦值

• 全域性變數的宣告可使用 var() 的方式進行簡寫
• 全域性變數的宣告不可以省略 var，但可使用並行方式
• 所有變數都可以使用型別推斷
• 區域性變數不可以使用 var() 的方式簡寫，只能使用並行方式

// var (
// 	a = 1
// 	b = 2
// 	c = 3
// 	d = 4
// )
func main() {
	//var a, b, c, d = 1,2,3,4
	a, b, c, d := 1,2,3,4
	fmt.Println(a)	//1
	fmt.Println(b)	//2
	fmt.Println(c)	//3
	fmt.Println(d)	//4
}

變數的型別轉換

• Go中不存在隱式轉換，所有型別轉換必須顯式宣告
• 轉換隻能發生在兩種相互相容的型別之間

package main

import (
	"fmt"
	"strconv"
)
func main() {
	var a float32 = 100.111;
	fmt.Println(a);	//100.111
	b := int(a);
	fmt.Println(b);	//100

	var c bool = true;
	d := int(c)//轉換不了，無法通過編譯
	
	var a int = 65;
	b := string(a);
	c := strconv.Itoa(a);
	fmt.Println(a)	//64
	fmt.Println(b)	//A
	fmt.Println(c)	//65
	//string() 表示將資料轉換成文字格式，因為計算機中儲存的任何東西
	//本質上都是數字，因此此函式自然地認為我們需要的是用數字65表示
	//的文字 A。
	
	//引入strconv包，呼叫strconv包裡的Itoa方法就會打印出65，而不是轉成A
}

7.常量

常量的定義

• 常量的值在編譯時就已經確定
• 常量的定義格式與變數基本相同
• 等號右側必須是常量或者常量表達式
• 常量表達式中的函式必須是內建函式
• 常量規範最好大寫

常量的初始化規則與列舉

• 在定義常量組時，如果不提供初始值，則表示將使用上行的表示式

const(
	a = 1;
	b
)

func main() {
	fmt.Println(a)	//1
	fmt.Println(b)	//1
}

• 使用相同的表示式不代表具有相同的值
• iota是常量的計數器，從0開始，組中每定義1個常量自動遞增1
• 通過初始化規則與iota可以達到列舉的效果
• 每遇到一個const關鍵字，iota就會重置為0

const(
	a = 'A'
	b = iota
	c = 'B'
	d = iota
)
const(
	e = iota
)

func main() {
	fmt.Println(a)	//65
	fmt.Println(b)	//1
	fmt.Println(c)	//66
	fmt.Println(d)	//3
	fmt.Println(e)	//0
}

8.運算子

Go中的運算子均是從左至右結合

func main() {
	fmt.Println(1 << 10)	//左移 1024
}

/*
6 : 0110
11:	1011
--------------------
&	0010   都為1，才為1							2
|	1111   有一個1，就為1							15
^	1101   只有一個1時候才為1						13
&^	0100   第二個數為1時，第一個相對應的數強制變為0	4
*/

func main() {
	fmt.Println(6 & 11)		//2
	fmt.Println(6 | 11)		//15
	fmt.Println(6 ^ 11)		//13
	fmt.Println(6 &^ 11)	//4
}

demo

結合常量的iota與<<運算子實現計算機儲存單位的列舉

const(
	B float64 = 1 << (iota * 10) 
	KB
	MB
	GB
)

func main() {
	fmt.Println(B)		//1
	fmt.Println(KB)		//1024
	fmt.Println(MB)		//1.048576e+06
	fmt.Println(GB)		//1.073741824e+09
}

9.指標

• Go 擁有指標。指標儲存了值的記憶體地址。
• 型別 *T 是指向 T 型別值的指標。其零值為 nil。

var p *int

• & 操作符會生成一個指向其運算元的指標。

i := 42
p = &i

• *操作符表示指標指向的底層值。

fmt.Println(*p) 	// 通過指標 p 讀取 i
*p = 21         	// 通過指標 p 設定 i

• 這也就是通常所說的“間接引用”或“重定向”。

Go雖然保留了指標，但與其它程式語言不同的是，在Go當中不支援指標運算以及”->”運算子，而直接採用”.”選擇符來操作指標目標物件的成員

func main() {
    a := 1
    var p *int = &a
	fmt.Println(p)	//0xc42000e218 指向的是p的記憶體地址
	fmt.Println(*p)	//1
}

func main() {
	i, j := 42, 27

	p := &i         // 指向 i
	fmt.Println(*p)
	*p = 21         // 通過指標 p 設定 i
	fmt.Println(i)  // i變成了新的值
	
	p = &j         	// 指向 j
	*p = *p / 3 	// 通過指標 p 設定 j
	fmt.Println(j)  // j變成了新的值
}

結果：

42
21
9