Go学习之旅：包、变量和函数（DAY 1）

---

前引

---

由于这段时间都一直在找实习 而现在已经快到另外一个阶段了 所以也算是有一点心情继续更新博客了

家中有事本来打算今天离校回成都 但恰巧今天再次封校 无奈把之前买的票给退掉了 只能尽人事 听天意了 继续留校等待出校的时机 希望封控不会持续太久…

这段时间发生了太多太多事情了 后续有比较好的时机会单独分享一下

后续由于某些原因 需要去学习Go语言 在寝室闲着也是闲着 不如自己也就花点时间学一下 后续反正也要学

God Bless！上天保佑

---

包、变量和函数

---

1、包的概念和所用

---

Go语言开始都是以包为单位 有两个关键字 Packet Import 可执行程序必须包含main Packet 就像c语言中的以main函数为入口 import则是引入其他包的路径 例如常用的fmt 就类似于c语言中的头文件引入
注意使用的时候 import是引入包的路径 而在函数中 则是指出包来使用函数

需要理解这个概念 于是自己写了两个文件

---

111.go

package main

import (
	"fmt"
	"../test2"
)

func main() {
	fmt.Println("today is 2022/11/26")
	FuckCOVID.Go()
}
1
2
3
4
5
6
7
8
9
10
11

---

222.go

package FuckCOVID

import (
	"fmt"
)

func Go() {
	fmt.Println("Fuck this COVID-19")
}
1
2
3
4
5
6
7
8
9

---

运行效果

---

2、导出名或者导出函数

---

Go语言中如何想要导出当前包的函数或者变量 必须要把变量头个字符大写
小写可以理解为 c/c++中的 全局static函数 而大写则是可以导出使用 例如下方

---

111.go
第四行main函数 注释才可以使用

package main

import (
	"fmt"
	"../test2"
	"math"
)

func main() {
	fmt.Println(math.Pi)
	fmt.Println(FuckCOVID.Publicnum)
	//fmt.Println(FuckCOVID.privatenum)
	FuckCOVID.PublicGo()
	//FuckCOVID.privatego()
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

---

222.go

package FuckCOVID

import (
	"fmt"
)

var Publicnum int = 10
var privatenum int = 20

func PublicGo() {
	fmt.Println("Fuck this COVID-19 Public")
}

func privatego() {
	fmt.Println("Fuck this COVID-19 Private")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

---

运行效果

---

3.1、函数参数声明方式（一）

---

go语言的函数参数 以及变量的声明方式与c/c++的函数 参数声明方式有太大的不同

例如变量声明
c-style int a float b double c
go-style var a int var b float var c double**

例如函数声明 两个参数的
c-style int add(int x, int y) { return x + y; }
go-style func Add(x int, y int) int { return x + y }

下方链接是解释了为什么函数 变量声明与c语言不同了
Go’s Declaration Syntax

---

声明一个简单的函数
111.go

package main

import (
	"fmt"
)

func add(x int, y int) int {
	return x + y
}

func main() {
	fmt.Println(add(10, 10))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

---

运行效果

---

3.2、函数参数声明方式（二）

---

对于大量重复的参数类型 可以优化
放到最后一个参数声明即可

111.go

package main

import (
	"fmt"
)

func addthreenum(x, y, z int) int {
	return x + y + z
}

func main() {
	fmt.Println(addthreenum(10, 10, 10))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

---

运行效果

---

4、函数返回值支持多值返回

---

go语言支持多值返回 这样对于很多功能实现就方便了
对于swap就不需要额外的中间变量 或者加减值 异或实现了

例如下方函数示例，Println会自动分隔开参数打空格
111.go

package main

import (
	"fmt"
)

func swap(x string, y string) (string, string) {
	return y, x
}

func main() {
	var x string = "first string"
	y := "second string"
	fmt.Println(x, y)
	fmt.Println(swap(x, y))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

---

5、函数命名返回值

---

可以对返回的值进行命名 但是这个就以为这是声明在函数顶部的变量
之后则是可以对其赋值

返回值也可以直接return 这个效果就是返回了返回值中定义的变量

111.go

package main

import (
	"fmt"
)

func swap(x string, y string) (swapy string, swapx string) {
	return y, x
}

func split(sum int) (a, b int) {
	a = sum / 10
	b = sum % 10
	return
}

func main() {
	var x string = "first string"
	y := "second string"
	fmt.Println(x, y)
	fmt.Println(swap(x, y))
	fmt.Println(split(17))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

---

运行效果

---

6、变量声明

---

go-style 声明变量
总结了有三种模式：

var num int（初始化为默认值）
var num int = 10
var num = 10（go语言主动推断类型）
num := 10（go语言推断值 省略var 但是只能在函数内部使用 显示初始化 因为函数外必须以关键字开始）

---

111.go

package main

import (
	"fmt"
)

var a, b, c int
var a1, b1, c1 int = 1, 2, 3

func main() {
	var x = "first string"
	y := "second string"
	var intnum int = 5
	var floatnum = 1.32
	judge := false

	fmt.Println(x)
	fmt.Println(y)
	fmt.Println(intnum)
	fmt.Println(floatnum)
	fmt.Println(judge)
	fmt.Println(a, b, c)
	fmt.Println(a1, b1, c1)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

---

运行效果

---

7、变量的基础类型

---

Go常用的基础类型有
整数类型：(u)int，(u)int8，(u)int16，(u)int32，(u)int64，uintptr(指针)，byte，rune（int32 的别名）（int大小取决于系统位数 32位4字节 64位8字节）
字符(串)类型：byte，string
浮点型：float32，float64
布尔型：bool

---

8、变量的默认值（零值）

---

下面列一下基础类型的全部零值
var i int(0)
var floatnum float64(0)
var boolean bool(false)
var str string(“”)

---

111.go

package main

import (
	"fmt"
)

func main() {
	var intnum int
	var floatnum float64
	var boolean bool
	var str string

	fmt.Println(intnum)
	fmt.Println(floatnum)
	fmt.Println(boolean)
	fmt.Println(str)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

---

运行效果

---

9、变量的类型转换

---

go语言的类型转换风格和c语言是相同的
只不过go语言不支持隐式类型转换 隐式类型转换无法进行正常编译

类似于c语言中的强制类型转换

---

111.go

package main

import (
	"fmt"
)

func main() {
	var intnum int = 10
	var floatnum float64 = float64(intnum)
	var tmpfloat float64 = 3.141592653
	var toint int = int(tmpfloat)

	fmt.Println(intnum)
	fmt.Println(floatnum)
	fmt.Println(tmpfloat)
	fmt.Println(toint)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

---

---

10、变量的定义类型推导 + 常量定义

---

var int i
j := i

这种情况 j则是i的类型

---

这个则是推导 定义根据后面的推导

i := 42 // int
f := 3.142 // float64
g := 0.867 + 0.5i // complex128

---

常量定义只是用const去取代var

const intnum int = 10
const floatnum float64 = 3.1415926