Golang基础教程

打印 上一主题 下一主题

主题 912|帖子 912|积分 2736

Golang基础学习

 以下使用goland的IDE演示,包含总计的golang基础功能共20个章节一、go语言结构:二、go基础语法:三、变量:四、常量:五、运算符:六、条件语句:七、循环:八、函数:九、变量作用域:十、数组:十一、指针:十二、结构体:十三、切片:十四、范围(Range):十五、集合:十六、递归:十七、数据类型转换:十八、接口:十九、错误处理:二十、并发: 一、go语言结构:1.运行Hello World!
  1. package main
  2. import "fmt"
  3. func main() {
  4. fmt.Println("Hello World!")
  5. }
复制代码
查看运行结果:<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
  2. import "fmt"
  3. func main() {
  4. fmt.Println("Hello World!")
  5. fmt.Println("Println函数会在行末尾自动加上换行符")
  6. }
复制代码
查看运行结果:<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"
  2. func main() {
  3. fmt.Println("golang"+"python")
  4. }
复制代码
查看运行结果:<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
  2. import "fmt"
  3. func main() {
  4. //fmt.Println("Hello World!")
  5. //fmt.Println("Println函数会在行末尾自动加上换行符")
  6. //fmt.Println("golang" + "python")
  7. var today = "星期六"
  8. var number = 6
  9. fmt.Printf("今天是%s,今天在本周的排号为%d", today, number)
  10. }
复制代码
查看运行结果:<img> 三、变量1、申明一个变量值,变量类型,并初始化(1)两种方式,方式1:使用var声明
  1. package main
  2. func main() {
  3. var str string = "hello"
  4. var num int = 123
  5. println(str, num)
  6. }
复制代码
查看运行结果:<img>(2)使用:=声明
  1. package main
  2. func main() {
  3. //var str string = "hello"
  4. //var num int = 123
  5. //println(str, num)
  6. mystr := "very good"
  7. mynum := 345
  8. println(mystr, mynum)
  9. }
复制代码
查看运行结果:<img> 2、申请变量未初始化,则会给默认值数值类型初始值0布尔类型为fasle字符串为""其他类型为nil
  1. func main() {
  2. //var str string = "hello"
  3. //var num int = 123
  4. //println(str, num)
  5. //初始值0
  6. var num1 int
  7. fmt.Println("num1初始值为:", num1)
  8. //初始值""
  9. var str1 string
  10. fmt.Println("str1初始值为:", str1)
  11. //布尔类型为 false
  12. var flag bool
  13. fmt.Println("flag初始值为:", flag)
  14. //其他类型为nil
  15. var a *int
  16. var b []int
  17. var c map[string]int
  18. var d chan int
  19. var e func(string) int
  20. var f error
  21. fmt.Println("a,b,c,d,e,f的初始值分别为:", a, b, c, d, e, f)
  22. }
复制代码
查看运行结果:<img> 3、根据值自行判定变量类型
  1. package main
  2. import (
  3. "fmt"
  4. "reflect"
  5. )
  6. func main() {
  7. var str2 = "hello"
  8. var num2 = 25
  9. var flag2 = true
  10. fmt.Println("str2的类型为:", reflect.TypeOf(str2))
  11. fmt.Println("num2的类型为:", reflect.TypeOf(num2))
  12. fmt.Println("flag2的类型为:", reflect.TypeOf(flag2))
  13. }
复制代码
查看运行结果:<img> 4、多变量声明:使用逗号隔开
  1. package main
  2. import "fmt"
  3. func main() {
  4. var str3, str4, str5 string = "hello", "World", "ok"
  5. num3, num4, num5 := 2, 3, 4
  6. fmt.Println(str3, str4, str5)
  7. fmt.Println(num3, num4, num5)
  8. }
复制代码
查看运行结果:<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
  2. func main() {
  3. const a string = "abc" //显示类型定义
  4. const b = "abc" //隐示类型定义
  5. const c, d = "o", "k"
  6. println(a, b, c, d)
  7. }
