Go后端开发 -- Golang语法

2024-01-02 18:05:18

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 mainpackage 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函数
  • 下图详细地解释了整个执行过程:
    请添加图片描述

例子:

  • 代码结构:
    在这里插入图片描述
  • 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
package main

import (
	"goProject/function_go/InitLib1"
	"goProject/function_go/InitLib2"
)

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

func main() {
	InitLib1.Lib1Test()
	InitLib2.Lib2Test()
}
  • 也可以给导入的包起别名
package main

import (
	"goProject/function_go/InitLib1"
	myLib2 "goProject/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.函数参数

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

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

在这里插入图片描述

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

在这里插入图片描述

文章来源:https://blog.csdn.net/kissland96166/article/details/135107717
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。