1、Go语言基础中的基础

摘要：马士兵教育的Go语言基础的视频笔记。

第一章：走进Golang

1.1、Go的SDK介绍

1.2、Go的项目基本目录结构

1.3、HelloWorld

1.4、编译

1.5、执行

1.6、一步到位

1.7、执行流程分析

1.8、语法注意事项

（1）源文件以"go"为扩展名。
（2）程序的执行入口是main()函数。
（3）严格区分大小写。
（4）方法由一条条语句构成，每个语句后不需要分号(Go语言会在每行后自动加分号)，这也体现出Golang的简洁性。
（5）Go编译器是一行行进行编译的，因此我们一行就写一条语句，不能把多条语句写在同一个，否则报错
（6）定义的变量或者import的包如果没有使用到，代码不能编译通过。
（7）大括号都是成对出现的，缺一不可。

1.9、语法注意事项

1.9、语法注意事项

1.10、语法注意事项

第二章：变量与数据类型

2.1、变量

2.2、代码练习

package main
import "fmt"
func main(){//1.变量的声明var age int//2.变量的赋值age = 18//3.变量的使用fmt.Println("age = ",age);//声明和赋值可以合成一句：var age2 int = 19fmt.Println("age2 = ",age2);// var age int = 20;// fmt.Println("age = ",age);/*变量的重复定义会报错：# command-line-arguments.\main.go:16:6: age redeclared in this blockprevious declaration at .\main.go:6:6*///不可以在赋值的时候给与不匹配的类型var num int = 12.56fmt.Println("num = ",num);
}

2.3、变量的4种声明方式

package main
import "fmt"
//全局变量：定义在函数外的变量
var n7 = 100
var n8 = 9.7
//设计者认为上面的全局变量的写法太麻烦了，可以一次性声明：
var (n9 = 500n10 = "netty"
)
func main(){//定义在{}中的变量叫：局部变量//第一种：变量的使用方式：指定变量的类型，并且赋值，var num int = 18fmt.Println(num)//第二种：指定变量的类型，但是不赋值，使用默认值 var num2 intfmt.Println(num2)//第三种：如果没有写变量的类型，那么根据=后面的值进行判定变量的类型 （自动类型推断）var num3 = "tom"fmt.Println(num3)//第四种：省略var，注意 := 不能写为 =   sex := "男"fmt.Println(sex)fmt.Println("------------------------------------------------------------------")//声明多个变量：var n1,n2,n3 intfmt.Println(n1)fmt.Println(n2)fmt.Println(n3)var n4,name,n5 = 10,"jack",7.8fmt.Println(n4)fmt.Println(name)fmt.Println(n5)n6,height := 6.9,100.6fmt.Println(n6)fmt.Println(height)fmt.Println(n7)fmt.Println(n8)fmt.Println(n9)fmt.Println(n10)
}

2.3、数据类型介绍

2.3.1、进制介绍

【1】进制的介绍：
十进制整数，如：99, -500, 0
八进制整数，要求以 0 开头，如：015
十六进制数，要求 0x 或 0X 开头，如：0x15
二进制：要求0b或者0B开头，如：0b11

2.3.2、数据类型

package main
import "fmt"
func main(){//定义浮点类型的数据：var num1 float32 = 3.14fmt.Println(num1)//可以表示正浮点数，也可以表示负的浮点数var num2 float32 = -3.14fmt.Println(num2)//浮点数可以用十进制表示形式，也可以用科学计数法表示形式  E 大写小写都可以的var num3 float32 = 314E-2 fmt.Println(num3)var num4 float32 = 314E+2fmt.Println(num4)var num5 float32 = 314e+2fmt.Println(num5)var num6 float64 = 314e+2fmt.Println(num6)//浮点数可能会有精度的损失，所以通常情况下，建议你使用：float64 var num7 float32 = 256.000000916fmt.Println(num7)var num8 float64 = 256.000000916fmt.Println(num8)//golang中默认的浮点类型为：float64 var num9 = 3.17fmt.Printf("num9对应的默认的类型为：%T",num9)
}

【4】查看UTF-8编码表：
http://www.mytju.com/classcode/tools/encode_utf8.asp

