GO基础，数组、切片、Map、函数

数组:

定义:

　　方式一:

arr1 := [...]int{1,2,3} 

　　方式二: arr2 := [3]int{1,2,3}

　　方式三: var arr3 [3]int

遍历:

//遍历数组
        for k, v :=range arr3{
                fmt.Println("key:%v,value:$v",k,v)
        }

值类型和引用类型:

1.基本数据类型 和 数组 都为值类型

2.改变副本值会影响原来值的为引用数据类型 指向的为同一个内存地址 。包含(切片)

定义二维数组:

    //定义二维数组
        arr := [3][2]string{
                {"北京","上海"},
                {"武汉","长沙"},
                {"南昌","成都"},
        }
        //遍历
        for _,v1 :=range arr{
                for _,v2 := range v1 {
                        println(v2)
                }
        }
                

切片


切片的本质就是对底层数组的封装 ，类似可变长度数组  声明未复制 默认值为 nil
len(s)获取长度, cap(s)获取容量
长度:所含元素个数
容量:从第一个元素开始数，到底层数组末尾的个数
append()为切片动态添加元素,长度和容量同时会增加
合并切片

        sliceA := []string{"张三丰","张学友","张国荣"}
        sliceB := []string{"刘德华","谢霆锋","阿三"}
        sliceA = append(sliceA,sliceB...)
        fmt.Println(sliceA)

　copy()复制切片 防止改变副本而改变本身

        sliceA := []string{"张三丰","张学友","张国荣"}
        sliceB := make([]string,4,4)
        //sliceC := []string{"刘德华","谢霆锋","阿三"}
        //sliceA = append(sliceA,sliceB...,sliceC...)
        copy(sliceB,sliceA) //把sliceA拷贝给sliceB中
        fmt.Println(sliceB) 

　删除切片元素

　　用append方法删除

字符串 切片的互换

       //字符串转切片
        s1 := "你好 golang"
        runeStr := []rune(s1)
        runeStr[0] = '您'
        fmt.Println(string(runeStr))

Map
是无序的k-v数据结构 为引用类型 必须初始化 默认值为nil

       //方式一
        var userinfo = make(map[string]string) //创建集合 第一个string为key的类型  第二个string为值的类型
        userinfo["title"] = "111"
        fmt.Println(userinfo)
        //方式二
        userdata := map[string]string{
                "ID":"1",
                "title":"测试标题",
        }
        fmt.Println(userdata)判断

判断某个key是否存在

v,ok := userdata["title"] //如果存在 v就是值 ok就为true  不存在 v就是空 ok就为false删除

删除key

delete(userdata, "title") //userData为map  title为key创建

创建一个Map类型的切片

       //创建一个元素为map类型的切片
        var userinfo = make([]map[string]string,3,3)
        if(userinfo[0] == nil){
                userinfo[0] = make(map[string]string)
                userinfo[0]["title"] = "测试标题"
        }
        fmt.Println(userinfo)值

值为切片类型的Map对象

      //创建一个值为切片的map
        var userinfo = make(map[string][]string)
        userinfo["hobby"] = []string{
                "吃饭","睡觉",
        }
        fmt.Println(userinfo)　

函数

定义多参数的函数

//函数
func sumFn1(x ...int){ //不固定参数
        fmt.Println(x)
}

//调用
sumFn1(1,2,3,4,5)

自定义函数类型

type calc func(x,y int) int  //定义个calc类型的函数

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


func main(){
        var c calc
        c = add  //add必须和C类型一致
        fmt.Printf("c的类型%T",c)
        //调用
        d := c(2,7)
        fmt.Println(d)
}　

　函数递归

func fnDg(n int) int{
        if n > 1{
                return n + fnDg(n-1)
        }else{
                return 1
        }
}

func main(){
        //函数递归
        sum := fnDg(100) //计算1-100的和
        fmt.Println(sum)

}　

　闭包

func add(x int) func() int{
        return func() int {
                return x+1
        }
}

func main(){
        //闭包函数 -- 全局变量会常驻内存,污染全局 ,闭包可以让一个变量常驻内存并不会污染全局
        //闭包是指有权访问另一个函数作用域中变量的函数
        //注意事项:由于闭包里局部变量资源不会立即销毁，所以可能会占用更多的内存
        var fn = add(2)() //返回的是一个函数 执行的话需带()
        fmt.Println(fn)

defer

//defer语句 -- 会将其后面跟随的语句延时处理 defer所属函数即将返回时 将延时语句逆向执行 (先被defer的语句最后执行 后被defer的语句先执行)
        defer fmt.Println("111")
        defer fmt.Println("222")
        defer fmt.Println("333")
        defer fmt.Println("444")

        //匿名返回值和命名返回值
        //匿名返回值不影响
        //命名返回值是执行之后的值

panic和recover

//panic在任何地方都可以触发  recover监听panic的异常 只有在defer调用的函数中有效
func fn1(){
        defer func() {
                err := recover()
                if err != nil {
                        fmt.Println(err)
                }
        }()
        panic("发现异常")
}

//make和new内存分配 (new主要针对指针类型 make主要用于map、切片和channel)