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 := "aaa@123.com"
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类型