Golang基础教程

Golang基础学习

 以下使用goland的IDE演示，包含总计的golang基础功能共20个章节一、go语言结构:二、go基础语法:三、变量:四、常量:五、运算符:六、条件语句:七、循环:八、函数:九、变量作用域:十、数组:十一、指针:十二、结构体:十三、切片:十四、范围(Range):十五、集合:十六、递归:十七、数据类型转换:十八、接口:十九、错误处理:二十、并发: 一、go语言结构：1.运行Hello World！

1. package main
3. import "fmt"
5. func main() {
6. fmt.Println("Hello World！")
7. }

复制代码

查看运行结果：<img> 2.语言结构：1. 第一行代码 package main 定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。2. 下一行 import "fmt" 告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了格式化 IO（输入/输出）的函数。3. 下一行 func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。4. 下一行 /*...*/ 是注释，在程序执行时将被忽略。单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释。多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾，且不可以嵌套使用，多行注释一般用于包的文档描述或注释成块的代码片段。5.下一行 fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。使用 fmt.Print("hello, world\n") 可以得到相同的结果。Print 和 Println 这两个函数也支持使用变量，如：fmt.Println(arr)。如果没有特别指定，它们会以默认的打印格式将变量 arr 输出到控制台。6. 当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。 二、go基础语法：1.行分隔符:Println函数会在行末尾自动加上换行符

1. package main
3. import "fmt"
5. func main() {
6. fmt.Println("Hello World!")
7. fmt.Println("Println函数会在行末尾自动加上换行符")
8. }

复制代码

查看运行结果：<img> 2.注释：单行注释以//开头，多行注释以 /* 开头，并以 */ 结尾// 单行注释/*我说多行注释1我说多行注释2我说多行注释3*/ 3.标识符：标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母(A~Z和a~z)数字(0~9)、下划线_组成的序列，但是第一个字符必须是字母或下划线而不能是数字。以下是有效的标识符：mahesh   kumar   abc   move_name   a_123myname50   _temp   j   a23b9   retVal以下是无效的标识符：* 1ab（以数字开头）* case（Go 语言的关键字）* a+b（运算符是不允许的） 4.字符串连接：Go 语言的字符串连接可以通过 + 实现：

1. import "fmt"
3. func main() {
4. fmt.Println("golang"+"python")
5. }

复制代码

查看运行结果：<img> 5.关键字：下面列举了 Go 代码中会使用到的 25 个关键字或保留字：break default func interface selectcase defer go map struct chan else goto package switchconst fallthrough if range typecontinue for import return var 6.格式化字符串：// 常用的使用%d 表示整型数字，%s 表示字符串

1. package main
3. import "fmt"
5. func main() {
6. //fmt.Println("Hello World!")
7. //fmt.Println("Println函数会在行末尾自动加上换行符")
8. //fmt.Println("golang" + "python")
9. var today = "星期六"
10. var number = 6
11. fmt.Printf("今天是%s，今天在本周的排号为%d", today, number)
12. }

复制代码

查看运行结果:<img> 三、变量1、申明一个变量值，变量类型，并初始化（1）两种方式，方式1：使用var声明

1. package main
3. func main() {
4. var str string = "hello"
5. var num int = 123
6. println(str, num)
7. }

复制代码

查看运行结果:<img>（2）使用:=声明

1. package main
3. func main() {
4. //var str string = "hello"
5. //var num int = 123
6. //println(str, num)
7. mystr := "very good"
8. mynum := 345
9. println(mystr, mynum)
11. }

复制代码

查看运行结果：<img> 2、申请变量未初始化，则会给默认值数值类型初始值0布尔类型为fasle字符串为""其他类型为nil

1. func main() {
2. //var str string = "hello"
3. //var num int = 123
4. //println(str, num)
6. //初始值0
7. var num1 int
8. fmt.Println("num1初始值为：", num1)
9. //初始值""
10. var str1 string
11. fmt.Println("str1初始值为：", str1)
12. //布尔类型为 false
13. var flag bool
14. fmt.Println("flag初始值为：", flag)
15. //其他类型为nil
16. var a *int
17. var b []int
18. var c map[string]int
19. var d chan int
20. var e func(string) int
21. var f error
22. fmt.Println("a,b,c,d,e,f的初始值分别为：", a, b, c, d, e, f)
23. }

复制代码

查看运行结果:<img> 3、根据值自行判定变量类型

1. package main
3. import (
4. "fmt"
5. "reflect"
6. )
8. func main() {
10. var str2 = "hello"
11. var num2 = 25
12. var flag2 = true
13. fmt.Println("str2的类型为:", reflect.TypeOf(str2))
14. fmt.Println("num2的类型为:", reflect.TypeOf(num2))
15. fmt.Println("flag2的类型为:", reflect.TypeOf(flag2))
16. }

复制代码

