go语言数据类型

一.Go 语言有四大显著特点：高效性：编译与运行效率高。并发性：原生支持并发编程。简洁性：编程风格简洁直接，代码可读性与可维护性高。跨平台性：程序能在 Windows、Linux、Mac OS 等多系统运行。二.go的包:package1.main:主函数2.fmt:输出     	 #fmt.Println()3.rand:随机数  rand.Intn(n) #生成0-n之间的随机数三.go的工具链组件: import 1.go mod init+自定义名称	#初始化项目,生成项目文件2.go run + 文件		#编译并执行文件 	3.go build       		#编译,将当前目录中的.go文件编译为可执行文件go build -o demo01_app demo01.go//-o demo01_app 指定可执行文件的名字4.go doc 组件名称            #查看组件的文档四.变量(var):变量申明后必须要使用1.声明赋值:var  变量名1,变量名2 数据类型 = a,bvar name,name2 string =a,b(1)声明多个不同类型的变量:var (name    stringage     intaddress string)2.短变量:不需要申明类型,系统自动判断类型格式: name := "jack" // 字符串类型的变量。3.匿名变量:a, b, _ := 1, 2, 3:表示第三个值不使用4.交换变量num1, num2 := 25, 36nam1, num2 = num2, num1五.常量(const):不允许重新赋值1.声明赋值:const name string = "Jack"声明多个常量:const(a int=1b string ="aa")2.iota:声明无类型的"整数"序数(等差数列)const (a = iotabc)六.输出和输入格式化输出:fmt.Printf()1.%v   #任意类型2.%s   #字符型3.%d   #整型4.%.2f #浮点:保留两位小数5.%t   #布尔值6.%T   #输出类型7.%c	 #编码转换,输出对应字符获取键盘输入:fmt.Scan(&a,&b)，控制台空格间隔,输完参数自动结束,&为固定的绑定变量值的符号fmt.Scanln(&a,&b)，控制台空格间隔,输完参数回车结束七.数据类型
1.基本数据类型(1)整型有符号整型(分正负) int8/16/32/64,默认由操作系统决定 [-32768, 32767]无符号整型(不分正负) uint8/16/32/64	 [0, 65535](2)浮点float32	32位浮点数float64	64位浮点数(短变量默认类型)(3)布尔类型bool	true为真值，false为假值var b1 bool = true(4)字符串类型1)字符串string	字符串,字符串可以用双引号""或反引号``来表示str := "Hello, World!"multilineStr := `       //可以换行This is amultiline string.`2)字符串的拼接:+str1 := "Hello, "str2 := "World!"str = str1+str23)字符串长度,单位是字节,英文占一个字节,汉字占三个字节:lenstr := "Hello, World!"length := len(str) 4)字符串索引:[],输出ascii码，的值用string()转回str := "Hello世界"firstChar := str[0]           secondChar := str[5]   #汉字占三个字节,这样只取出一个字节fmt.Println(firstChar, secondChar) // 输出 '72' 和 '228'// 编码转换fmt.Println(string(firstChar), string(secondChar)5)字符串切片:可以取出汉字的内容,按照字节进行计数str[start:end]：从start到end（不包括end）。str[:]：获取字符串的完整副本str := "Hello世界"fmt.Println(str2[5:8]) // "世"(5)字符型:可输出中文完整的ascii编码，使用string()可以转换，0到2551)byte,使用单引号包括一个字符,相当于uint8var a byte = 'a' fmt.Println(a)  // 97,输出ASCII编码值2)rune,相当于int32，0到65535var b rune = '中'fmt.Println(b)  // 20013(6) \转义字符\n   换行符号\t   横向制表符号(多空格)\b   回退符号\f   换页符号(7)零值:一个类型的空值或者说默认值更为准确。var i int  // 默认为0var s8 string  // 默认为""var b3 bool  // 默认为false2.各种引用数据类型1.数组1.数组初始化（1）初始化一个长度为5的整型数组var nums [5]intnames = [3]string{"1","2","3"}for i := 0; i < index; i++ {newArr[i] = arr[i]}（2）也可以用元素初始化nums := [5]int{1, 2, 3}（3）自动设置长度nums := [...]int{3, 8, 7, 12}(1)下标访问：names[i](2)切片访问：names[n:m]，不包括m,从0开始的话，可以省略names[:m]，names[0:],names[:](3)数组长度：len(数组)(4)遍历数组，for循环的简化版for key, value := range names {fmt.Println(key, value)}(5)反转数组：func reverseArray(arr [6]int) [6]int {length := len(arr)for i := 0; i < length/2; i++ {arr[i], arr[length-i-1] = arr[length-i-1], arr[i]}return arr}func main() {arr := [6]int{10, 20, 30, 40, 50, 60}reversed := reverseArray(arr)fmt.Println("反转后的数组:", reversed)}2.二维数组1）// 初始化一个 2 行 3 列的二维数组var arr [2][3]int = [2][3]int{  #本质操作行和列{1, 2, 3},{4, 5, 6},}2）// 使用 ... 自动推断行数arr := [...][3]int{{1, 2, 3},{4, 5, 6},}fmt.Println(arr)3） //遍历二维数组，相加列func main() {// 定义命令行参数arr :=[2][2]int{{1,2},{4,3},}res :=make([]int,len(arr[0]))for k,_ :=range arr[0]{ //列sum :=0for k1,_ :=range arr{ //行fmt.Println(arr[k1][k])sum = sum+arr[k1][k]}res[k] = sum}fmt.Println(res)	}2.切片：和数组相比就是没有设置长度（1）切片的初始化：和数组相比就是没有设置长度s := []int{1, 2, 3, 4, 5} // 创建一个包含5个元素的切片s := make([]int, 5, 10) // 创建类型为[]int，长度为5，最大容量为10的切片（2）切片的长度和容量len(slice),cap(slice)   //容量第一次成倍扩容，后面一个一个扩容（3）子切片slice[startIndex:endIndex] //子切片的内容改变，父切片的内容也会改变（4）切片增加元素s = []int{1, 2, 3, 4,  5}s = append(s, 6, 7, 8) // 向切片中添加元素，返回新的切片（5）元素展开 s1 :=sp[:2]s2 :=sp[3:]s := append(s1,s2...)  //s2...元素展开，在append函数使用fmt.Println(s)（6）复制拷贝切片当需要一个独立副本时，可以使用内置的copy函数来实现num1 :=[]int{1,2,3}num2 :=make([]int,len(num1))copy(目标切片, 源切片)(7)字节切片:[]byte，字符串每个字符取出是字节，占用 1 个字节的内存空间。8）字符串-->转字符切片var str stringrunes :=[]rune(s)字符切片(ascci)-->转字符串，占用 4 个字节的内存空间string(runes)3.指针类型，指向一个内存地址(1)指针的申明var p *int //指针类型，p表示地址*p         //*取值p = &a    //&取地址(2)new函数：分配一个内存p :=new(int)*p =1004.映射（map）类型：关联键和值的数据结构(无序),查找灵活(1)可扩展make初始化s :=make(map[string]int) //map[键类型][值类型]赋值：s["1"]=1--s :=map[string] int{"key":   value,"Bob":   50000,"Charlie": 60000,	}(2)访问值，通过键得到值v :=s[key](3)删除元素delete(映射名字(变量值)，“键”)(4)循环输出for key,value :=range 映射的变量名字{fmt.Println(key,value)}5.结构体类型(struct)(1)语法结构，定义在main之外type 结构体名 struct {字段名1 类型1字段名2 类型2...}type Person struct { //首字母大写，导包使用Name stringAge  intCity string}（2）初始化结构体var p Personp.Name = "Alice"p.Age = 30p.City = "Beijing"--简化初始化s := Person{Name: "Bob",Age: 25, City: "Shanghai"}s := Person{"Bob",25,"Shanghai"}（4）匿名结构体person := struct {Name stringAge  int}{Name: "Charlie",Age:  28,}（5）切片和map在结构体中的初始化p2.A_name=[]string{"aa","bb"}p2.Ck=map[string]int{"name":1}6.Json类型：是一种轻量级的数据交换格式{"name": "Alice","age": 20,"is_married": false,"like": ["red", "blue", "purple"],"phone": null}(1)序列化：json.Marshal，go中的数据转为json格式，序列化。json格式转为go中的数据格式，反序列化	设置标签：结构体的标签对应JSON对象的键，也可以不设置使用默认的type Person struct {Name    string            `json:"name"`Age     int               `json:"age"`Like    []string          `json:"like"`Address map[string]string `json:"address"`}// 序列化jsonData, err := json.Marshal(p1)if err != nil {fmt.Println(err)}（2）反序列化：json.Unmarshal，将JSON格式的字节切片解码为Go语言结构体。// 反序列化var p2 Personerr2 := json.Unmarshal(jsonData, &p2)if err != nil {fmt.Println(err2)}fmt.Println(p2)找各种包：studygolang--->标准库中文版，
八.字符串操作（1）遍历：英文，汉字可能会出现乱码，因为一个汉字可能占多个字节。str := "Hello"for i := 0; i < len(str); i++ {fmt.Printf("%c ", str[i])}fmt.Println()按字符（rune）遍历优点: 能正确处理 UTF-8 编码的多字节字符，避免乱码。str := "Hello, 世界"for _, char := range str {  //range 遍历数据类型，大多都返回key，valuefmt.Printf("%c ", char) }（2）Contains/Index查找字符串1）strings.Contains(“源字符串”, “目标字符串”) bool: 判断字符串 s 是否包含子串 substr。text := "I love programming in Go!"fmt.Println(strings.Contains(text, "Go")) // 输出 true2）strings.Index(“源字符串”, “目标字符串”) int: 返回子串 substr 在 s 中首次出现的索引。text := "hello, world"index := strings.Index(text, "world")fmt.Println(index) // 输出 7（3）Replace替换字符串strings.Replace(“源字符串”, old, new,替换次数) //将 s 中的前 n 个 old 子串替换为 new 子串。（4）Split分割字符串：输出为切片strings.Split(“源字符串”,"分隔符") //以“分隔符”将 s 分割成多个子串。（5）切片-->字符串:Joinstrings.Join(“源字符串切片”, “连接符号”) //将字符串切片 a 中的元素用 sep 连接起来。（6）大小写转换strings.ToLower(“字符串”)  // 将 s 中的所有字母转换为小写。strings.ToUpper(“字符串”)  //将 s 中的所有字母转换为大写。strings.TrimSpace(“字符串”) //去除 s 首尾的空格。九.数据类型转换整型和浮点的转换:var a int8 = 6int16/float64(a) 字符串转换:1)fmt.Sprintf("%d", a):其它类型转字符串,只格式化,不输出var a int = 20var stra string   //转换的类型stra = fmt.Sprintf("%d", a) //格式化输出转换fmt.Printf("stra type is %T, value is %v \n", stra, stra)2)fmt.Sprintf: //不同类型的数据拼接var str string = "aa"var f1 float32 = 12.2var b1 bool = truea := fmt.Sprintf("商品标题:%s 价格:%f 是否在售:%t\n",str,f1,b1)fmt.Printf(a)3)strconv:实现基本数据类型和字符串之间的转换字符串和整型相互转换strconv.Atoi(str) #字符串转整型strconv.Itoa(int) #整型转字符串字符串和浮点形转换	strconv.ParseFloat(str,64) #字符串转浮点strconv,FormatFloat(num,'f',2,64) #浮点转字符串(要转换的浮点型,输出浮点形,保留2位,64位的)字符串和布尔转换strconv.ParseBool(str)  #字符串转布尔strconv.FormatBool(b)   #布尔转字符串4）字符串-->转字符切片var str stringrunes :=[]rune(s)字符切片(ascci)-->转字符串string(runes)5）strings.Join："字符串"切片-->转字符串result := strings.Join(strSlice, ",")练习：
// 创建一个映射，键为学生的姓名（字符串类型），值为一个自定义的 Student 结构体，
// 该结构体包含 Age（整数类型）和 Scores（整数切片类型，存储学生的多门课程成绩）两个字段。
// 实现以下功能：
// - 向映射中添加至少 3 个学生的信息。
// - 计算并输出每个学生的平均成绩。
// - 找出平均成绩最高的学生，并输出其姓名和平均成绩。type Student struct{Age intScores []int
}
func main() {smap :=make(map[string]Student)smap["name1"] =Student{Age:11,Scores: []int{1,3},}smap["name2"] =Student{Age:22,Scores: []int{2,4},}smap["name3"] =Student{Age:33,Scores: []int{4,6},}// avg :=make([]int,0)// fmt.Println(smap)hs :=""hc :=0for k,_ :=range smap{sum :=0for _,v1 :=range smap[k].Scores{sum =sum+v1	}// avg =append(avg,sum/len(smap[k].Scores))fmt.Printf("%s,%d\n",k,sum/len(smap[k].Scores))if hc < sum/len(smap[k].Scores){hc = sum/len(smap[k].Scores)hs = k}}fmt.Println(hs,hc)
}		

