【go语言】Golang语言基础
Golang语言基础
Go 语言结构与语法基础
- 包声明
- 引入包
- 函数
- init函数
- 变量
- 标识符
- 行分隔符
- 语句&表达式
- 注释
- 公有成员与私有成员
- 关键字、保留字和预定义
lan-structure
- package1
- package.go
- package2
- p2.go
- go.mod
- main.go
- package1
package.go
1
2
3
4
5
6
7
8
9
10// 包名可以与文件夹名称不一致
package p1
import "fmt"
// 首字母大写就是包的共有函数
// 小写就是私有的
// 没有受保护的成员
func F1(){
fmt.Println("调用package1 F1 方法")
}p2.go
1
2
3
4
5
6
7package p1
import "fmt"
func init(){
fmt.Println("调用package2 init")
}main.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30/* go run ./main.go */
// 声明包
package main
// 引入包
// p1是别名
// 由于在包里面我们也给这个包名是p1，而且这个包是没有可以调用的内容的，所以我们可以使用一个_来取别名，表示占用
import (
p1 "lan-structure/package1"
"fmt"
_ "lan-structure/package2"
)
// 函数（main函数为整个程序的入口
func main(){
// 定义变量
var i = 10
// 语句或表达式
fmt.Println("调用 lan-structure main")
fmt.Println(fmt.Sprintf("打印参数i: %d", i))
p1.F1()
}
// 初始化函数，golang每个包的引用会优先调用该函数
// go中每一个文件夹是一个包，所以并不一定init一定会先于main函数执行，而是每个包在被引用的时候都会优先调用init函数。而main函数所在的包，其init函数会优先于main执行
func init(){
fmt.Println("调用 lan-structure init")
}
数据类型
- bool
- string
- byte
- int, uint, uint8, int16, uint16, int32, uint32, int64, uint64
- float32, float64, complex, complex64, complex128
- rune
- uintptr无符号整型，用于存放一个指针，该类型用于指针计算
- 结构类型
- 指针类型*string
- 数组
- 切片
- map
- interface{}
- 通道类型
- 函数类型
- 时间类型
其中的引用类型
- 切片
- map
- channel
- interface
- func
- 指针类型
var.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48// 变量类型使用方法
package _case
import "fmt"
func VarDeclareCase(){
// 通过var关键词声明变量
var i int
var j = 100 // 自动类型推断，默认推断为int
var j2 int = 100
var f = 100.123 // 自动类型推断，默认推断为float64
var f2 float32 = 100.123 // 自动类型推断，默认推断为float64
var i1, i2 int
// :=以推断的方式定义变量，此方法只适用于局部变量的定义
b := true
// 数组，定长的数组，基本不用
var arr = [5]int{1,2,3,4,5}
arr1 := [...]int{2,3,4,5} // 也是定长的
var arr2 [5]int
arr2[2] = 4
arr2[3] = 5
fmt.Println(i,j,j2,f,f2,i1,i2,b,arr, arr1, arr2)
// golang的指针是不参与运算的，只是用于表示变量地址的类型
var intPtr *int
var floatPtr *float64 // 在golang中，值类型都是有默认值的，而引用类型默认值都为nil
var i100 = 100
fc1(i100)
fmt.Println(i100) // 是不会发生变化的，因为是值传递
fc2(&i100)
fmt.Println(i100) // 传地址会改变实际值
// 接口类型
var inter interface{} // 空接口类型可以接收任何类型的值
inter = i1
inter = floatPtr
fmt.Println(intPtr, floatPtr, inter)
}
func fc1(i int){
i = i + 1
}
func fc2(i *int){
*i = *i + 1
}const.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31// 常量类型使用方法
package _case
import "fmt"
type Gender uint // 一个类型别名
// 自动累加的枚举类型
const (
FEMALE Gender = iota // 一个关键字，默认是0，后面的类型就可以不用写了，会自动累加
MALE
THIRD
)
const (
B = 1 << ( 10 * iota )
KB
MB
_
TB
)
func ConstAndEnumCase(){
const(
A int64 = 10
B = 20
)
fmt.Println(A, B)
var gender Gender = MALE
size := MB
fmt.Println(gender, size)
}struct.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39// 结构类型使用方法
package _case
import "fmt"
// golang中没有class，只有struct
type user struct {
Name string
Age uint
}
func StructCase(){
// struct是一个值类型
u:= user{
Name : "Mick",
Age : 18,
}
f2(u)
fmt.Println(u) // 不会改变
u1:= &user{ // 声明一个指针类型
Name : "Mick1",
Age : 19,
}
fmt.Println(u1)
// 指针类型2
u2 := new(user)
u2.Name = "nick3"
u2.Age = 20
fmt.Println(u2)
// 结构体是值类型，定义变量后将被默认初始化
var u3 user
fmt.Println(u3)
}
func f2(u user){
u.Age = 28
}newmake.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74// new 和make的使用
package _case
import "fmt"
func NewCase(){
// 通过new函数，可以创建任意类型，并返回指针
mpPtr := new(map[string]*user) // 一个map类型，string是key，*user是值
if *mpPtr == nil {
fmt.Println("map 为空")
}
slicePtr := new([]user)
if *slicePtr == nil {
fmt.Println("切片 为空")
}
// 以上两种使用new的方式，得到的值都为nil，因为引用类型不会默认赋值，都只是nil，所以
// 这两种方式都是错误的，(*mpPtr)["A"] = &user{}, (*slicePtr)[0] = user{} ,这两种都会报错
// 正确的：
*slicePtr = append(*slicePtr, user{Name : "mick"})
// 我们的切片是构建在数组之上的，我们的切片是可以自动扩容的，所以一般使用切片而不是数组
userPtr := new(user)
strPtr := new(string)
fmt.Println(mpPtr, slicePtr, userPtr.Name, strPtr) // 直接使用userPtr的内容值是没问题的，因为user是值类型，会有默认初始化
}
// make仅用于 切片、集合、通道的初始化
func MakeCase(){
// 初始化切片，并设置长度和容量
slice := make([]int, 10, 20)
slice[0] = 10
// 初始化集合，并设置集合的初始化大小
mp := make(map[string]string, 10)
mp["A"] = "a" // 不会报错，和new有区别
// 初始化通道，设置通道的读写方向和缓冲大小
ch := make(chan user, 10) // 可读可写，走user类型的通道
ch1 := make(chan <- int, 10) // 只写的，走int类型的通道
ch2 := make(<-chan int, 10) // 只读的
fmt.Println(slice, mp, ch, ch1, ch2)
}
func SliceAndMapCase(){
// 定义切片
var slice []int
slice = []int{1,2,3,4,5,6}
slice1 := make([]int, 10)
slice1[1] = 10
fmt.Println(slice, slice1)
// 切片的截取
slice2 := slice[0:3] // 包括0，不包括5
slice3 := make([]int, 5, 10) // 长度是5， 容量是10
fmt.Println(len(slice3), cap(slice3), slice2)
slice2 = slice3[0:8] // 是可以超过切片长度的，只要不超过容量
// 切片的附加
slice3 = append(slice3, 1,2,3,4,5,6) // 添加的数超过了容量，会发生扩容
fmt.Println(len(slice3), cap(slice3))
// 集合，是无序的
mp := make(map[string]string, 10)
mp["A"] = "a"
mp["B"] = "b"
mp["C"] = "c"
mp["D"] = "d"
for k,v := range mp{
fmt.Println(k, v) // 多试几次会发现是无序的
}
// 删除元素
delete(mp, "B")
fmt.Println(mp)
}type_convert.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73// 演示类型转换
package _case
import (
"fmt"
"strconv"
"time"
"unsafe"
)
func ConvertCase(){
// 1.同一类型的数据转换 数字和数字，字符串和字符和字节
// 2.不同类型的数据转换 数字和字符串
// 3.接口类型转其他类型
// 数字类型的转换
var num1 = 100
fmt.Println(int64(num1))
var num2 int64 = 100
fmt.Println(int(num2)) // 小心精度的丢失，假如本身超过了int类型能表示的数，那么不管怎么转都是int的最大值or最小值
// 字符串与数字类型转换
var num3 = 100
fmt.Println(strconv.Itoa(num3) + "abc") // 仅对int类型
var str1 = "100"
fmt.Println(strconv.Atoi(str1))
var num4 int64 = 1010
fmt.Println(strconv.FormatInt(num4, 10))
var str2 = "1010"
fmt.Println(strconv.ParseInt(str2, 10, 64))
// 字符串与字节，即[]byte
var str3 = "今天天气好"
byte1 := []byte(str3)
fmt.Println([]byte(str3))
fmt.Println(string(byte1))
// 字符串与runa转换，runa是一种专门用来处理unicode等编码的类型
// rune 实际上是一个int32类型
// 将字符串转换为rune切片，实际上rune切片中存储了字符串的Unicode码点
var rune1 = []rune(str3)
fmt.Println(rune1)
fmt.Println(string(rune1))
fmt.Println(string(rune1[3]))
// 接口类型转具体类型
var inf interface{} = 100
var infStruct interface{} = user{}
i, ok := inf.(int)
fmt.Println(i, ok)
u, ok := infStruct.(user)
fmt.Println(u, ok)
// 时间类型转字符串
var t time.Time
t = time.Now()
timeStr := t.Format("2006-01-02 15:04:05Z07:00") // 使用这个具体的时间来表达格式，不要误会有什么具体含义，只要记下来这个具体的时间
fmt.Println(timeStr)
// 字符串转时间
t2, _ := time.Parse("2006-01-02 15:04:05Z07:00", timeStr)
fmt.Println(t2)
// uintptr
u1 := user{}
// unsafe.Pointer是一个通用的指针类型，不能用于计算
uPtr := unsafe.Pointer(&u1)
namePtr := unsafe.Pointer(uintptr(uPtr) + unsafe.Offsetof(u1.Name))
*(*string)(namePtr) = "nick"
fmt.Println(u1)
}
变量作用域与函数
- case.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54package p1
// 形参
// 局部变量
// 全局变量
import "errors"
// 函数可以有多个形参和多个返回值，返回值也可以和形参一样拥有参数名称
func SumCase(a, b int) (sum int, err error){
// 因为返回引用的时候，有可能出错为nil，那么我们最好的实践就是加error这个变量，这样我们就可以通过判断error来处理这样的情况
if a <= 0 && b <= 0 {
err = errors.New("两数相加不能同时小于0")
return
}
sum = a + b
return
}
// 值传递与引用传递
func ReferenceCase(a int, b *int){
a += 1
*b += 1
}
// 全局变量，注意是包内的全局变量
var g int
// 共有的才能被外部访问
var G int
// 变量作用域
func ScopeCase(a, b int){
c := 100
g = a + b + c
G = g
}
// 面向对象写法
type User struct {
Name string
Age uint
}
func NewUser(name string, age uint) *User{
return &User{Name : name, Age:age}
}
func (u *User) GetName() string{
return u.Name
}
func (u *User) GetAge() uint{
return u.Age
} - main.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21package main
import (
"fmt"
p1"var-func/case"
)
func main(){
a := 10
b := 20
fmt.Println(p1.SumCase(a, b))
fmt.Println(a, b) // 值传递，不会修改变量
p1.ReferenceCase(a, &b)
fmt.Println(a, b)
fmt.Println(p1.G)
p1.ScopeCase(a, b)
fmt.Println(p1.G)
user := p1.NewUser("mark", 18)
fmt.Println(user.GetName(), user.GetAge())
}
运算符与优先级
1 | package p1 |
流程控制
- if else
- for
- switch case
- goto
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108package p1
import "fmt"
func FlowControlCase(){
ifElseCase(0)
ifElseCase(1)
ifElseCase(2)
forCase()
switchCase("A",1)
switchCase("C","")
}
func ifElseCase(a int){
if a == 0 {
fmt.Println("执行if语句块")
}else if a == 1{
fmt.Println("执行else if语句块")
}else{
fmt.Println("执行else语句块")
}
}
func forCase(){
for i:=0;i<10;i++{
if i == 5{
continue
}
fmt.Println("位置1执行for语句块，i:",i)
}
var i int
var b = true
for b {
fmt.Println("位置2执行for语句块，i:",i)
i++
if i >= 10 {
b = false
}
}
list := []int{1,2,3,4,5,6,7,8,9}
for index, data := range list{
fmt.Printf("位置3执行for语句块，index:%d, data:%d\n",index,data)
}
mp := map[string]string{"A":"a","B":"b","C":"c"}
for k, value := range mp {
fmt.Printf("位置4执行for语句块，key:%v, value:%v\n",k,value)
}
str := "今天天气很好"
for index, char := range str {
fmt.Printf("位置5执行for语句块，index:%d, char:%v\n",index,string(char)) // 可以发现对字符串的遍历是得出的unicode码点，也就是rune类型的
}
var j int
for{
for {
fmt.Println("位置6执行for语句块，j:",j)
j++
if j >= 10 {
break // 只跳出一层
}
}
break
}
lab1:
for i :=0;i<2;i++{
for j:=0;j<2;j++{
fmt.Printf("位置7执行for语句块，i:%d,j:%d\n",i,j)
break lab1 // 和goto是不一样的，跳出就是跳出了，goto会重新从lab1位置执行
}
}
}
func switchCase(alpha string, in interface{}){
switch alpha{
case "A":
fmt.Println("执行A") // 不需要break，默认就是break
case "B":
fmt.Println("执行B")
case "C","D":
fmt.Println("执行CD")
fallthrough // 会强制执行下一个语句块，但是不会执行下下个
case "E":
fmt.Println("执行E")
case "F":
fmt.Println("执行E")
}
switch in.(type){
case string:
fmt.Println("字符串类型")
case int:
fmt.Println("int类型")
default:
fmt.Println("未识别类型")
}
}
func gotoCase(){
var a = 0
lab1:
fmt.Println("goto 位置")
for i:=0;i<10;i++{
a += i
if a == 0{
goto lab1 // 死循环
}
}
}
泛型编程
- 什么是泛型？
- 开发过程中编写适用于所有类型的模板，只有在具体使用的时候才能确定其真正的类型
- 利弊
- 提高了代码的复用率，提高了编程效率
- 不同类型间代码复用，使得代码更加优雅
- 增加了编译器的负担，降低了编译效率
泛型简单应用
1 | // 简单泛型应用 |
泛型类型
1 | // 泛型类型 |
泛型接口
1 | // 泛型接口 |
泛型receiver
1 | // 泛型receiver和结构体 |
golang标准库
1. encoding包
1 | // 编解码功能 |
2. errors包
1 | // 错误处理功能 |
3. fmt包
1 | // 字符串处理 |
4. log包
1 | package p1 |
5. math包
1 | // 数学函数功能 |
6. reflect包
1 | // 反射机制用法 |
7. regexp包
1 | // 正则表达式 |
8. sort包
1 | // 排序包使用 |