Golang基础教程

一、go语言结构：

1.1.运行Hello World！

golang">
package main
import "fmt"
func main() {fmt.Println("Hello World！")
}

二、go基础语法

2.1 fmt.Println会自动换行

golang">
package main
import "fmt"
func main() {fmt.Println("Hello World！")fmt.Println("hello world 自动换行")
}

在这里插入图片描述

2.2 注释

单行注释以//开头，多行注释以 /* 开头，并以 / 结尾
// 单行注释
/
我说多行注释1
我说多行注释2
我说多行注释3
*/

2.3 标识符

标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母(A_Z和az)数字(0~9)、下划线_组成的序列，但是第一个字符必须是字母或下划线而不能是数字。
以下是有效的标识符：
mahesh kumar abc move_name a_123
myname50 _temp j a23b9 retVal
以下是无效的标识符：

1ab（以数字开头）
case（Go 语言的关键字）
a+b（运算符是不允许的）

2.4 字符串连接

Go 语言的字符串连接可以通过 + 实现：

golang">
package main
import "fmt"
func main() {fmt.Println("golang"+"python")
}

在这里插入图片描述

2.5 关键字

下面列举了 Go 代码中会使用到的 25 个关键字或保留字：
break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var

2.6 格式化字符串

golang">
package main
import "fmt"
func main() {var today stringtoday = "周二"var day intday = 3fmt.Printf("%s是一周的第%d天",today,day)
}

在这里插入图片描述

三、变量

3.1 申明一个变量值，变量类型，并初始化

（1）两种方式，方式1：使用var声明

golang">
package main
import "fmt"
func main() {var str string = "hello"var num int = 123println(str,num)
}

运行结果
在这里插入图片描述

（2）使用:=声明

golang">
package main
import "fmt"
func main() {str := "hello"num := 123println(str,num)
}

运行结果
在这里插入图片描述

3.2 申请变量未初始化，则会给默认值

数值类型初始值0
布尔类型为fasle
字符串为""
其他类型为nil

golang">
package main
import "fmt"
func main() {var num1 intfmt.Println("num1的初始值为:",num1)var str1 stringfmt.Println("str1的初始值为:",str1)var flag boolfmt.Println("flag的初始值为:",flag)var a *intvar b []intvar c map[string] intvar d chan intvar e func(string) intvar f errorfmt.Println("a,b,c,d,e,f的初始值为:",a,b,c,d,e,f)
}

运行结果
在这里插入图片描述

3.3 根据值自行判定变量类型

golang">
package main
import "fmt"
func main() {var str2 = "hello"
var num2 = 25
var flag2 = true
fmt.Println("str2的类型为:", reflect.TypeOf(str2))
fmt.Println("num2的类型为:", reflect.TypeOf(num2))
fmt.Println("flag2的类型为:", reflect.TypeOf(flag2))
}

运行结果
在这里插入图片描述

3.4 多变量声明

使用逗号隔开

golang">
package main
import "fmt"
func main() {var num1,num2,num3 int = 4,6,8fmt.Println("num1,num2,num3的值为:",num1,num2,num3)
}

运行结果
在这里插入图片描述

3.5 引用类型变量

&可查看引用变量的地址

golang">
package main
import "fmt"
func main() {var num = 10var str = "hello"fmt.Println("num的值为:",num)fmt.Println("num的引用为:",&num)fmt.Println("str的值为:",str)fmt.Println("str的应用为:",&str)
}

运行结果
在这里插入图片描述

四、常量

4.1 常量定义

常量是一个简单值的标识符，在程序运行时，不会被修改的量，使用const修饰一个常量

golang">
package main
import "fmt"
func main() {const a string = "abc" //显示类型定义const b = "abc" //隐示类型定义const c, d = "o", "k"println(a, b, c, d)
}

运行结果
在这里插入图片描述

4.2 常量还可以用作枚举

并且常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过