package main
import "fmt"
func main(){//定义字符类型的数据：var c1 byte = 'a'fmt.Println(c1)//97var c2 byte = '6'fmt.Println(c2)//54var c3 byte = '('fmt.Println(c3 + 20)//40//字符类型，本质上就是一个整数，也可以直接参与运算，输出字符的时候，会将对应的码值做一个输出//字母，数字，标点等字符，底层是按照ASCII进行存储。var c4 int = '中'fmt.Println(c4)//汉字字符，底层对应的是Unicode码值//对应的码值为20013，byte类型溢出，能存储的范围：可以用int//总结：Golang的字符对应的使用的是UTF-8编码（Unicode是对应的字符集，UTF-8是Unicode的其中的一种编码方案）var c5 byte = 'A'//想显示对应的字符，必须采用格式化输出fmt.Printf("c5对应的具体的字符为：%c",c5)
}

package main
import "fmt"
func main(){//练习转义字符：//\n  换行fmt.Println("aaa\nbbb")//\b 退格fmt.Println("aaa\bbbb")//\r 光标回到本行的开头，后续输入就会替换原有的字符fmt.Println("aaaaa\rbbb")//\t 制表符fmt.Println("aaaaaaaaaaaaa")fmt.Println("aaaaa\tbbbbb")fmt.Println("aaaaaaaa\tbbbbb")//\"fmt.Println("\"Golang\"")
}

package main
import "fmt"
func main(){//测试布尔类型的数值：var flag01 bool = truefmt.Println(flag01)var flag02 bool = falsefmt.Println(flag02)var flag03 bool = 5 < 9fmt.Println(flag03)
}

package main
import "fmt"
func main(){//1.定义一个字符串：var s1 string = "你好全面拥抱Golang"fmt.Println(s1)//2.字符串是不可变的：指的是字符串一旦定义好，其中的字符的值不能改变var s2 string = "abc"//s2 = "def"//s2[0] = 't'fmt.Println(s2)//3.字符串的表示形式：//（1）如果字符串中没有特殊字符，字符串的表示形式用双引号//var s3 string = "asdfasdfasdf"//（2）如果字符串中有特殊字符，字符串的表示形式用反引号 ``var s4 string = `package mainimport "fmt"func main(){//测试布尔类型的数值：var flag01 bool = truefmt.Println(flag01)var flag02 bool = falsefmt.Println(flag02)var flag03 bool = 5 < 9fmt.Println(flag03)}`fmt.Println(s4)//4.字符串的拼接效果：var s5 string = "abc" + "def"s5 += "hijk"fmt.Println(s5)//当一个字符串过长的时候：注意：+保留在上一行的最后var s6 string = "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" +"def"+ "abc" + "def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+"abc" + "def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+ "abc" +"def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+ "abc" + "def"fmt.Println(s6)
}

package main
import "fmt"
func main(){//进行类型转换：var n1 int = 100//var n2 float32 = n1  在这里自动转换不好使，比如显式转换fmt.Println(n1)//fmt.Println(n2)var n2 float32 = float32(n1)fmt.Println(n2)//注意：n1的类型其实还是int类型，只是将n1的值100转为了float32而已，n1还是int的类型fmt.Printf("%T",n1)  //intfmt.Println()//将int64转为int8的时候，编译不会出错的，但是会数据的溢出var n3 int64 = 888888var n4 int8 = int8(n3)fmt.Println(n4)//56var n5 int32 = 12var n6 int64 = int64(n5) + 30  //一定要匹配=左右的数据类型fmt.Println(n5)fmt.Println(n6)var n7 int64 = 12var n8 int8 = int8(n7) + 127  //编译通过，但是结果可能会溢出//var n9 int8 = int8(n7) + 128 //编译不会通过fmt.Println(n8)//fmt.Println(n9)
}

package main
import "fmt"
func main(){var n1 int = 19var n2 float32 = 4.78var n3 bool = falsevar n4 byte = 'a'var s1 string = fmt.Sprintf("%d",n1)fmt.Printf("s1对应的类型是：%T ，s1 = %q \n",s1, s1)var s2 string = fmt.Sprintf("%f",n2)fmt.Printf("s2对应的类型是：%T ，s2 = %q \n",s2, s2)var s3 string = fmt.Sprintf("%t",n3)fmt.Printf("s3对应的类型是：%T ，s3 = %q \n",s3, s3)var s4 string = fmt.Sprintf("%c",n4)fmt.Printf("s4对应的类型是：%T ，s4 = %q \n",s4, s4)
}

