Go基础——map与函数

8.map

key-value, 无序，引用类型
引用类型必须初始化以后才能使用，只是var定义了，并不能直接使用

8.1定义

map[KeyType]ValueType

map类型的变量默认值是nil需要使用make来分配内存

make(map[KeyType]ValueType, [cap])

cap表示map的容量，该参数不是必须的，但应该在初始化的时候就为其制定一个合适的值

score := make(map[string]int, 8)
score["python"] = 1
score["java"] = 2
fmt.Println(score)

map也支持在声明的时候填充元素，

map也支持在声明的时候填充元素，
score := map[string]int{
	"python": 1,
	"java":2,
}

8.2判断某个键是否存在

value, ok := map[key]

这个ok类型是true或者false

value, v := score["java"]
	if v {
		fmt.Println("value:", value)
	} else {
		fmt.Println("error")
	}

8.3遍历

for k, v := range score {
		fmt.Println("k:", k)
		fmt.Println("v:", v)
	}

如果只想遍历key

for k := range score {
		fmt.Println("k:", k)
		//fmt.Println("v:", v)
	}

8.4delete删除键值对

delete(map, key)

8.6练习题

//练习题
	var s string
	s = "how do you do"
	var lis = strings.Split(s, " ")
	fmt.Printf("typeof lis:%T", lis)
	var total = map[string]int{}
	for _, key := range lis {
		_, exist := total[key]
		if exist {
			total[key] += 1
		} else {
			total[key] = 1
		}
	}
	fmt.Println(total)

	type Map map[string][]int
	m := make(Map)
	s := []int{1, 2}
	s = append(s, 3)
	fmt.Printf("%+v\n", s) //1,2,3
	m["q1mi"] = s
	s = append(s[:1], s[2:]...)
	fmt.Printf("%+v\n", s) //1,3
	fmt.Printf("%+v\n", m["q1mi"]) //1,3,3


map里存的切片s 和外边的s不是同一个切片了，但是指向的数组是同一个的

9.函数

9.1定义

func 函数名(参数)(返回值){
    函数体
}

func test(x, y int)int{
	return x * y
}

9.2可变参数

//可变参数

func test2(x...int)int{
	fmt.Println(x)
	sum := 0
	for _,v := range x{
		sum += v
	}
    return sum
}

func test2(x int, y...int)int{
	sum := x
	for _, v := range y{
		sum += v
	}
	return sum
}

9.3多返回值

如果多个返回值，要将返回值包裹起来，

函数定义时可以给返回值命名，并在函数体中直接使用这些变量

func test4(x int, y int)(int, int){
	imul := x*y
	chu := x/y
	return imul, chu
}
//多返回值命名
func test5(x int,y int)(imul int, chu int){
    imul = x*y
    chu = x/y
    return imul, chu
}

if x > 0 {
		z := 100 //变量z只在if语句块生效
		fmt.Println(z)
	}
z只在if语句块中生效

函数返回值类型为slice时，nil可以看做是一个有效的slice

func sliceFunc(x string)[]int{
    if len(x)==0{
        return nil
    }
    ...
}

9.4定义函数类型

可以声明函数类型的变量并且为该变量赋值

type calculate func(int, int) int

func add(x, y int)int{
    return x + y
}

var c calculate
c = add
cc := c(10, 20)

9.5函数可以做参数和返回值

//参数
func canshu(x int, y int, op func(int, string)int)[]int{
    op(x+y, "helloeord")
}
//返回值
func ret(x int, y int)func(int)int{
    
}

9.6匿名函数

匿名函数因为没有函数名，所以没办法像普通函数那样调用，所以匿名函数需要保存到某个变量或者作为立即执行函数

func(x int){
    fmt.Println("starting---at :", x)
}(10)

9.7被defer的语句延迟执行

func test(){
	defer fmt.Println(1)
	defer fmt.Println(2)
	defer fmt.Println(3)
	fmt.Println("end")
}
//end
  3
  2
  1

9.8 异常处理

	defer func() {
		err := recover()
		if err != nil {
			fmt.Println("error detecated")
		}
	}()

func a() {
	fmt.Println("a")
}

func b() {
	defer func() {
		err := recover()
		if err != nil {
			fmt.Println("error detecated")
		}
	}()
	panic("b error")
}