Go后端开发 – main函数 & 变量 & 常量 & 函数
文章目录
- Go后端开发 -- main函数 & 变量 & 常量 & 函数
- 一、第一个main函数
- 1.创建工程
- 2.main函数解析
- 二、变量声明
- 1.单变量声明
- 2.多变量声明
- 三、常量
- 1.常量的定义
- 2.优雅的常量 iota
- 四、函数
- 1.函数返回多个值
- 2.init函数与import本地导包
- 3.import匿名导包和别名导包
- 4.import导入的包不在同一个路径下
- 5.函数参数
- 5.1.值传递
- 5.2.引用传递(指针传递)
一、第一个main函数
1.创建工程
在$GOPATH/src目录下创建一个hello.go文件：
输入以下代码：
package main //程序的包名
//只要包含main函数的文件，就是main包
//main是主包，与工程文件名没有任何关系
/*
import "fmt" //导入格式化的包
import "time"
*/
//也可以一块导入包，导入多个包建议这种方案
import (
"fmt"
"time"
)
func main() { // 函数的}一定和函数名在一行，否则编译报错
fmt.Println("hello Go!")
time.Sleep(1 * time.Second)
}
终端运行：
go run表示直接编译go语言并执行应用程序，一步完成；
也可以通过go build先编译，然后再执行：
2.main函数解析
- 第一行代码
package main定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。 - 下一行
import "fmt"告诉 Go 编译器这个程序需要使用fmt包（的函数，或其他元素），fmt包实现了格式化 IO（输入/输出）的函数。 - 下一行
func main()是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。
注意：这里面go语言的语法，定义函数的时候，‘{’ 必须和函数名在同一行，不能另起一行。 - 注释，单行注释是最常见的注释形式，你可以在任何地方使用以
//开头的单行注释。多行注释也叫块注释，均已以/*开头，并以*/结尾，且不可以嵌套使用，多行注释一般用于包的文档描述或注释成块的代码片段。 - 下一行
fmt.Println(...)可以将字符串输出到控制台，并在最后自动增加换行字符 \n。 使用 fmt.Print(“hello, world\n”) 可以得到相同的结果。Print和Println这两个函数也支持使用变量，如：fmt.Println(arr)。如果没有特别指定，它们会以默认的打印格式将变量 arr 输出到控制台。 - go语言的语法中，加不加
;都可以，建议不加 - 导入多个包的时候建议以下这种语法：
二、变量声明
1.单变量声明
声明变量的一般形式是使用var关键字；
- 第一种：指定变量类型，声明后若不赋值，使用默认值0。
var v_name v_type
v_name = value
var v_name v_type = value
package main
import "fmt"
func main() {
var a int = 5
fmt.Printf("a = %d\n", a)
}
- 第二种：根据值自行判定变量类型
var v_name = value
package main
import "fmt"
func main() {
var b = 10
fmt.Printf("b = %d\n", b)
}
- 第三种，省略var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误（最常用）
v_name := value
:=表示既初始化，又赋值
package main
import "fmt"
func main() {
//var a int = 5
//var b = 10
a := 10
fmt.Printf("a = %d\n", a)
}
- 全局变量的声明
package main
import "fmt"
var a int = 100
var b = "abc"
// 这种分解的写法,一般用于声明全局变量
var (
c int
d bool
)
func main() {
fmt.Println("a = ", a)
fmt.Println("b = ", b)
}
使用var可以声明全局变量；
package main
import "fmt"
var a int = 100
var b = "abc"
c := 1.2
func main() {
fmt.Println("a = ", a)
fmt.Println("b = ", b)
fmt.Println("c = ", c)
}
使用:=不可以声明全局变量，只能够在函数体内使用；
- 可以使用
%T格式化输出变量的类型
package main
import "fmt"
func main() {
//默认值
var a int
fmt.Printf("a = %d\n", a)
fmt.Printf("type of a = %T\n", a)
var b int = 10
fmt.Printf("b = %d\n", b)
fmt.Printf("type of b = %T\n", b)
var c = "golang"
fmt.Printf("c = %s\n", c)
fmt.Printf("type of c = %T\n", c)
d := 20.15
fmt.Printf("d = %f\n", d)
fmt.Printf("type of d = %T\n", d)
}
2.多变量声明
- 方法一：
var c, d int = 1, 2 - 方法二：
var e, f = 123, "Golang" - 方法三：
g, h := 333, "需要在函数体内实现" - 方法四：
- 可以使用
_来接受赋值，表示赋值被废弃，_不具备读特性
package main
import "fmt"
var x, y int
// 这种分解的写法,一般用于声明全局变量
var (
a int
b bool
)
var c, d int = 1, 2
var e, f = 123, "Golang"
//这种不带声明格式的只能在函数体内声明
//g, h := 123, "需要在func函数体内实现"
func main() {
g, h := 333, "需要在函数体内实现"
//h
fmt.Println(x, y, a, b, c, d, e, f, g, h)
//不能对g变量再次做初始化声明
//g := 400
_, value := 7, 5 实际上7的赋值被废弃，变量 _ 不具备读特性
//fmt.Println(_)
fmt.Println(value)
var (
vv int = 15
cc bool = false
)
fmt.Println(vv, cc)
}
三、常量
1.常量的定义
常量是一个简单值的标识符，在程序运行时，不会被修改的量。
常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。
- 常量的定义格式：
const identifier [type] = value
你可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。
//显式类型定义
const b string = "abc"
//隐式类型定义：
const b = "abc"
例如：
package main
import "fmt"
func main() {
const LENGTH int = 10
const WIDTH int = 5
var area int
const a, b, c = 1, false, "golang"
area = LENGTH * WIDTH
fmt.Println("面积为：", area)
fmt.Println(a, b, c)
}
- 常量还可以用作枚举类型：
const (
UNKNOW = 0
FEMALE = 1
MALE = 2
)
数字 0、1 和 2 分别代表未知性别、女性和男性。
- 常量可以用
len(), cap(), unsafe.Sizeof()常量计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过：
package main
import (
"fmt"
"unsafe"
)
const (
a = "golang"
b = len(a)
c = unsafe.Sizeof(a)
)
func main() {
fmt.Println(a, b, c)
}
unsafe.Sizeof(a)输出的结果是16 。
字符串类型在 go 里是个结构, 包含指向底层数组的指针和长度,这两部分每部分都是 8 个字节，所以字符串类型大小为 16 个字节。
2.优雅的常量 iota
有些概念有名字，并且有时候我们关注这些名字，甚至（特别）是在我们代码中。
const (
CCVisa = "Visa"
CCMasterCard = "MasterCard"
CCAmericanExpress = "American Express"
)
在其他时候，我们仅仅关注能把一个东西与其他的做区分。有些时候一件事没有本质上的意义。比如，我们在一个数据库表中存储产品，我们可能不想以 string 存储他们的分类。我们不关注这个分类是怎样命名的，此外，该名字在市场上一直在变化，我们仅仅关注它们是怎么彼此区分的。
const (
CategoryBooks = 0
CategoryHealth = 1
CategoryClothing = 2
)
使用 0, 1, 和 2 代替，我们也可以选择 17， 43， 和 61。这些值是任意的
在 Go，常量有许多微妙之处。当用好了，可以使得代码非常优雅且易维护的。
自增长
- 在 golang 中，一个方便的习惯就是使用
iota标示符，它简化了常量用于增长数字的定义，给以上相同的值以准确的分类。 - 可以在
const()添加一个关键字iota，只在第一行添加iota，之后的每行的iota都会累加1，第一行的iota默认值是0
const (
CategoryBooks = iota // 0
CategoryHealth // 1
CategoryClothing // 2
)
iota和表达式
iota可以做更多事情，而不仅仅是 increment。更精确地说，iota总是用于 increment，但是它可以用于表达式，在常量中的存储结果值。- 每行的iota都会参与表达式
package main
import (
"fmt"
)
type Allergen int
const (
IgEggs Allergen = 1 << iota // 1 << 0 which is 00000001
IgChocolate // 1 << 1 which is 00000010
IgNuts // 1 << 2 which is 00000100
IgStrawberries // 1 << 3 which is 00001000
IgShellfish // 1 << 4 which is 00010000
)
func main() {
fmt.Println(IgEggs | IgChocolate | IgShellfish)
}
- 这个工作是因为当你在一个const组中仅仅有一个标示符在一行的时候，它将使用增长的iota取得前面的表达式并且再运用它。在 Go 语言的spec中， 这就是所谓的隐性重复最后一个非空的表达式列表.
- 如果你对鸡蛋，巧克力和海鲜过敏，把这些 bits 翻转到 “on” 的位置（从左到右映射 bits）。然后你将得到一个 bit 值
00010011，它对应十进制的 19。
package main
import (
"fmt"
)
type ByteSize float64
const (
_ = iota // ignore first value by assigning to blank identifier
KB ByteSize = 1 << (10 * iota) // 1 << (10 * 1)
MB
GB
TB
PB
EB
ZB
YB
)
func main() {
fmt.Println(KB, MB, GB)
}
- 当你在把两个常量定义在一行的时候会发生什么？
package main
import (
"fmt"
)
const (
Apple, Banana = iota + 1, iota + 2
Cherimoya, Durian
Elderberry, Fig
)
func main() {
fmt.Println(Apple, Banana, Cherimoya, Durian)
}
- 在下一行增长，而不是立即取得它的引用。
- 如果从中间改变表达式，后面的行也会跟着改变
package main
import (
"fmt"
)
const (
a, b = iota + 1, iota + 2
c, d
e, f
g, h = iota * 2, iota * 3
i, j
)
func main() {
fmt.Println("a = ", a, "b = ", b)
fmt.Println("c = ", c, "d = ", d)
fmt.Println("e = ", e, "f = ", f)
fmt.Println("g = ", g, "h = ", h)
fmt.Println("i = ", i, "j = ", j)
}
- iota只能配合const()进行使用，只有在const()中有累加效果
四、函数
1.函数返回多个值
Go函数的定义：
func 函数名(形参1 类型, 形参2 类型, ...) (返回值1类型, 返回值2类型, ...){
// 函数体
return 返回值1， 返回值2
}
例如：
Go 函数可以返回多个值
- 返回值为匿名
package main
import "fmt"
func swap(x, y string) (string, string) {
return y, x
}
func main() {
a, b := swap("golang", "c++")
fmt.Println(a, b)
}
- 返回值有名称
- 有名称的返回值也相当于函数中的形参
- 有名称的返回值需要在函数体中给返回值参数赋值，如果不赋值直接返回值也是可以的
- 没有赋值之前，返回值参数都默认值为0，是作为局部变量来赋值的，作用域为当前函数的{}内
package main
import "fmt"
func prt(a string, b int) (r1 int, r2 int) {
fmt.Println("a = ", a)
fmt.Println("b = ", b)
fmt.Println(r1, r2) // 没赋值之前，r1和r2默认值为0，相当于函数中的形参
//给有名称的返回值变量赋值
r1 = 1000
r2 = 2000
return
}
func main() {
a, b := prt("golang", 123)
fmt.Println(a, b)
}
- 各个参数类型或者各个返回值类型都是一样的，可以放到一起声明类型
func swap(x, y string) (r1, r2 string) {
return y, x
}
2.init函数与import本地导包
- init 函数可在package main中，可在其他package中，可在同一个package中出现多次。
- main 函数只能在package main中。
执行顺序
- golang里面有两个保留的函数：init函数（能够应用于所有的package）和main函数（只能应用于package main）。这两个函数在定义时不能有任何的参数和返回值。
- 虽然一个package里面可以写任意多个init函数，但这无论是对于可读性还是以后的可维护性来说，我们都强烈建议用户在一个package中每个文件只写一个init函数。
- init函数是在主程序开始之前做的一些预处理，如加载配置文件，加载数据库的内容，做环境变量的初始化等；
- go程序会自动调用init()和main()，所以你不需要在任何地方调用这两个函数。每个package中的init函数都是可选的，但package main就必须包含一个main函数。
- 程序的初始化和执行都起始于main包。
- 如果main包还导入了其它的包，那么就会在编译时将它们依次导入。有时一个包会被多个包同时导入，那么它只会被导入一次（例如很多包可能都会用到fmt包，但它只会被导入一次，因为没有必要导入多次）。
- 当一个包被导入时，如果该包还导入了其它的包，那么会先将其它包导入进来，然后再对这些包中的包级常量和变量进行初始化，接着执行init函数（如果有的话），依次类推。
- 等所有被导入的包都加载完毕了，就会开始对main包中的包级常量和变量进行初始化，然后执行main包中的init函数（如果存在的话），最后执行main函数。
- 下图详细地解释了整个执行过程：
例子：
- 代码结构：
- go.mod
module function_go
go 1.20
- Lib1.go
package Initlib1
import "fmt"
// lib1提供的API
func lib1Test() {
fmt.Println("lib1Test()...")
}
func init() {
fmt.Println("lib1")
}
- Lib2.go
package Initlib2
import "fmt"
// lib2提供的API
func lib2Test() {
fmt.Println("lib2Test()...")
}
func init() {
fmt.Println("lib2")
}
- main.go
- 在使用Go Modules导入本地包的时候，在包名的前面需要指定模块名才可以导入
比如上面的go.mod中模块名是function_go，导入包的路径就是function_go/InitLib1 - 在导入了包之后，需要调用包中的方法，可以直接
包名.方法()
- 在使用Go Modules导入本地包的时候，在包名的前面需要指定模块名才可以导入
package main
import (
"function_go/InitLib1"
"function_go/InitLib2"
)
func main() {
InitLib1.Lib1Test()
InitLib2.Lib2Test()
}
- 如果要使用GOPATH机制，在
main.go中使用import导本地包的时候，一定要在包名前加上该包路径相对于GOPATH的路径
运行结果
lib1
lib2
libmain init
libmian main
- 如果在Lib1中导入Lib2包，mian包不导入Lib2
package InitLib1
import (
"fmt"
"goProject/function_go/InitLib2"
)
// lib2提供的API
func lib2Test() {
fmt.Println("lib2Test()...")
}
func init() {
fmt.Println("lib1")
}
输出结果：
lib2
lib1
libmain init
libmian main
main包以及Lib1包都导入了Lib2，但是只出现一次，并且最先输出
-
说明如果一个包会被多个包同时导入，那么它只会被导入一次，而先输出lib2是因为main包中导入Lib1时，Lib1又导入了Lib2，会首先初始化Lib2包的东西
-
如果一个函数名首字母是大写的，说明此函数是对外开放的，如果是小写的，只能在当前包内调用，无法对外开放
3.import匿名导包和别名导包
- 在go中，如果我们导入了一个包，但是没有使用其中的接口，那么编译就会报错；
- 如果我们不想使用包中的接口，但是想导入包执行init函数，我们可以选择匿名导入；
- 在包的路径前加上
_就代表匿名导入
package main
import (
_ "function_go/InitLib1" //匿名导包
_ "function_go/InitLib2"
)
func main() {
InitLib1.Lib1Test()
InitLib2.Lib2Test()
}
- 也可以给导入的包起别名
package main
import (
"function_go/InitLib1"
myLib2 "function_go/InitLib2" //给包起别名
)
func main() {
InitLib1.Lib1Test()
myLib2.Lib2Test()
}
- 将包中的内容全部导入当前包
在要导入的包前加.，表示将包中所有内容导入当前包，可以直接调用方法，不需要在前面指定包名
package main
import (
"goProject/function_go/InitLib1"
. "goProject/function_go/InitLib2" //将改包所有的方法导入main包
)
func main() {
InitLib1.Lib1Test()
Lib2Test() //直接调用方法
}
4.import导入的包不在同一个路径下
项目结构：
fun_go和function_go是两个不同的模块，如果要在fun_go下的main.go中导入function_go/InitLib1包，也需要指定模块名：
package main
import (
"fmt"
"function_go/InitLib1" // 指定模块名
)
func main() {
InitLib1.Lib1Test()
fmt.Println("go")
}
5.函数参数
函数如果使用参数，该变量可称为函数的形参；形参就像定义在函数体内的局部变量。
调用函数，可以通过两种方式来传递参数：
5.1.值传递
值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。
以下定义了 swap() 函数：
package main
import "fmt"
func swap(x, y int) {
var temp int
temp = x
x = y
y = temp
}
func main() {
a := 100
b := 200
fmt.Println("交换前a的值：", a)
fmt.Println("交换前b的值：", b)
swap(a, b)
fmt.Println("交换后a的值：", a)
fmt.Println("交换后b的值：", b)
}
5.2.引用传递(指针传递)
指针
- Go 语言的取地址符是
&，放到一个变量前使用就会返回相应变量的内存地址。
package main
import "fmt"
func main() {
a := 100
fmt.Println(&a)
}
- 引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。
package main
import "fmt"
func swap(x, y *int) {
var temp int
temp = *x
*x = *y
*y = temp
}
func main() {
a := 100
b := 200
fmt.Println("交换前a的值：", a)
fmt.Println("交换前b的值：", b)
swap(&a, &b)
fmt.Println("交换后a的值：", a)
fmt.Println("交换后b的值：", b)
}
- golang可以支持二级指针
package main
import "fmt"
func main() {
a := 100
var p *int = &a
var pp **int = &p
fmt.Println(&p)
fmt.Println(pp)
}