package main
import("fmt""strconv"
)
func main(){var n1 int = 18var s1 string = strconv.FormatInt(int64(n1),10)  //参数：第一个参数必须转为int64类型 ，第二个参数指定字面值的进制形式为十进制fmt.Printf("s1对应的类型是：%T ，s1 = %q \n",s1, s1)var n2 float64 = 4.29var s2 string = strconv.FormatFloat(n2,'f',9,64)//第二个参数：'f'（-ddd.dddd）  第三个参数：9 保留小数点后面9位  第四个参数：表示这个小数是float64类型fmt.Printf("s2对应的类型是：%T ，s2 = %q \n",s2, s2)var n3 bool = truevar s3 string = strconv.FormatBool(n3)fmt.Printf("s3对应的类型是：%T ，s3 = %q \n",s3, s3)
}

package main
import("fmt""strconv"
)
func main(){//string-->boolvar s1 string = "true"var b bool//ParseBool这个函数的返回值有两个：(value bool, err error)//value就是我们得到的布尔类型的数据，err出现的错误//我们只关注得到的布尔类型的数据，err可以用_直接忽略b , _ = strconv.ParseBool(s1)fmt.Printf("b的类型是：%T,b=%v \n",b,b)//string---》int64var s2 string = "19"var num1 int64num1,_ = strconv.ParseInt(s2,10,64)fmt.Printf("num1的类型是：%T,num1=%v \n",num1,num1)//string-->float32/float64var s3 string = "3.14"var f1 float64f1,_ = strconv.ParseFloat(s3,64)fmt.Printf("f1的类型是：%T,f1=%v \n",f1,f1)//注意：string向基本数据类型转换的时候，一定要确保string类型能够转成有效的数据类型，否则最后得到的结果就是按照对应类型的默认值输出var s4 string = "golang"var b1 boolb1 , _ = strconv.ParseBool(s4)fmt.Printf("b1的类型是：%T,b1=%v \n",b1,b1)var s5 string = "golang"var num2 int64num2,_ = strconv.ParseInt(s5,10,64)fmt.Printf("num2的类型是：%T,num2=%v \n",num2,num2)
}

package main
import("fmt"
)
func main(){var age int = 18//&符号+变量 就可以获取这个变量内存的地址fmt.Println(&age) //0xc0000a2058//定义一个指针变量：//var代表要声明一个变量//ptr 指针变量的名字//ptr对应的类型是：*int 是一个指针类型 （可以理解为 指向int类型的指针）//&age就是一个地址，是ptr变量的具体的值var ptr *int = &agefmt.Println(ptr)fmt.Println("ptr本身这个存储空间的地址为：",&ptr)//想获取ptr这个指针或者这个地址指向的那个数据：fmt.Printf("ptr指向的数值为：%v",*ptr) //ptr指向的数值为：18
}

2.4、标识符的使用

（关于模块的导入，这里的方式比较老了，去学习go module即可）

2.4、关键字

第三章：运算符

3.1、算术运算符

package main
import "fmt"
func main(){//+加号：//1.正数 2.相加操作  3.字符串拼接var n1 int = +10fmt.Println(n1)var n2 int = 4 + 7fmt.Println(n2)var s1 string = "abc" + "def"fmt.Println(s1)// /除号：fmt.Println(10/3) //两个int类型数据运算，结果一定为整数类型fmt.Println(10.0/3)//浮点类型参与运算，结果为浮点类型// % 取模  等价公式： a%b=a-a/b*bfmt.Println(10%3) // 10%3= 10-10/3*3 = 1fmt.Println(-10%3)fmt.Println(10%-3)fmt.Println(-10%-3)//++自增操作：var a int = 10a++fmt.Println(a)a--fmt.Println(a)//++ 自增 加1操作，--自减，减1操作//go语言里，++，--操作非常简单，只能单独使用，不能参与到运算中去//go语言里，++，--只能在变量的后面，不能写在变量的前面 --a  ++a  错误写法
}

3.2、赋值运算符

3.3、关系运算符

3.4、逻辑运算符

package main
import "fmt"
func main(){//与逻辑：&& :两个数值/表达式只要有一侧是false，结果一定为false//也叫短路与：只要第一个数值/表达式的结果是false，那么后面的表达式等就不用运算了，// 直接结果就是false  -->提高运算效率fmt.Println(true&&true)fmt.Println(true&&false)fmt.Println(false&&true)fmt.Println(false&&false)//或逻辑：||:两个数值/表达式只要有一侧是true，结果一定为true//也叫短路或：只要第一个数值/表达式的结果是true，那么后面的表达式等就不用运算了,,//直接结果就是true -->提高运算效率fmt.Println(true||true)fmt.Println(true||false)fmt.Println(false||true)fmt.Println(false||false)//非逻辑：取相反的结果：fmt.Println(!true)fmt.Println(!false)
}