查看运行结果：<img> 4、多变量声明：使用逗号隔开

1. package main
3. import "fmt"
5. func main() {
8. var str3, str4, str5 string = "hello", "World", "ok"
9. num3, num4, num5 := 2, 3, 4
10. fmt.Println(str3, str4, str5)
11. fmt.Println(num3, num4, num5)
13. }

复制代码

查看运行结果：<img> 5、引用类型变量&可查看引用变量的地址

12345678910111213

package main  import "fmt"  func main() {  var a1 = 10var b1 = "ok"fmt.Println("a1=", a1)fmt.Println("b1=", b1)fmt.Println("a1=", &a1)fmt.Println("b1=", &b1)}

查看运行结果：<img> 四、常量1.常量定义：常量是一个简单值的标识符，在程序运行时，不会被修改的量，使用const修饰一个常量

1. package main
3. func main() {
4. const a string = "abc" //显示类型定义
5. const b = "abc" //隐示类型定义
6. const c, d = "o", "k"
7. println(a, b, c, d)
8. }

复制代码

查看运行结果：<img> 2. 常量还可以用作枚举：并且常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过

1. package main
3. import "unsafe"
5. func main() {
6. //const a string = "abc" //显示类型定义
7. //const b = "abc" //隐示类型定义
8. //const c, d = "o", "k"
9. //println(a, b, c, d)
10. const (
11. Unknown = 0
12. Female = 1
13. Male = 2
14. )
16. const (
17. a = "abc"
18. b = len(a)
19. c = unsafe.Sizeof(a) //16个字节，返回string结构体的字符与长度各8个字符相加
20. )
21. println(Unknown, Female, Male, a, b, c)
22. }

复制代码

查看运行结果：<img> 3.特殊常量iotaiota，特殊常量，可以认为是一个可以被编译器修改的常量。iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

1. package main
3. func main() {
5. const (
6. a = iota
7. b
8. c
9. )
10. println(a, b, c)
11. }

复制代码

查看运行结果：<img>

1. package main
3. import "fmt"
5. func main() {
7. //println(a, b, c)
8. const (
9. a = iota //0
10. b //1
11. c //2
12. d = "ha" //独立值，iota += 1
13. e //"ha" iota += 1
14. f = 100 //iota +=1
15. g //100 iota +=1
16. h = iota //7,恢复计数
17. i //8
18. )
19. fmt.Println(a, b, c, d, e, f, g, h, i)
20. }

复制代码

查看运行结果：<img> 五、运算符1.算数运算符:

1. package main
3. import "fmt"
5. func main() {
6. a := 1
7. b := 2
8. fmt.Println("a加b等于:", a+b)
9. fmt.Println("a减b等于:", a-b)
10. fmt.Println("a剩b等于:", a*b)
11. fmt.Println("a除b等于:", a/b)
12. fmt.Println("a除b后取余数等于:", a%b)
13. a++
14. fmt.Println("a++后的结果:", a)
15. b--
16. fmt.Println("b--后的结果:", b)
17. }

复制代码

查看运行结果:<img> 2.关系运算符关系运算符主要有 =,!=,>,=, n {fmt.Println("第三行返回:a大于b")} else {fmt.Println("第三行返回:a不大于b")}m, n = n, m //交换m,n的值if m = n {fmt.Println("第四行返回:a不小于b")}}[/code]查看运行结果:<img> 3.逻辑运算符主要有三种逻辑运算符:&&:逻辑 AND 运算符。 如果两边的操作数都是 True，则条件 True，否则为 False。||:逻辑 OR 运算符。 如果两边的操作数有一个 True，则条件 True，否则为 False。!:逻辑 NOT 运算符。 如果条件为 True，则逻辑 NOT 条件 False，否则为 True。

1. package main
3. import "fmt"
5. func main() {
7. var m int = 21
8. var n int = 10
9. if m == n {
10. fmt.Println("第一行返回:a等于b")
11. } else {
12. fmt.Println("第一行返回:a不等于b")
13. }
14. if m < n {
15. fmt.Println("第二行返回:a小于b")
16. } else {
17. fmt.Println("第二行返回:a不小于b")
18. }
19. if m > n {
20. fmt.Println("第三行返回:a大于b")
21. } else {
22. fmt.Println("第三行返回:a不大于b")
23. }
24. m, n = n, m //交换m,n的值
25. if m <= n {
26. fmt.Println("第四行返回:a小于等于b")
27. }
28. if m >= n {
29. fmt.Println("第四行返回:a不小于b")
30. }
31. }

复制代码

查看运行结果：<img> 4.位运算符位运算符对整数在内存中的二进制位进行操作。 &, |,  ^ ，四种位运算方式