golang">
package main
import "fmt"
import "unsafe"
func main() {const (Unknown = 0Female = 1Male = 2)const (a = "abc"b = len(a)c = unsafe.Sizeof(a) //16个字节，返回string结构体的字符与长度各8个字符相加)println(Unknown, Female, Male, a, b, c)
}

运行结果
在这里插入图片描述

4.3 特殊常量iota

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

golang">
package main
import "fmt"
import "unsafe"
func main() {const (a = iota //0b //1c //2d = "ha" //独立值，iota += 1e //"ha" iota += 1f = 100 //iota +=1g //100 iota +=1h = iota //7,恢复计数i //8)fmt.Println(a, b, c, d, e, f, g, h, i)
}

运行结果
在这里插入图片描述

五、运算符

5.1 算数运算符

golang">
package main
import "fmt"
import "unsafe"
func main() {a := 1b := 2fmt.Println("a加b等于:", a+b)fmt.Println("a减b等于:", a-b)fmt.Println("a剩b等于:", a*b)fmt.Println("a除b等于:", a/b)fmt.Println("a除b后取余数等于:", a%b)a++fmt.Println("a++后的结果:", a)b--fmt.Println("b--后的结果:", b)
}

运行结果
在这里插入图片描述

5.2 关系运算符

关系运算符主要有 =,!=,>,<,>=,<=共6种运算符

golang">
package main
import "fmt"
import "unsafe"
func main() {var m int = 21var n int = 10if m == n {fmt.Println("第一行返回:a等于b")} else {fmt.Println("第一行返回:a不等于b")}if m < n {fmt.Println("第二行返回:a小于b")} else {fmt.Println("第二行返回:a不小于b")}if m > n {fmt.Println("第三行返回:a大于b")} else {fmt.Println("第三行返回:a不大于b")}m, n = n, m //交换m,n的值if m <= n {fmt.Println("第四行返回:a小于等于b")}if m >= n {fmt.Println("第四行返回:a不小于b")}
}

运行结果
在这里插入图片描述

5.3 逻辑运算符

主要有三种逻辑运算符:
&&:逻辑 AND 运算符。如果两边的操作数都是 True，则条件 True，否则为 False。
||:逻辑 OR 运算符。如果两边的操作数有一个 True，则条件 True，否则为 False。
!:逻辑 NOT 运算符。如果条件为 True，则逻辑 NOT 条件 False，否则为 True。

golang">
package main
import "fmt"
import "unsafe"
func main() {var a bool = truevar b bool = falseif a && b {fmt.Printf("第一行 - 条件为 true\n")} else if a || b {fmt.Printf("第一行 - 条件为 true\n")}a, b = b, a //修改a，b的值，对调if a && b {fmt.Printf("第二行 - 条件为 true\n")} else {fmt.Printf("第二行 - 条件为 false\n")}if !(a && b) {fmt.Printf("第三行 - 条件为 true\n")} else {fmt.Printf("第三行 - 条件为 false\n")}
}

运行结果
在这里插入图片描述

5.4 位运算符

位运算符对整数在内存中的二进制位进行操作。
&, |, ^ ，<<，>>四种位运算方式

golang">
package main
import "fmt"
import "unsafe"
func main() {var a uint = 60 /* 60 = 0011 1100 */var b uint = 13 /* 13 = 0000 1101 */var c uint = 0c = a & b /* 12 = 0000 1100 */fmt.Printf("第一行 - c 的值为 %d\n", c)c = a | b /* 61 = 0011 1101 */fmt.Printf("第二行 - c 的值为 %d\n", c)c = a ^ b /* 49 = 0011 0001 */fmt.Printf("第三行 - c 的值为 %d\n", c)c = a << 2 /* 240 = 1111 0000 */fmt.Printf("第四行 - c 的值为 %d\n", c)c = a >> 2 /* 15 = 0000 1111 */fmt.Printf("第五行 - c 的值为 %d\n", c)
}

运行结果
在这里插入图片描述

5.5 赋值运算符

赋值符号为=,将一个表达式的值赋给一个左值，结合之前其他的型号的赋值运算符如下

golang">
package main
import "fmt"
import "unsafe"
func main() {var a int = 21var c intc = afmt.Printf("第 1 行 - = 运算符实例，c 值为 = %d\n", c)c += afmt.Printf("第 2 行 - += 运算符实例，c 值为 = %d\n", c)c -= afmt.Printf("第 3 行 - -= 运算符实例，c 值为 = %d\n", c)c *= afmt.Printf("第 4 行 - *= 运算符实例，c 值为 = %d\n", c)c /= afmt.Printf("第 5 行 - /= 运算符实例，c 值为 = %d\n", c)c = 200c <<= 2fmt.Printf("第 6行 - <<= 运算符实例，c 值为 = %d\n", c)c >>= 2fmt.Printf("第 7 行 - >>= 运算符实例，c 值为 = %d\n", c)c &= 2fmt.Printf("第 8 行 - &= 运算符实例，c 值为 = %d\n", c)c ^= 2fmt.Printf("第 9 行 - ^= 运算符实例，c 值为 = %d\n", c)c |= 2fmt.Printf("第 10 行 - |= 运算符实例，c 值为 = %d\n", c)
}

运行结果
在这里插入图片描述

六、条件语句

6.1 if else语句

golang">
package main
import "fmt"
import "unsafe"
func main() {age := 18if age < 5 {fmt.Println("你的age为：", age, "，你太小了无法进入")} else if age < 18 {fmt.Println("你的age为：", age, "，你虽然不小了，但是仍然未满18，无法进入")} else {fmt.Println("你的age为：", age, "，你已满18岁，可以进入")}
}

运行结果
在这里插入图片描述

6.2 if嵌套语句

计算可以数字a在0-100内，且是否可以被5整除

golang">
package main
import "fmt"
import "unsafe"
func main() {a := 100//if嵌套if a <= 100 {fmt.Println("a的值符合条件1：在0~100内,为：", a)if a%5 == 0 {fmt.Println("a的值符合条件2:可以被5整除，为：", a)} else {fmt.Println("a的值不符合条件2:不可以被5整除，为：", a)}} else {fmt.Println("a的值不符合条件1：非在0~100内,为:", a)}
}

运行结果
在这里插入图片描述

6.3 switch语句

6.3.1 switch+case语句：

switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上至下逐一测试，直到匹配为止。
witch 默认情况下 case 最后自带 break 语句，匹配成功后就不会执行其他 case

golang">
package main
import "fmt"
import "unsafe"
func main() {score := 75var grade stringswitch {case score < 60:grade = "C"case score >= 60 && score < 80:grade = "B"case score >= 80:grade = "A"}fmt.Println(grade)
}

运行结果
在这里插入图片描述
6.3.2 switch+case+fallthrough：

使用 fallthrough 会强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true。

golang">
package main
import "fmt"
import "unsafe"
func main() {score := 90var grade stringswitch {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:grade = "A"fallthroughcase false:fmt.Println("使用fallthrough语句跳入到了下一步打印此句,因为您的成绩为:", grade)}fmt.Println(grade)
}

运行结果
在这里插入图片描述

6.3.3 switch+default:

defalut如果放在哪里是会最后执行

golang">
package main
import "fmt"
import "unsafe"
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 <= 100:grade = "A"fallthroughcase false:fmt.Println("使用fallthrough语句跳入到了下一步打印此句,因为您的成绩为:", grade)}
}

