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

Go后端开发 – main函数 & 变量 & 常量 & 函数

---

一、第一个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 mainimport "fmt"func main() {var a int = 5fmt.Printf("a = %d\n", a)
}

• 第二种：根据值自行判定变量类型
  var v_name = value

package mainimport "fmt"func main() {var b = 10fmt.Printf("b = %d\n", b)
}

• 第三种，省略var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误（最常用）
  v_name := value
:=表示既初始化，又赋值

package mainimport "fmt"func main() {//var a int = 5//var b = 10a := 10fmt.Printf("a = %d\n", a)
}

• 全局变量的声明

package mainimport "fmt"var a int = 100
var b = "abc"// 这种分解的写法,一般用于声明全局变量
var (c intd bool
)func main() {fmt.Println("a = ", a)fmt.Println("b = ", b)
}

使用var可以声明全局变量；

package mainimport "fmt"var a int = 100
var b = "abc"c := 1.2func main() {fmt.Println("a = ", a)fmt.Println("b = ", b)fmt.Println("c = ", c)
}

使用:=不可以声明全局变量，只能够在函数体内使用；

• 可以使用%T格式化输出变量的类型

package mainimport "fmt"func main() {//默认值var a intfmt.Printf("a = %d\n", a)fmt.Printf("type of a = %T\n", a)var b int = 10fmt.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.15fmt.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 mainimport "fmt"var x, y int// 这种分解的写法,一般用于声明全局变量
var (a intb bool
)var c, d int = 1, 2
var e, f = 123, "Golang"//这种不带声明格式的只能在函数体内声明
//g, h := 123, "需要在func函数体内实现"func main() {g, h := 333, "需要在函数体内实现"//hfmt.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  = 15cc bool = false)fmt.Println(vv, cc)
}

三、常量

1.常量的定义

常量是一个简单值的标识符，在程序运行时，不会被修改的量。
常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

• 常量的定义格式：
  const identifier [type] = value
  你可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。

//显式类型定义
const b string = "abc"
//隐式类型定义：
const b = "abc"

例如：

package mainimport "fmt"func main() {const LENGTH int = 10const WIDTH int = 5var area intconst a, b, c = 1, false, "golang"area = LENGTH * WIDTHfmt.Println("面积为：", area)fmt.Println(a, b, c)
}

• 常量还可以用作枚举类型：

const (UNKNOW = 0FEMALE = 1MALE   = 2
)

数字 0、1 和 2 分别代表未知性别、女性和男性。

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

package mainimport ("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    = 0CategoryHealth   = 1CategoryClothing = 2
)

使用 0, 1, 和 2 代替，我们也可以选择 17， 43， 和 61。这些值是任意的
在 Go，常量有许多微妙之处。当用好了，可以使得代码非常优雅且易维护的。

自增长

• 在 golang 中，一个方便的习惯就是使用iota标示符，它简化了常量用于增长数字的定义，给以上相同的值以准确的分类。
• 可以在const()添加一个关键字iota，只在第一行添加iota，之后的每行的iota都会累加1，第一行的iota默认值是0

const (CategoryBooks    = iota // 0CategoryHealth          // 1CategoryClothing        // 2
)

iota和表达式

• iota可以做更多事情，而不仅仅是 increment。更精确地说，iota总是用于 increment，但是它可以用于表达式，在常量中的存储结果值。
• 每行的iota都会参与表达式

package mainimport ("fmt"
)type Allergen intconst (IgEggs         Allergen = 1 << iota // 1 << 0 which is 00000001IgChocolate                         // 1 << 1 which is 00000010IgNuts                              // 1 << 2 which is 00000100IgStrawberries                      // 1 << 3 which is 00001000IgShellfish                         // 1 << 4 which is 00010000
)func main() {fmt.Println(IgEggs | IgChocolate | IgShellfish)
}