3.5、其他运算符

3.6、位运算符的优先级别

3.7、获取用户的终端输入

package main
import "fmt"
func main(){//实现功能：键盘录入学生的年龄，姓名，成绩，是否是VIP//方式1：Scanlnvar age int// fmt.Println("请录入学生的年龄：")//传入age的地址的目的：在Scanln函数中，对地址中的值进行改变的时候，实际外面的age被影响了//fmt.Scanln(&age)//录入数据的时候，类型一定要匹配，因为底层会自动判定类型的var name string// fmt.Println("请录入学生的姓名：")// fmt.Scanln(&name)var score float32// fmt.Println("请录入学生的成绩：")// fmt.Scanln(&score)var isVIP bool// fmt.Println("请录入学生是否为VIP：")// fmt.Scanln(&isVIP)//将上述数据在控制台打印输出：//fmt.Printf("学生的年龄为：%v,姓名为：%v,成绩为：%v,是否为VIP:%v",age,name,score,isVIP)//方式2：Scanffmt.Println("请录入学生的年龄，姓名，成绩，是否是VIP，使用空格进行分隔")fmt.Scanf("%d %s %f %t",&age,&name,&score,&isVIP)//将上述数据在控制台打印输出：fmt.Printf("学生的年龄为：%v,姓名为：%v,成绩为：%v,是否为VIP:%v",age,name,score,isVIP)
}

第四章：流程控制

4.1、分支结构

package main
import "fmt"
func main(){//实现功能：如果口罩的库存小于30个，提示：库存不足：//var count int = 100//单分支：// if count < 30 {// 	fmt.Println("对不起，口罩存量不足")// }//if后面表达式，返回结果一定是true或者false，//如果返回结果为true的话，那么{}中的代码就会执行//如果返回结果为false的话，那么{}中的代码就不会执行//if后面一定要有空格，和条件表达式分隔开来//{}一定不能省略//条件表达式左右的()是建议省略的//在golang里，if后面可以并列的加入变量的定义：if count := 20;count < 30 {fmt.Println("对不起，口罩存量不足")}
}

