Golang 速成手冊

如何使用集合

如何使用切片


// 特性: 可變、引用傳遞、堆分配
a := []int{1,2,3,4,5} // 簡寫並初始化
// 也可以指定下標進行佔位
a := []int{0:1,4:3}
// 增加
a = append(a, 6)
// 刪除
// 要刪除的元素下標
index := 2
// 刪除元素
slice = append(slice[:index], slice[index+1:]...)  // 這也是數組的合並
// 修改和讀取同數組

關於切片中的長度和容量的含義


// 長度（Length）指的是切片當前包含的元素個數。
// 容量（Capacity）指的是底層數組的大小，即切片可以容納的元素個數, 即系上限。
a := make([]byte, 5, 10) // 這意味着切片 a 可以容納最多 10 個 byte 類型的元素，但當前只有 5 個元素。
// 可以不指定容量
a := make([]byte, 5)
 
// 語法解釋 a[b:c] => 
// b 表示當前的下標，若空時則表示下標爲0
// c 表示當前的下標, 若空時則表示下標爲 len(a)
s := x[:] // 切片s指向了數組x的內存空間，改變切片s的值，也會影響數組x的值

如何遍歷切片


for k,v := range a {} 
for _,v := range a {} // 不需要下標
for k := range a {} // 只需要下標
for range time.Tick(time.Second) {} // 都不需要

如何使用數組


// 特性：大小長度固定、值傳遞、棧分配
a := [5]int{1,2,3,4,5}
// 無法增加或者刪除
// 修改
a[3] = 6
// 讀取
a[3]

如何使用switch


switch a {
case "a":
	// todo
case "b", "c":  // 匹配任何一個 b 或者 c 即可
	// todo
default:
	// todo
}
 
// 也可以前置一條語法程式碼
switch a:=1; a { ... }

如何使用for循環


for {}  // 相當於 while true
for a < 19 {} // 相當於  while a < 19
for a := 10; a<99; a++ {} // 普通用法
 
// 額外地也支持 break 和 continue 與 外層的label 配合
here:
    for i := 0; i < 2; i++ {
        for j := i + 1; j < 3; j++ {
            if i == 0 {
                continue here
            }
            fmt.Println(j)
            if j == 2 {
                break
            }
        }
    }
 
there:
    for i := 0; i < 2; i++ {
        for j := i + 1; j < 3; j++ {
            if j == 1 {
                continue
            }
            fmt.Println(j)
            if j == 2 {
                break there
            }
        }
    }

如何使用if的結構


if a > 0 {}
 
// 可額外添加程式碼語句並用分號結束
if a := b+c; a > 0 {}

關於包的與預設約束


在每個Go源文件的最開頭(不包括注釋)添加包聲明
可執行文件在main包裡
慣例：包名 == 包導入路徑的最後一個名稱(導入路徑 math/rand => 包名 rand)
大寫字母開頭的標識符: 表示可導出(exported)標識符， 對其它包可見
小寫字母開頭的標識符: 表示私有(private)標識符，對其它包不可見

如何聲明函數


func a() {}
func a(b int){}
func a(b, c int){} // 多個相同類型
func a() string {}
// 返回值
func a() (int,string){
  return 1, "1"
}
// 返回標志符, 只需要直接返回return
func a() (b int, c string){
	b = 1
	c = "1"
	return
}

函數的傳遞和閉包


// 作爲 參數 使用
add := func(a,b)int{
	return a+b
}
 
// 作爲 返回值 使用
func wrapAdd() (add func() int) {
	c := 1
	add = func() int { return c }
	return
}

函數可變參數


func a(args ...int) int {
	return 1
}

如何聲明相關變數


var a int = 1
a := 1
const a = "1"

iota 妙用

自增枚舉值


const (
	Red   = iota // 0
	Green        // 1
	Blue         // 2
)

使用位操作進行標志常量


const (
	FlagNone = 0      // 0
	FlagA    = 1 << iota // 1
	FlagB    = 1 << iota // 2
	FlagC    = 1 << iota // 4
)

跳過不需要的值


const (
	_  = iota             // 跳過第一個枚舉值
	January = 1 + iota    // 1
	February              // 2
	March                 // 3
)

引入其他文件方式

相對路徑導入：使用相對路徑導入其他文件。這種方式適用於在同一個項目中引用其他文件。例如，import "./utils" 將引入當前項目中的 utils 文件。
絕對路徑導入：使用絕對路徑導入其他文件。這種方式適用於引用位於不同項目或庫中的文件。例如，import "github.com/example/package" 將引入 github.com/example/package 包中的文件。
標準庫導入：Go 語言提供了許多標準庫，可以直接使用它們而無需進行額外的導入。例如，import "fmt" 將導入標準庫中的 fmt 包。
別名導入：可以爲導入的包或文件設定別名，以便在程式碼中使用更簡潔的名稱。例如，import utils "github.com/example/package" 將爲 github.com/example/package 設定別名爲 utils，之後可以使用 utils 來存取該包的內容。
空白標識符導入：有時你可能只是想爲了執行文件中的 init 函數，而不需要使用該文件中的其他內容。在這種情況下，可以使用空白標識符 _ 進行導入。例如，import _ "github.com/example/package" 將執行 github.com/example/package 包中的 init 函數，但不會在程式碼中使用該包的其他內容。
使用點操作符導入的好處是可以使程式碼更簡潔，但也可能導致程式碼可讀性下

常用cli命令


go build：用於編譯 Go 程式碼並生成可執行文件。例如，go build main.go 將編譯 main.go 文件並生成可執行文件。
 
go run：用於編譯並執行 Go 程式碼。例如，go run main.go 將編譯並直接執行 main.go 文件。
 
go test：用於執行 Go 單元測試。透過 go test 命令，可以自動執行項目中的測試文件並輸出測試結果。
 
go get：用於獲取並安裝第三方依賴包。例如，go get github.com/example/package 將獲取並安裝 github.com/example/package 依賴包。
 
go mod init：用於初始化 Go 項目的模塊管理。透過執行 go mod init 命令，可以創建一個新的 go.mod 文件，用於管理項目的依賴關系。
 
go mod tidy：用於自動清理項目中不再使用的依賴項。執行 go mod tidy 命令會檢查項目的依賴關系，並刪除不再需要的依賴項。
 
go mod vendor：用於將項目的依賴項複製到項目的 vendor 目錄下。透過執行 go mod vendor 命令，可以將所有依賴項複製到項目中，以便離線構建和部署。
 
go doc：用於查看 Go 程式碼的文件。例如，go doc fmt.Println 將顯示 fmt 包中 Println 函數的文件。