一.Go 语言有四大显著特点：
    高效性：编译与运行效率高。
    并发性：原生支持并发编程。
    简洁性：编程风格简洁直接，代码可读性与可维护性高。
    跨平台性：程序能在 Windows、Linux、Mac OS 等多系统运行。

二.go的包:package
    1.main:主函数
    2.fmt:输出          #fmt.Println()
    3.rand:随机数  
        rand.Intn(n) #生成0-n之间的随机数

三.go的工具链组件: import 
    1.go mod init+自定义名称    #初始化项目,生成项目文件
    2.go run + 文件        #编译并执行文件     
    3.go build               #编译,将当前目录中的.go文件编译为可执行文件
         go build -o demo01_app demo01.go
        //-o demo01_app 指定可执行文件的名字
    4.go doc 组件名称            #查看组件的文档
    

四.变量(var):变量申明后必须要使用
    1.声明赋值:var  变量名1,变量名2 数据类型 = a,b
            var name,name2 string =a,b
        (1)声明多个不同类型的变量:
            var (
                name    string
                age     int
                address string
            )
    2.短变量:不需要申明类型,系统自动判断类型
            格式: name := "jack" // 字符串类型的变量。

    3.匿名变量:a, b, _ := 1, 2, 3:表示第三个值不使用
    
    4.交换变量
            num1, num2 := 25, 36
            nam1, num2 = num2, num1