package main
import "fmt"
func main(){//实现功能：如果口罩的库存小于30个，提示：库存不足,否则提示：库存充足//定义口罩的数量：var count int = 70if count < 30 { //这个条件表达式返回的是true的话，后面{}执行了fmt.Println("库存不足")} else {//count >= 30fmt.Println("库存充足")}//双分支一定会二选一走其中一个分支。}

package main
import "fmt"
func main(){//实现功能：根据给出的学生分数，判断学生的等级：// >=90  -----A// >=80  -----B// >=70  -----C// >=60  -----D// <60   -----E//方式1：利用if单分支实现：//定义一个学生的成绩：var score int = 18//对学生的成绩进行判定：// if score >= 90 {// 	fmt.Println("您的成绩为A级别")// }// if score >= 80 && score < 90 {// 	fmt.Println("您的成绩为B级别")// }// if score >= 70 && score < 80 {// 	fmt.Println("您的成绩为C级别")// }// if score >= 60 && score < 70 {// 	fmt.Println("您的成绩为D级别")// }// if score < 60 {// 	fmt.Println("您的成绩为E级别")// }//上面方式1利用多个单分支拼凑出多个选择，多个选择是并列的，依次从上而下顺序执行，即使走了第一个分支，那么其它分支也是需要判断//方式2：多分支：优点：如果已经走了一个分支了，那么下面的分支就不会再去判断执行了// if score >= 90 {// 	fmt.Println("您的成绩为A级别")// } else if score >= 80 {//else隐藏：score < 90// 	fmt.Println("您的成绩为B级别")// } else if score >= 70 {//score < 80// 	fmt.Println("您的成绩为C级别")// } else if score >= 60 {//score < 70// 	fmt.Println("您的成绩为D级别")// } else {//score < 60// 	fmt.Println("您的成绩为E级别")// } //建议你保证else的存在，只有有了else才会真正 起到多选一 的效果if score > 10 {fmt.Println("aaa")} else if score > 6{fmt.Println("bbb")}
}

4.2、switch

package main
import "fmt"
func main(){//实现功能：根据给出的学生分数，判断学生的等级：// >=90  -----A// >=80  -----B// >=70  -----C// >=60  -----D// <60   -----E//给出一个学生分数：var score int = 187//根据分数判断等级：//switch后面是一个表达式，这个表达式的结果依次跟case进行比较，满足结果的话就执行冒号后面的代码。//default是用来“兜底”的一个分支，其它case分支都不走的情况下就会走default分支//default分支可以放在任意位置上，不一定非要放在最后。switch score/10 {case 10 :fmt.Println("您的等级为A级")case 9 :fmt.Println("您的等级为A级")case 8 :fmt.Println("您的等级为B级")case 7 :fmt.Println("您的等级为C级")case 6 :fmt.Println("您的等级为D级")case 5 :fmt.Println("您的等级为E级")case 4 :fmt.Println("您的等级为E级")case 3 :fmt.Println("您的等级为E级")case 2 :fmt.Println("您的等级为E级")case 1 :fmt.Println("您的等级为E级")case 0 :fmt.Println("您的等级为E级")default:fmt.Println("您的成绩有误")}}

4.3、循环结构

package main
import "fmt"
func main(){//实现一个功能：求和： 1+2+3+4+5：//求和：//利用for循环来解决问题：var sum int = 0for i := 1 ; i <= 5 ; i++ {sum += i}//输出结果：fmt.Println(sum)// for循环的语法格式：// for 初始表达式; 布尔表达式（条件判断）; 迭代因子 {// 	循环体;--》反复重复执行的内容// }// 注意：for的初始表达式 不能用var定义变量的形式，要用:=// 注意：for循环实际就是让程序员写代码的效率高了，// 但是底层该怎么执行还是怎么执行的，底层效率没有提高，只是程序员写代码简洁了而已
}

package main
import "fmt"
func main(){//定义一个字符串：var str string = "hello golang你好"//方式1：普通for循环：按照字节进行遍历输出的 （暂时先不使用中文）// for i := 0;i < len(str);i++ {//i:理解为字符串的下标// 	fmt.Printf("%c \n",str[i])// }//方式2：for rangefor i , value := range str {fmt.Printf("索引为：%d,具体的值为：%c \n",i,value)}//对str进行遍历，遍历的每个结果的索引值被i接收，每个结果的具体数值被value接收//遍历对字符进行遍历的
}

4.3、循环结构的关键字

第五章：函数

5.1、函数的引入

package main
import "fmt"
// func   函数名（形参列表)（返回值类型列表）{
// 	执行语句..
// 	return + 返回值列表
// }
//自定义函数：功能：两个数相加：
func cal (num1 int,num2 int) (int) { //如果返回值类型就一个的话，那么()是可以省略不写的var sum int = 0sum += num1sum += num2return sum
}
func main(){//功能：10 + 20//调用函数：sum := cal(10,20)fmt.Println(sum)// var num1 int = 10// var num2 int = 20//求和：// var sum int = 0// sum += num1// sum += num2// fmt.Println(sum)//功能：30 + 50var num3 int = 30var num4 int = 50//调用函数：sum1 := cal(num3,num4)fmt.Println(sum1)//求和：// var sum1 int = 0// sum1 += num3// sum1 += num4// fmt.Println(sum1)
}

package main
import "fmt"
//定义一个函数：
func test(num int){fmt.Println(num)
}
func main(){//函数也是一种数据类型，可以赋值给一个变量	a := test//变量就是一个函数类型的变量fmt.Printf("a的类型是：%T,test函数的类型是：%T \n",a,test)//a的类型是：func(int),test函数的类型是：func(int)//通过该变量可以对函数调用a(10) //等价于  test(10)
}

package main
import "fmt"
//定义一个函数：
func test(num int){fmt.Println(num)
}
//定义一个函数，把另一个函数作为形参：
func test02 (num1 int ,num2 float32, testFunc func(int)){fmt.Println("-----test02")
}
func main(){//函数也是一种数据类型，可以赋值给一个变量	a := test//变量就是一个函数类型的变量fmt.Printf("a的类型是：%T,test函数的类型是：%T \n",a,test)//a的类型是：func(int),test函数的类型是：func(int)//通过该变量可以对函数调用a(10) //等价于  test(10)//调用test02函数：test02(10,3.19,test)test02(10,3.19,a)
}

5.2、包的引入

5.4、init函数

5.5、匿名函数

package main
import "fmt"
var Func01 = func (num1 int,num2 int) int{return num1 * num2
}
func main(){//定义匿名函数：定义的同时调用result := func (num1 int,num2 int) int{return num1 + num2}(10,20)fmt.Println(result)//将匿名函数赋给一个变量，这个变量实际就是函数类型的变量//sub等价于匿名函数sub := func (num1 int,num2 int) int{return num1 - num2}//直接调用sub就是调用这个匿名函数了result01 := sub(30,70)fmt.Println(result01)result02 := sub(30,70)fmt.Println(result02)result03 := Func01(3,4)fmt.Println(result03)
}

5.6、闭包

package main
import "fmt"
//函数功能：求和
//函数的名字：getSum 参数为空
//getSum函数返回值为一个函数，这个函数的参数是一个int类型的参数，返回值也是int类型
func getSum() func (int) int {var sum int = 0return func (num int) int{sum = sum + num return sum}
}
//闭包：返回的匿名函数+匿名函数以外的变量num
func main(){f := getSum()fmt.Println(f(1))//1 fmt.Println(f(2))//3fmt.Println(f(3))//6fmt.Println(f(4))//10fmt.Println("----------------------")fmt.Println(getSum01(0,1))//1fmt.Println(getSum01(1,2))//3fmt.Println(getSum01(3,3))//6fmt.Println(getSum01(6,4))//10
}
func getSum01(sum int,num int) int{sum = sum + numreturn sum
}
//不使用闭包的时候：我想保留的值，不可以反复使用
//闭包应用场景：闭包可以保留上次引用的某个值，我们传入一次就可以反复使用了

5.7、defer关键字

5.8、系统函数

5.5 系统函数之日期和时间相关函数

5.6、系统函数只内置函数

第六章：错误处理

6.1、defer+recover机制处理错误

6.2、自定义错误

第七章：数组

7.1、数组的引入

7.2、内存分析

7.3、数组的遍历

7.4、数组的初始化方式

7.5、注意事项

7.6、二维数组

7.7、二维数组的遍历

package main
import "fmt"
func main(){//定义二维数组：var arr [3][3]int = [3][3]int{{1,4,7},{2,5,8},{3,6,9}}fmt.Println(arr)fmt.Println("------------------------")//方式1：普通for循环：for i := 0;i < len(arr);i++{for j := 0;j < len(arr[i]);j++ {fmt.Print(arr[i][j],"\t")}fmt.Println()}fmt.Println("------------------------")//方式2：for range循环：for key,value := range arr {for k,v := range value {fmt.Printf("arr[%v][%v]=%v\t",key,k,v)}fmt.Println()}
}

第八章：切片

8.1、切片的引入

8.2、内存分析

8.3、切片的定义

8.4、切片的遍历

8.5、切片的注意事项

第九章：映射

9.1、map的引入

9.2、map的3种创建方式

package main
import "fmt"
func main(){//方式1：//定义map变量：var a map[int]string//只声明map内存是没有分配空间//必须通过make函数进行初始化，才会分配空间：a = make(map[int]string,10) //map可以存放10个键值对//将键值对存入map中：a[20095452] = "张三"a[20095387] = "李四"//输出集合fmt.Println(a)//-------------------------------------------------------//方式2：b := make(map[int]string)b[20095452] = "张三"b[20095387] = "李四"fmt.Println(b)//-------------------------------------------------------//方式3：c := map[int]string{20095452 : "张三",20098765 : "李四",}c[20095387] = "王五"fmt.Println(c)
}

9.3、map的操作

package main
import "fmt"
func main(){//定义mapb := make(map[int]string)//增加：b[20095452] = "张三"b[20095387] = "李四"b[20098833] = "王五"//获取长度：fmt.Println(len(b))//遍历：for k,v := range b {fmt.Printf("key为：%v value为%v \t",k,v)}fmt.Println("---------------------------")//加深难度：a := make(map[string]map[int]string)//赋值：a["班级1"] = make(map[int]string,3)a["班级1"][20096677] = "露露"a["班级1"][20098833] = "丽丽"a["班级1"][20097722] = "菲菲"a["班级2"] = make(map[int]string,3)a["班级2"][20089911] = "小明"a["班级2"][20085533] = "小龙"a["班级2"][20087244] = "小飞"for k1,v1:= range a {fmt.Println(k1)for k2,v2:= range v1{fmt.Printf("学生学号为：%v 学生姓名为%v \t",k2,v2)}fmt.Println()}
}

第十章：面向对象

10.1、面向对象的引入

10.2、结构体

10.3、内存分析

10.4、结构体实例的创建方式

10.5、结构体之间的转换

10.6、结构体方法

第十一章：