Go后端开发 -- main函数变量常量函数

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
- 在导入了包之后，需要调用包中的方法，可以直接包名.方法()

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)
}

在这里插入图片描述