五.常量(const):不允许重新赋值

    1.声明赋值:const name string = "Jack"
        声明多个常量:
        const(
            a int=1
            b string ="aa"
        )

    2.iota:声明无类型的"整数"序数(等差数列)
        const (
            a = iota
            b
            c
        )

六.输出和输入
    格式化输出:fmt.Printf()
        1.%v   #任意类型
        2.%s   #字符型
        3.%d   #整型
        4.%.2f #浮点:保留两位小数
        5.%t   #布尔值
        6.%T   #输出类型
        7.%c     #编码转换,输出对应字符
    获取键盘输入:
        fmt.Scan(&a,&b)，控制台空格间隔,输完参数自动结束,&为固定的绑定变量值的符号
        fmt.Scanln(&a,&b)，控制台空格间隔,输完参数回车结束

七.数据类型
1.基本数据类型
    (1)整型
        有符号整型(分正负) int8/16/32/64,默认由操作系统决定 [-32768, 32767]
        无符号整型(不分正负) uint8/16/32/64     [0, 65535]
    (2)浮点
        float32    32位浮点数
        float64    64位浮点数(短变量默认类型)

    (3)布尔类型
        bool    true为真值，false为假值
        var b1 bool = true

    (4)字符串类型
        1)字符串
        string    字符串,字符串可以用双引号""或反引号``来表示
        str := "Hello, World!"
        multilineStr := `       //可以换行
            This is a
            multiline string.
        `
        2)字符串的拼接:+
            str1 := "Hello, "
            str2 := "World!"
            str = str1+str2
    
        3)字符串长度,单位是字节,英文占一个字节,汉字占三个字节:len
            str := "Hello, World!"
            length := len(str) 
    
        4)字符串索引:[],输出ascii码，的值用string()转回
            str := "Hello世界"
            firstChar := str[0]           
            secondChar := str[5]   #汉字占三个字节,这样只取出一个字节
            fmt.Println(firstChar, secondChar) // 输出 '72' 和 '228'
            // 编码转换
            fmt.Println(string(firstChar), string(secondChar)
    
        5)字符串切片:可以取出汉字的内容,按照字节进行计数
            str[start:end]：从start到end（不包括end）。
            str[:]：获取字符串的完整副本
            str := "Hello世界"
            fmt.Println(str2[5:8]) // "世"

    (5)字符型:可输出中文完整的ascii编码，使用string()可以转换，0到255
        1)byte,使用单引号包括一个字符,相当于uint8
            var a byte = 'a' 
            fmt.Println(a)  // 97,输出ASCII编码值
        
        2)rune,相当于int32，0到65535
            var b rune = '中'
            fmt.Println(b)  // 20013

    (6) \转义字符
        \n   换行符号
        \t   横向制表符号(多空格)
        \b   回退符号
        \f   换页符号

    (7)零值:一个类型的空值或者说默认值更为准确。
        var i int  // 默认为0
        var s8 string  // 默认为""
        var b3 bool  // 默认为false