复制代码
查看运行结果:<img> 2. 常量还可以用作枚举:并且常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中,函数必须是内置函数,否则编译不过
  1. package main
  2. import "unsafe"
  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. const (
  9. Unknown = 0
  10. Female = 1
  11. Male = 2
  12. )
  13. const (
  14. a = "abc"
  15. b = len(a)
  16. c = unsafe.Sizeof(a) //16个字节,返回string结构体的字符与长度各8个字符相加
  17. )
  18. println(Unknown, Female, Male, a, b, c)
  19. }
复制代码
查看运行结果:<img> 3.特殊常量iotaiota,特殊常量,可以认为是一个可以被编译器修改的常量。iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前),const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。
  1. package main
  2. func main() {
  3. const (
  4. a = iota
  5. b
  6. c
  7. )
  8. println(a, b, c)
  9. }
复制代码
查看运行结果:<img>
  1. package main
  2. import "fmt"
  3. func main() {
  4. //println(a, b, c)
  5. const (
  6. a = iota //0
  7. b //1
  8. c //2
  9. d = "ha" //独立值,iota += 1
  10. e //"ha" iota += 1
  11. f = 100 //iota +=1
  12. g //100 iota +=1
  13. h = iota //7,恢复计数
  14. i //8
  15. )
  16. fmt.Println(a, b, c, d, e, f, g, h, i)
  17. }
复制代码
查看运行结果:<img> 五、运算符1.算数运算符:
  1. package main
  2. import "fmt"
  3. func main() {
  4. a := 1
  5. b := 2
  6. fmt.Println("a加b等于:", a+b)
  7. fmt.Println("a减b等于:", a-b)
  8. fmt.Println("a剩b等于:", a*b)
  9. fmt.Println("a除b等于:", a/b)
  10. fmt.Println("a除b后取余数等于:", a%b)
  11. a++
  12. fmt.Println("a++后的结果:", a)
  13. b--
  14. fmt.Println("b--后的结果:", b)
  15. }
复制代码
查看运行结果:<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
  2. import "fmt"
  3. func main() {
  4. var m int = 21
  5. var n int = 10
  6. if m == n {
  7. fmt.Println("第一行返回:a等于b")
  8. } else {
  9. fmt.Println("第一行返回:a不等于b")
  10. }
  11. if m < n {
  12. fmt.Println("第二行返回:a小于b")
  13. } else {
  14. fmt.Println("第二行返回:a不小于b")
  15. }
  16. if m > n {
  17. fmt.Println("第三行返回:a大于b")
  18. } else {
  19. fmt.Println("第三行返回:a不大于b")
  20. }
  21. m, n = n, m //交换m,n的值
  22. if m <= n {
  23. fmt.Println("第四行返回:a小于等于b")
  24. }
  25. if m >= n {
  26. fmt.Println("第四行返回:a不小于b")
  27. }
  28. }
复制代码
查看运行结果:<img> 4.位运算符位运算符对整数在内存中的二进制位进行操作。 &, |,  ^ ,四种位运算方式
  1. package main
  2. import "fmt"
  3. func main() {
  4. var a bool = true
  5. var b bool = false
  6. if a && b {
  7. fmt.Printf("第一行 - 条件为 true\n")
  8. } else if a || b {
  9. fmt.Printf("第一行 - 条件为 true\n")
  10. }
  11. a, b = b, a //修改a,b的值,对调
  12. if a && b {
  13. fmt.Printf("第二行 - 条件为 true\n")
  14. } else {
  15. fmt.Printf("第二行 - 条件为 false\n")
  16. }
  17. if !(a && b) {
  18. fmt.Printf("第三行 - 条件为 true\n")
  19. } else {
  20. fmt.Printf("第三行 - 条件为 false\n")
  21. }
  22. }