运行结果
在这里插入图片描述

6.4 select语句

select 是 Go 中的一个控制结构，类似于用于通信的 switch 语句。每个 case 必须是一个通信操作，要么是发送要么是接收。
select 随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行。一个默认的子句应该总是可运行的。

golang">
package main
import "fmt"
import "unsafe"
func main() {var c1, c2, c3 chan intvar i1, i2 intselect {case i1 = <-c1:fmt.Printf("received ", i1, " from c1\n")case c2 <- i2:fmt.Printf("sent ", i2, " to c2\n")case i3, ok := (<-c3): // same as: i3, ok := <-c3if ok {fmt.Printf("received ", i3, " from c3\n")} else {fmt.Printf("c3 is closed\n")}default:fmt.Printf("no communication\n")}
}

运行结果
在这里插入图片描述

七、循环

7.1 for循环

7.1.1 for condition {}

golang">
package main
import "fmt"
import "unsafe"
func main() {for i:=0;i<10;i++{fmt.Println(i)}
}

运行结果
在这里插入图片描述

7.1.1 for init {}

golang">
package main
import "fmt"
import "unsafe"
func main() {Strings := []string{"google","baidu"}for m,n := range Strings{fmt.Println(m,n)}
}

运行结果
在这里插入图片描述

7.2 循环嵌套

golang">
package main
import "fmt"
import "unsafe"
func main() {var i, j intfor i = 2; i < 30; i++ {for j = 2; j <= i/j; j++ {if i%j == 0 {break}}if j > (i / j) {fmt.Println(i, "是一个素数")}
}
}

运行结果
在这里插入图片描述

7.3 break语句

7.3.1 用于循环语句中跳出循环，并开始执行循环之后的语句

golang">
package main
import "fmt"
import "unsafe"
func main() {var a int = 10for a < 20 {fmt.Println("a的值：", a)a++if a == 15 {break}}
}

运行结果
在这里插入图片描述

7.3.2 break 在 switch（开关语句）中在执行一条 case 后跳出语句的作用。（此break会隐藏）
7.3.3 在多重循环中，可以用标号 label 标出想 break 的循环

7.4 continue 语句

Go 语言的 continue 语句有点像 break 语句。但是 continue 不是跳出循环，而是跳过当前循环执行下一次循环语句。

7.4.1 for 循环中，执行 continue 语句会触发 for 增量语句的执行

golang">
package main
import "fmt"
import "unsafe"
func main() {a := 10for a < 20 {a++if a == 15 {continue}fmt.Println("a的值为:", a)}
}

运行结果
在这里插入图片描述

7.5 goto 语句

Go 语言的 goto 语句可以无条件地转移到过程中指定的行。
goto 语句通常与条件语句配合使用。可用来实现条件转移，构成循环，跳出循环体等功能。

golang">
package main
import "fmt"
import "unsafe"
func main() {var a int = 10/* 循环 */LOOP:for a < 20 {if a == 15 {a = a + 1goto LOOP}fmt.Printf("a的值为 : %d\n", a)a++}
}

运行结果
在这里插入图片描述

八、函数

8.1 函数定义与调用

Go 语言最少有个 main() 函数。
你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。
函数定义解析：

func：函数由 func 开始声明
function_name：函数名称，参数列表和返回值类型构成了函数签名。
parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
函数体：函数定义的代码集合。

golang">
package main
import "fmt"
import "unsafe"
func max(num1, num2 int) int {/* 声明局部变量 */var result intif num1 > num2 {result = num1} else {result = num2}return result
}
func main() {var a int = 98var b int = 99var c int = max(a, b)fmt.Println("a,b两个数的最大值为：", c)
}

运行结果
在这里插入图片描述

8.2 函数返回多个值

golang">
package main
import "fmt"
import "unsafe"func swap(x, y string) (string, string) {x, y = y, xreturn x, y
}
func main() {x := "hello"y := "world"fmt.Println("交换前的x与y分别为：", x, y)x, y = swap(x, y)fmt.Println("交换后的x与y分别为：", x, y)
}

运行结果
在这里插入图片描述

8.3 值传递与引用传递

8.3.1 值传递

值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数

golang">
package main
import "fmt"
import "unsafe"func swap(x, y string) (string, string) {x, y = y, xreturn x, y
}
func main() {x := "hello"y := "world"fmt.Println("交换前的x与y分别为：", x, y)x, y = swap(x, y)fmt.Println("交换后的x与y分别为：", x, y)
}

运行结果
在这里插入图片描述

8.3.2 引用传递

引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数

golang">
package main
import "fmt"
import "unsafe"
func swap(x, y *string) string {var temp stringtemp = *x*x = *y*y = tempreturn temp
}
func main() {x := "hello"y := "world"fmt.Println("交换前的x与y分别为：", x, y)swap(&x, &y)fmt.Println("交换后的x与y分别为：", x, y)
}

运行结果
在这里插入图片描述

8.4 函数作为另外一个函数的实参（进阶ToDo）

8.5 闭包（进阶ToDo）

8.6 方法（进阶ToDo）

九、变量作用域

9.1 局部变量

函数内定义的变量称为局部变量，它们的作用域只在函数体内，参数和返回值变量也是局部变量

golang">
package main
import "fmt"
import "unsafe"
func main() {var a, b, c int/* 初始化参数 */a = 10b = 20c = a + bfmt.Printf("结果： a = %d, b = %d and c = %d\n", a, b, c)
}

运行结果
在这里插入图片描述

9.2 全局变量

函数外定义的变量称为全局变量，全局变量可以在整个包甚至外部包（被导出后）使用

golang">
package main
import "fmt"
import "unsafe"
var g int
func main() {/* 声明局部变量 */var a, b int/* 初始化参数 */a = 10b = 20g = a + bfmt.Printf("结果： a = %d, b = %d and g = %d\n", a, b, g)
}

运行结果
在这里插入图片描述