2.各种引用数据类型
    1.数组
        1.数组初始化
        （1）初始化一个长度为5的整型数组
            var nums [5]int
    
            names = [3]string{"1","2","3"}
    
            for i := 0; i < index; i++ {
                    newArr[i] = arr[i]
                }
        （2）也可以用元素初始化
            nums := [5]int{1, 2, 3}
        （3）自动设置长度
            nums := [...]int{3, 8, 7, 12}
    
        (1)下标访问：names[i]
        (2)切片访问：names[n:m]，不包括m,从0开始的话，可以省略
            names[:m]，names[0:],names[:]
        (3)数组长度：len(数组)
        (4)遍历数组，for循环的简化版
            for key, value := range names {
                fmt.Println(key, value)
            }
        (5)反转数组：
            func reverseArray(arr [6]int) [6]int {
                length := len(arr)
                for i := 0; i < length/2; i++ {
                    arr[i], arr[length-i-1] = arr[length-i-1], arr[i]
                }
                return arr
            }
            
            func main() {
                arr := [6]int{10, 20, 30, 40, 50, 60}
                reversed := reverseArray(arr)
                fmt.Println("反转后的数组:", reversed)
            }
        2.二维数组
            1）// 初始化一个 2 行 3 列的二维数组
                var arr [2][3]int = [2][3]int{  #本质操作行和列
                    {1, 2, 3},
                    {4, 5, 6},
                }
        
            2）// 使用 ... 自动推断行数
                arr := [...][3]int{
                    {1, 2, 3},
                    {4, 5, 6},
                }
                fmt.Println(arr)

            3） //遍历二维数组，相加列
                func main() {
                    // 定义命令行参数
                    arr :=[2][2]int{
                        {1,2},
                        {4,3},
                    }
                    res :=make([]int,len(arr[0]))
                    for k,_ :=range arr[0]{ //列
                        sum :=0
                        for k1,_ :=range arr{ //行
                            fmt.Println(arr[k1][k])
                            sum = sum+arr[k1][k]
                        }
                        res[k] = sum
                    }
                    fmt.Println(res)    
                }

    2.切片：和数组相比就是没有设置长度
        （1）切片的初始化：和数组相比就是没有设置长度
            s := []int{1, 2, 3, 4, 5} // 创建一个包含5个元素的切片
            s := make([]int, 5, 10) // 创建类型为[]int，长度为5，最大容量为10的切片
            
        （2）切片的长度和容量
            len(slice),cap(slice)   //容量第一次成倍扩容，后面一个一个扩容
    
        （3）子切片
            slice[startIndex:endIndex] //子切片的内容改变，父切片的内容也会改变
    
        （4）切片增加元素
            s = []int{1, 2, 3, 4,  5}
            s = append(s, 6, 7, 8) // 向切片中添加元素，返回新的切片
    
        （5）元素展开 
            s1 :=sp[:2]
             s2 :=sp[3:]
             s := append(s1,s2...)  //s2...元素展开，在append函数使用
             fmt.Println(s)
        
        （6）复制拷贝切片
            当需要一个独立副本时，可以使用内置的copy函数来实现
            num1 :=[]int{1,2,3}
            num2 :=make([]int,len(num1))
            copy(目标切片, 源切片)
        
        (7)字节切片:[]byte，字符串每个字符取出是字节，占用 1 个字节的内存空间。
                
        8）字符串-->转字符切片
                    var str string
            runes :=[]rune(s)

          字符切片(ascci)-->转字符串，占用 4 个字节的内存空间
            string(runes)

    3.指针类型，指向一个内存地址
        (1)指针的申明
            var p *int //指针类型，p表示地址
            *p         //*取值
             p = &a    //&取地址
        
        (2)new函数：分配一个内存
            p :=new(int)
            *p =100
    
    
    4.映射（map）类型：关联键和值的数据结构(无序),查找灵活
    
        (1)可扩展make初始化
            s :=make(map[string]int) //map[键类型][值类型]
            赋值：s["1"]=1
         --
            s :=map[string] int{
                "key":   value,
                    "Bob":   50000,
                    "Charlie": 60000,    
                }
        (2)访问值，通过键得到值
            v :=s[key]
        
        (3)删除元素
            delete(映射名字(变量值)，“键”)
    
        (4)循环输出
            for key,value :=range 映射的变量名字{
                fmt.Println(key,value)
            }
            
    5.结构体类型(struct)
        (1)语法结构，定义在main之外
            type 结构体名 struct {
                字段名1 类型1
                字段名2 类型2
                ...
            }
            type Person struct { //首字母大写，导包使用
                Name string
                Age  int
                City string
            }
    
        （2）初始化结构体
            var p Person
            p.Name = "Alice"
            p.Age = 30
            p.City = "Beijing"

           --简化初始化
            s := Person{
                Name: "Bob",
                Age: 25, 
                     City: "Shanghai"
                 }
    
            s := Person{
                "Bob",
                        25,
                        "Shanghai"
             }
        
        （4）匿名结构体
            person := struct {
                Name string
                Age  int
            }{
                Name: "Charlie",
                Age:  28,
            }
        
        （5）切片和map在结构体中的初始化
                p2.A_name=[]string{"aa","bb"}
                p2.Ck=map[string]int{"name":1}
    
    6.Json类型：是一种轻量级的数据交换格式
        {
            "name": "Alice",
            "age": 20,
            "is_married": false,
            "like": ["red", "blue", "purple"],
            "phone": null
        }
        
    
        (1)序列化：json.Marshal，go中的数据转为json格式，序列化。json格式转为go中的数据格式，反序列化    
        设置标签：结构体的标签对应JSON对象的键，也可以不设置使用默认的
            type Person struct {
                Name    string            `json:"name"`
                Age     int               `json:"age"`
                Like    []string          `json:"like"`
                Address map[string]string `json:"address"`
            }
            // 序列化
            jsonData, err := json.Marshal(p1)
            
            if err != nil {
                fmt.Println(err)
            }
    
    
        （2）反序列化：json.Unmarshal，将JSON格式的字节切片解码为Go语言结构体。
            // 反序列化
            var p2 Person
            err2 := json.Unmarshal(jsonData, &p2)
            if err != nil {
                fmt.Println(err2)
            }
            fmt.Println(p2)