复制代码
查看运行结果:<img> 5.赋值运算符赋值符号为=,将一个表达式的值赋给一个左值,结合之前其他的型号的赋值运算符如下:
  1. package main
  2. import "fmt"
  3. func main() {
  4. var a uint = 60 /* 60 = 0011 1100 */
  5. var b uint = 13 /* 13 = 0000 1101 */
  6. var c uint = 0
  7. c = a & b /* 12 = 0000 1100 */
  8. fmt.Printf("第一行 - c 的值为 %d\n", c)
  9. c = a | b /* 61 = 0011 1101 */
  10. fmt.Printf("第二行 - c 的值为 %d\n", c)
  11. c = a ^ b /* 49 = 0011 0001 */
  12. fmt.Printf("第三行 - c 的值为 %d\n", c)
  13. c = a << 2 /* 240 = 1111 0000 */
  14. fmt.Printf("第四行 - c 的值为 %d\n", c)
  15. c = a >> 2 /* 15 = 0000 1111 */
  16. fmt.Printf("第五行 - c 的值为 %d\n", c)
  17. }
复制代码
查看运行结果:<img> 六、条件语句1.if else语句:
  1. package main
  2. import "fmt"
  3. func main() {
  4. var a int = 21
  5. var c int
  6. c = a
  7. fmt.Printf("第 1 行 - = 运算符实例,c 值为 = %d\n", c)
  8. c += a
  9. fmt.Printf("第 2 行 - += 运算符实例,c 值为 = %d\n", c)
  10. c -= a
  11. fmt.Printf("第 3 行 - -= 运算符实例,c 值为 = %d\n", c)
  12. c *= a
  13. fmt.Printf("第 4 行 - *= 运算符实例,c 值为 = %d\n", c)
  14. c /= a
  15. fmt.Printf("第 5 行 - /= 运算符实例,c 值为 = %d\n", c)
  16. c = 200
  17. c <<= 2
  18. fmt.Printf("第 6行 - <<= 运算符实例,c 值为 = %d\n", c)
  19. c >>= 2
  20. fmt.Printf("第 7 行 - >>= 运算符实例,c 值为 = %d\n", c)
  21. c &= 2
  22. fmt.Printf("第 8 行 - &= 运算符实例,c 值为 = %d\n", c)
  23. c ^= 2
  24. fmt.Printf("第 9 行 - ^= 运算符实例,c 值为 = %d\n", c)
  25. c |= 2
  26. fmt.Printf("第 10 行 - |= 运算符实例,c 值为 = %d\n", c)
  27. }
复制代码
查看运行结果:<img> 2.if嵌套语句计算可以数字a在0-100内,且是否可以被5整除
  1. package main
  2. import "fmt"
  3. func main() {
  4. //if else语句
  5. age := 18
  6. if age < 5 {
  7. fmt.Println("你的age为:", age, ",你太小了无法进入")
  8. } else if age < 18 {
  9. fmt.Println("你的age为:", age, ",你虽然不小了,但是仍然未满18,无法进入")
  10. } else {
  11. fmt.Println("你的age为:", age, ",你已满18岁,可以进入")
  12. }
  13. }
复制代码
查看运行结果:<img>(2)switch+case+fallthrough使用 fallthrough 会强制执行后面的 case 语句,fallthrough 不会判断下一条 case 的表达式结果是否为 true。
  1. package main
  2. import "fmt"
  3. func main() {
  4. a := 100
  5. //if嵌套
  6. if a <= 100 {
  7. fmt.Println("a的值符合条件1:在0~100内,为:", a)
  8. if a%5 == 0 {
  9. fmt.Println("a的值符合条件2:可以被5整除,为:", a)
  10. } else {
  11. fmt.Println("a的值不符合条件2:不可以被5整除,为:", a)
  12. }
  13. } else {
  14. fmt.Println("a的值不符合条件1:非在0~100内,为:", a)
  15. }
  16. }
复制代码
查看运行结果:<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

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有账号?立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览

快速回复

您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

羊蹓狼

金牌会员
这个人很懒什么都没写!

标签云

快速回复 返回顶部 返回列表