• 这个工作是因为当你在一个const组中仅仅有一个标示符在一行的时候，它将使用增长的iota取得前面的表达式并且再运用它。在 Go 语言的spec中， 这就是所谓的隐性重复最后一个非空的表达式列表.
• 如果你对鸡蛋，巧克力和海鲜过敏，把这些 bits 翻转到 “on” 的位置（从左到右映射 bits）。然后你将得到一个 bit 值00010011，它对应十进制的 19。
  

package mainimport ("fmt"
)type ByteSize float64const (_           = iota             // ignore first value by assigning to blank identifierKB ByteSize = 1 << (10 * iota) // 1 << (10 * 1)MBGBTBPBEBZBYB
)func main() {fmt.Println(KB, MB, GB)
}

• 当你在把两个常量定义在一行的时候会发生什么？

package mainimport ("fmt"
)const (Apple, Banana = iota + 1, iota + 2Cherimoya, DurianElderberry, Fig
)func main() {fmt.Println(Apple, Banana, Cherimoya, Durian)
}

• 在下一行增长，而不是立即取得它的引用。
  
• 如果从中间改变表达式，后面的行也会跟着改变

package mainimport ("fmt"
)const (a, b = iota + 1, iota + 2c, de, fg, h = iota * 2, iota * 3i, 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 mainimport "fmt"func swap(x, y string) (string, string) {return y, x
}func main() {a, b := swap("golang", "c++")fmt.Println(a, b)
}

• 返回值有名称
  • 有名称的返回值也相当于函数中的形参
  • 有名称的返回值需要在函数体中给返回值参数赋值，如果不赋值直接返回值也是可以的
  • 没有赋值之前，返回值参数都默认值为0，是作为局部变量来赋值的，作用域为当前函数的{}内

package mainimport "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 = 1000r2 = 2000return
}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_gogo 1.20

• Lib1.go

package Initlib1import "fmt"// lib1提供的API
func lib1Test() {fmt.Println("lib1Test()...")
}func init() {fmt.Println("lib1")
}

• Lib2.go

package Initlib2import "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 mainimport ("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 InitLib1import ("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 mainimport (_ "function_go/InitLib1" //匿名导包_ "function_go/InitLib2"
)func main() {InitLib1.Lib1Test()InitLib2.Lib2Test()
}

• 也可以给导入的包起别名

package mainimport ("function_go/InitLib1"myLib2 "function_go/InitLib2" //给包起别名
)func main() {InitLib1.Lib1Test()myLib2.Lib2Test()
}

• 将包中的内容全部导入当前包
  在要导入的包前加. ，表示将包中所有内容导入当前包，可以直接调用方法，不需要在前面指定包名

package mainimport ("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 mainimport ("fmt""function_go/InitLib1" // 指定模块名
)func main() {InitLib1.Lib1Test()fmt.Println("go")
}

5.函数参数

函数如果使用参数，该变量可称为函数的形参；形参就像定义在函数体内的局部变量。
调用函数，可以通过两种方式来传递参数：

5.1.值传递

值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。
以下定义了 swap() 函数：

package mainimport "fmt"func swap(x, y int) {var temp inttemp = xx = yy = temp
}func main() {a := 100b := 200fmt.Println("交换前a的值：", a)fmt.Println("交换前b的值：", b)swap(a, b)fmt.Println("交换后a的值：", a)fmt.Println("交换后b的值：", b)
}

5.2.引用传递(指针传递)

指针

• Go 语言的取地址符是&，放到一个变量前使用就会返回相应变量的内存地址。

package mainimport "fmt"func main() {a := 100fmt.Println(&a)
}

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

package mainimport "fmt"func swap(x, y *int) {var temp inttemp = *x*x = *y*y = temp
}func main() {a := 100b := 200fmt.Println("交换前a的值：", a)fmt.Println("交换前b的值：", b)swap(&a, &b)fmt.Println("交换后a的值：", a)fmt.Println("交换后b的值：", b)
}

• golang可以支持二级指针

package mainimport "fmt"func main() {a := 100var p *int = &avar pp **int = &pfmt.Println(&p)fmt.Println(pp)
}