找各种包：studygolang--->标准库中文版，
八.字符串操作
    （1）遍历：英文，汉字可能会出现乱码，因为一个汉字可能占多个字节。
        str := "Hello"
        for i := 0; i < len(str); i++ {
            fmt.Printf("%c ", str[i])
        }
        fmt.Println()
        
        按字符（rune）遍历
        优点: 能正确处理 UTF-8 编码的多字节字符，避免乱码。
        str := "Hello, 世界"
        for _, char := range str {  //range 遍历数据类型，大多都返回key，value
            fmt.Printf("%c ", char) 
        }
    
    （2）Contains/Index查找字符串
        1）strings.Contains(“源字符串”, “目标字符串”) bool: 判断字符串 s 是否包含子串 substr。
            text := "I love programming in Go!"
            fmt.Println(strings.Contains(text, "Go")) // 输出 true

        2）strings.Index(“源字符串”, “目标字符串”) int: 返回子串 substr 在 s 中首次出现的索引。
            text := "hello, world"
            index := strings.Index(text, "world")
            fmt.Println(index) // 输出 7

    （3）Replace替换字符串
        strings.Replace(“源字符串”, old, new,替换次数) //将 s 中的前 n 个 old 子串替换为 new 子串。

    （4）Split分割字符串：输出为切片
        strings.Split(“源字符串”,"分隔符") //以“分隔符”将 s 分割成多个子串。

    （5）切片-->字符串:Join
        strings.Join(“源字符串切片”, “连接符号”) //将字符串切片 a 中的元素用 sep 连接起来。

    （6）大小写转换
        strings.ToLower(“字符串”)  // 将 s 中的所有字母转换为小写。
        strings.ToUpper(“字符串”)  //将 s 中的所有字母转换为大写。
        strings.TrimSpace(“字符串”) //去除 s 首尾的空格。

