IT评测·应用市场-qidao123.com

标题: Golang基础教程 [打印本页]
作者: 麻花痒    时间: 2023-5-15 14:54
标题: 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、引用类型变量&可查看引用变量的地址
12345678910111213package 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



欢迎光临 IT评测·应用市场-qidao123.com (https://dis.qidao123.com/) Powered by Discuz! X3.4