1. package main
3. import "fmt"
5. func main() {
7. var a bool = true
8. var b bool = false
9. if a && b {
10. fmt.Printf("第一行 - 条件为 true\n")
11. } else if a || b {
12. fmt.Printf("第一行 - 条件为 true\n")
13. }
14. a, b = b, a //修改a，b的值，对调
15. if a && b {
16. fmt.Printf("第二行 - 条件为 true\n")
17. } else {
18. fmt.Printf("第二行 - 条件为 false\n")
19. }
20. if !(a && b) {
21. fmt.Printf("第三行 - 条件为 true\n")
22. } else {
23. fmt.Printf("第三行 - 条件为 false\n")
24. }
26. }

复制代码

查看运行结果:<img> 5.赋值运算符赋值符号为=,将一个表达式的值赋给一个左值，结合之前其他的型号的赋值运算符如下：

1. package main
3. import "fmt"
5. func main() {
7. var a uint = 60 /* 60 = 0011 1100 */
8. var b uint = 13 /* 13 = 0000 1101 */
9. var c uint = 0
11. c = a & b /* 12 = 0000 1100 */
12. fmt.Printf("第一行 - c 的值为 %d\n", c)
14. c = a | b /* 61 = 0011 1101 */
15. fmt.Printf("第二行 - c 的值为 %d\n", c)
17. c = a ^ b /* 49 = 0011 0001 */
18. fmt.Printf("第三行 - c 的值为 %d\n", c)
20. c = a << 2 /* 240 = 1111 0000 */
21. fmt.Printf("第四行 - c 的值为 %d\n", c)
23. c = a >> 2 /* 15 = 0000 1111 */
24. fmt.Printf("第五行 - c 的值为 %d\n", c)
26. }

复制代码

查看运行结果：<img> 六、条件语句1.if else语句：

1. package main
3. import "fmt"
5. func main() {
7. var a int = 21
8. var c int
10. c = a
11. fmt.Printf("第 1 行 - = 运算符实例，c 值为 = %d\n", c)
13. c += a
14. fmt.Printf("第 2 行 - += 运算符实例，c 值为 = %d\n", c)
16. c -= a
17. fmt.Printf("第 3 行 - -= 运算符实例，c 值为 = %d\n", c)
19. c *= a
20. fmt.Printf("第 4 行 - *= 运算符实例，c 值为 = %d\n", c)
22. c /= a
23. fmt.Printf("第 5 行 - /= 运算符实例，c 值为 = %d\n", c)
25. c = 200
27. c <<= 2
28. fmt.Printf("第 6行 - <<= 运算符实例，c 值为 = %d\n", c)
30. c >>= 2
31. fmt.Printf("第 7 行 - >>= 运算符实例，c 值为 = %d\n", c)
33. c &= 2
34. fmt.Printf("第 8 行 - &= 运算符实例，c 值为 = %d\n", c)
36. c ^= 2
37. fmt.Printf("第 9 行 - ^= 运算符实例，c 值为 = %d\n", c)
39. c |= 2
40. fmt.Printf("第 10 行 - |= 运算符实例，c 值为 = %d\n", c)
41. }

复制代码

查看运行结果：<img> 2.if嵌套语句计算可以数字a在0-100内，且是否可以被5整除

1. package main
3. import "fmt"
5. func main() {
6. //if else语句
7. age := 18
8. if age < 5 {
9. fmt.Println("你的age为：", age, "，你太小了无法进入")
10. } else if age < 18 {
11. fmt.Println("你的age为：", age, "，你虽然不小了，但是仍然未满18，无法进入")
12. } else {
13. fmt.Println("你的age为：", age, "，你已满18岁，可以进入")
14. }
15. }

复制代码

查看运行结果：<img>（2）switch+case+fallthrough使用 fallthrough 会强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true。

1. package main
3. import "fmt"
5. func main() {
7. a := 100
8. //if嵌套
9. if a <= 100 {
10. fmt.Println("a的值符合条件1：在0~100内,为：", a)
11. if a%5 == 0 {
12. fmt.Println("a的值符合条件2:可以被5整除，为：", a)
13. } else {
14. fmt.Println("a的值不符合条件2:不可以被5整除，为：", a)
16. }
17. } else {
18. fmt.Println("a的值不符合条件1：非在0~100内,为:", a)
20. }
21. }

复制代码

查看运行结果：<img>（3）switch+default:defalut如果放在哪里是会最后执行[code]package main import "fmt" func main() { score := 200var grade stringswitch {default:grade = "Nothing"fmt.Printf("你的成绩为%d,并不合法，最终grade为%s", score, grade)case score < 60:grade = "C"fallthroughcase false:fmt.Println("使用fallthrough语句跳入到了下一步打印此句,因为您的成绩为:", grade)case score >= 60 && score < 80:grade = "B"fallthroughcase false:fmt.Println("使用fallthrough语句跳入到了下一步打印此句,因为您的成绩为:", grade)case score >= 80 && score