九.数据类型转换
    整型和浮点的转换:
        var a int8 = 6
        int16/float64(a) 
        
    字符串转换:
        1)fmt.Sprintf("%d", a):其它类型转字符串,只格式化,不输出
            var a int = 20
            var stra string   //转换的类型
            stra = fmt.Sprintf("%d", a) //格式化输出转换
            fmt.Printf("stra type is %T, value is %v \n", stra, stra)
        
        2)fmt.Sprintf: //不同类型的数据拼接
            var str string = "aa"
            var f1 float32 = 12.2
            var b1 bool = true
            a := fmt.Sprintf("商品标题:%s 价格:%f 是否在售:%t\n",str,f1,b1)
            fmt.Printf(a)

        3)strconv:实现基本数据类型和字符串之间的转换
            字符串和整型相互转换
                strconv.Atoi(str) #字符串转整型
                strconv.Itoa(int) #整型转字符串
            字符串和浮点形转换    
                strconv.ParseFloat(str,64) #字符串转浮点
                strconv,FormatFloat(num,'f',2,64) #浮点转字符串(要转换的浮点型,输出浮点形,保留2位,64位的)

            字符串和布尔转换
                strconv.ParseBool(str)  #字符串转布尔
                strconv.FormatBool(b)   #布尔转字符串

        4）字符串-->转字符切片
                    var str string
            runes :=[]rune(s)
          字符切片(ascci)-->转字符串
            string(runes)
        
        5）strings.Join："字符串"切片-->转字符串
              result := strings.Join(strSlice, ",")

        
