go語言學習筆記2

go時間和日期

2006/01/02 15：04：05這個時間是固定的

package main
import "fmt"
import "time"

func main(){
    now := time.Now()
    fmt.Printf("Year=%v\n", now.Year())
    fmt.Printf("Month=%v\n", now.Month())
    fmt.Printf("Month=%v\n", int(now.Month()))
    fmt.Printf("Day=%v\n", now.Day())
	fmt.Printf("Hour=%v\n", now.Hour())
    fmt.Printf("Minute=%v\n", now.Minute())
    fmt.Printf("Second=%v\n", now.Second())
    fmt.Printf("%d-%d-%d %d:%d:%d\n", now.Year(), int(now.Month()), now.Day(), now.Hour(), now.Second(), now.Second())
    fmt.Printf(now.Format("2006/01/02 15:04:05"))
}

輸出結果：

go內置函數

• new使用

• make分配引用類型的內存

go錯誤處理

1. go中沒有try-catch-finally處理異常
2. go引入defer，panic，recover處理異常

package main
import "fmt"

func test(){
	defer func(){
		err := recover() //recover是內置函數，可以捕獲異常
		if err != nil{
			fmt.Println("err=", err)
		}
	}()
	// 匿名函數，定義時（）調用
	num1 := 10
	num2 := 0
	res := num1 / num2
	fmt.Println("res=", res)
}


func main(){
	test()
	fmt.Println("meet error")
}

輸出結果：

• go自定義錯誤

import "errors"

func readconf(name string) (err error){
	if name == "config.ini"{
		return nil    //正常返回
	}else{
		return errors.New("read file error")
	}
}


func main(){
	res := readconf("ini")
	if res != nil{
		panic(res)  //輸出錯誤，退出程序
	}
	fmt.Println("exit...")  //不會執行

}

go數組

定義數組：var hens [6]float64，有默認值0，定義時必須指定大小

給數組賦值：hens[0] = 1.2

數組的首地址：&hens = 0xc0404a00a0 就是第一個元素的地址&hens[0]

若數組時int32類型，地址之間hens[0], hens[1]相差4

4種初始化數組方式

	var arr1 [3]int = [3]int{1,2,3}
	var arr2 = [3]int{1,2,3}
	var arr3 = [...]int{1,2,3,4}
	var arr4 = [...]int{1:100, 0:50}
	fmt.Println("arr1="arr1)

• 數組是值傳遞，arr仍保持原值
  
• 指針傳遞，效率高
  *arr相當於拿到數組，必須加（）
  

go切片

• 引用傳遞，長度可變

var arr = [...]int{1,2,3,4}
slice := arr[1:3]  //包含前不包含後
slice[0] = 100   //數組的值也會變，因爲他們指向同一內存空間
fmt.Println("切片的容量var=", cap(slice))   //動態可變

切片在內存中

• 通過make創建切片，會先創建數組默認值int，float=0

var 切片名 []int = make([]int, len, cap)，cap是可選的且cap>=len，默認=len

var slice []int = make([]int, 4, 10)
slice[0] = 100
slice[1] = 200

• 可以在切片裏繼續創建切片
• 擴展切片append

var slice []int = []int{1,2,3}
slice2 = append(slice, 4, 5, 6)

//在slice基礎上追加slice2（必須是切片，...不能省略）
slice3 = append(slice, slice2...)

fmt.Println("slice=", slice)    // 1,2,3
fmt.Println("slice2=", slice2)  // 1,2,3,4,5,6

• 切片之間copy

var a []int = []int{1,2,3}
var slice = make([]int, 10) //切片如果len=1，也不會報錯，只會copy第一個
copy(slice, a)  //將a拷貝到slice裏

• string切片處理

str := "[email protected]"
str[0] = 'm'   //報錯，字符串不允許改變

slice := str[4:]  //切片

//要修改字符串，要先改爲[]byte或[]rune，再重新轉爲string
arr := []byte(str)   //str轉爲byte切片
arr[0] = 'm'
str = string(arr)

*byte有個問題是無法轉換漢字，因爲byte是按字節存儲，而一個漢字需要3個自己，換成rune可以解決

go二維數組

聲明：var arr [3][3]int
arr[0][0] = 0

var arr [2][3]int = [2][3]int{{1,2,3}, {4,5,6}}

map集合

聲明：var map名字 map[keytype]valuetype

聲明是不會分配內存，只有在make時才分配，這一點切片和map區別於數組，數組是聲明時直接分配內存空間

// 第一種創建方式
var pjson map[string]string
pjson = make(map[string]string, 10)
pjson['name'] = 'amber'

注意：map是無序的，每次遍歷得到的順序不一樣，不像python按照添加key排序

//  第二種創建方式(可以不指定長度len)
pjson := make(map[string]string)
pjson['name'] = 'amber'

//  第三種創建方式
pjson := map[string][string]{
	"name": "amber",
	"age": 21,
	// 注意，逗號不能省略
}

• 嵌套：{“stu1”: {“name”: “alice”, “age”: “12”}, “stu2”: {“name”: “mike”, “age”: “19”}, }

student := make(map[string]map[string]string)
student["stu1"] = make(map[string]string)
student["stu1"]["name"] = "alice"
student["stu1"]["age"] = "12"

• maps刪除key，若key不存在也不會報錯

delete(student, "stu1")

• map查找

// val是key對應的value，flag返回bool顯示是否找到
val, flag := student["stu1"]
if flag {
	fmt.Println(val)
}

• map遍歷
  不可以使用for循環，只能用for-range,因爲map的key不一定是數字

for key, value := range student {
	fmt.Println(key)
	fmt.Println(value)
}

• map長度

num := len(student)

• map切片
  定義：切片的數據類型是map就可以，就可以動態增加切片

// make切片必須指定大小，後續可通過append增加
// make map可以不指定

var mapslice []map[string]string= make([]map[string]string, 4, 10)
mapslice[0] = make(map[string]string)
mapslice[0]["name"] = "Alex"

newstu := map[string]string {
	"name" = "Jake",
	"age" = "45",
}
mapslice = append(mapslice, newstu)

• map排序

1. 將key放進切片裏
2. 對切片排序
3. 遍歷切片

import "sort"

//student [1:"alice", 8: "amber"]
var keys []int
for k,_ := range student {
	keys = append(keys, k)
}
sort.Ints(keys)
for i := range keys {
	fmt.Println(student[i])
}

• map使用細節

1. map同切片都是引用類型，對元素修改會修改直接影響內存的值
2. map達到容量後會動態擴容，不像切片需要append
3. map的value更適合struct類型