练习：
// 创建一个映射，键为学生的姓名（字符串类型），值为一个自定义的 Student 结构体，
// 该结构体包含 Age（整数类型）和 Scores（整数切片类型，存储学生的多门课程成绩）两个字段。
// 实现以下功能：
// - 向映射中添加至少 3 个学生的信息。
// - 计算并输出每个学生的平均成绩。
// - 找出平均成绩最高的学生，并输出其姓名和平均成绩。

type Student struct{
    Age int
    Scores []int
}
func main() {
    smap :=make(map[string]Student)
    smap["name1"] =Student{
        Age:11,
        Scores: []int{1,3},
    }
    smap["name2"] =Student{
        Age:22,
        Scores: []int{2,4},
    }
    smap["name3"] =Student{
        Age:33,
        Scores: []int{4,6},
    }
    // avg :=make([]int,0)
    // fmt.Println(smap)
    hs :=""
    hc :=0
    for k,_ :=range smap{
        sum :=0
        for _,v1 :=range smap[k].Scores{
            sum =sum+v1    
        }
        // avg =append(avg,sum/len(smap[k].Scores))
        fmt.Printf("%s,%d\n",k,sum/len(smap[k].Scores))
        if hc < sum/len(smap[k].Scores){
            hc = sum/len(smap[k].Scores)
            hs = k
        }
    }
    fmt.Println(hs,hc)
}