Golang 变量与常量｜Go主题月

变量

go 语言的变量声明和大多数语言相似，经过 var 关键字声明变量，只是 go 语言做为静态类型语言，声明变量时须要指定其类型。

下面的代码表示声明一个『name』变量，类型为『string』，并给其赋值『"Shenfq"』。

var name string = "Shenfq"
复制代码

若是咱们不进行赋值，这变量会得到一个默认值，下面列举一些 go 语言中的基础类型及其默认值。

类型	默认值
int（int3二、int64……）	0
uint（uint3二、uint64……）	0
float3二、float64	0.0
bool	false
string	""

多变量声明

上面介绍 go 语言经过 var 关键字进行单个变量声明，咱们还能够经过 var 关键字进行多个变量的声明：

// 声明两个变量为同一类型
var firstName, lastName string
// 给两个变量同时赋值
firstName, lastName = "frank", "shen"
复制代码

// 声明两个变量为不一样类型
var (
  age int
	name string
)
// 给两个变量同时赋值
age, name = 25, "Shenfq"
复制代码

类型推导

若是咱们在变量声明阶段，对变量进行了赋值操做，这时候咱们是能够直接省略变量类型的，由于 go 在编译过程当中会依据所赋予的初始值推导出其类型。

var age = 25

fmt.Printf("age 类型为：%T", age) // age 类型为：int
复制代码

var (
  age = 18
  name = "Shenfq"
)
fmt.Printf("age 类型为：%T", age) // age 类型为：int
fmt.Printf("name 类型为：%T", name) // name 类型为：string
复制代码

简短格式

前面介绍了变量声明的时候，若是给定了初始值，go 在编译阶段能够进行类型推导。这种状况，go 提供了一种更简单的声明方式，经过 := 的方式进行变量声明，能够省略 var 关键字。

func main() {
  age := 25
	name := "Shenfq"
}
复制代码

// 也能够进行多个变量同时赋值
func main() {
  age, name := 25, "Shenfq"
}
复制代码

⚠️注意事项一

这种声明方式只能用于函数体内，不能用于全局变量的声明。

// ⚠️ 不能在全局使用这种方式声明变量
age, name := 25, "Shenfq"

// 只能在函数体内使用该方式
func main() {
	age, name := 25, "Shenfq"
	fmt.Printf("age 类型为：%T", age)
	fmt.Printf("name 类型为：%T", name)
}
复制代码

⚠️注意事项二

已经声明过的变量，不能使用 := 的方式进行赋值。

func main() {
  var age int
	age := 25
}
复制代码

已经声明过的变量，只能经过 = 的方式进行赋值。

func main() {
  var age int
	age = 25
}
复制代码

全局变量与局部变量

简单来讲，声明在函数体外的变量为全局变量，声明在函数体内的变量为局部变量。

局部变量若是有声明，没有进行使用，则不会经过编译。

func main() {
  var age int
}
复制代码

可是，全局变量是能够声明而不使用的。

var age int
func main() {
	name := "Shenfq"
	//fmt.Printf("age 类型为：%T", age)
	fmt.Printf("name 类型为：%T", name)
}
复制代码

上面的代码中，咱们声明了 age 全局变量，可是并未使用，能够正常编译。

空白标识符

前面介绍过，go 在变量赋值的时候，能够一次性对多个变量赋值。同时，go 的函数在 return 的时候，也能一次返回多个结果。

func double(num int) (string, int) {
	var err string
	if num < 0 {
		err = "num 不能为负数"
		return err, -1
	}
	result := num * 2
	return err, result
}
复制代码

上面咱们实现了一个 double 函数，该函数接受一个 int 类型的变量（num），返回两个值，一个为异常提示，一个为 num * 2 的结果。若是 num < 0 ， 则提示 num 不能负数。

func main() {
	err, res := double(10)
	if err != "" {
		fmt.Printf(err)
	} else {
		fmt.Printf("结果为：%v", res)
	}
}
复制代码

若是，咱们并不关心 err ，只想执行 double 以后，输出其结果。

func main() {
	err, res := double(10)
	fmt.Printf("结果为：%v", res)
}
复制代码

运行后，咱们会收到一个编译错误，err 变量并未使用。这时候，就须要用到空白标识符（_）。

func main() {
	_, res := double(10)
	fmt.Printf("结果为：%v", res)
}
复制代码

咱们能够经过 _ 来接受 err 值，这个地方的值就会被抛弃掉，就能顺利经过编译。

常量

常量就是不会发生变化的变量，一旦声明就不会改变。go 语言中，常量的声明只须要将变量声明时的 var 关键字替换为 const 关键字。

// 隐式类型定义
const PI = 3.14
// 显式类型定义
const PI2 float  = 3.14
复制代码

多常量声明

与变量相似，常量也支持一次性声明多个。

func main() {
	const (
		PI = 3.14
		PI2 = 3.14
	)
	fmt.Printf("结果为：%v\n", PI)
	fmt.Printf("结果为：%v\n", PI2)
}
复制代码

若是一次声明多个常量时，某个常量若是为进行赋值，默认会与上一个常量的值进行同步。下面代码的运行结果，与上面的代码一致。

func main() {
	const (
		PI = 3.14
		PI2
	)
	fmt.Printf("结果为：%v\n", PI)
	fmt.Printf("结果为：%v\n", PI2)
}
复制代码

特殊常量

有个叫作 iota 的特殊常量，在常量的赋值过程当中，会进行累加。

func main() {
	const (
		A = iota
		B
		C
	)
	fmt.Println(A, B, C) // 0 1 2
}
复制代码

在 iota 累加的过程当中，能够对其进行打断。

func main() {
	const (
		A = iota
		B
		C = "Shenfq"
    D
    E
	)
	fmt.Println(A, B, C, D, E)
}
复制代码

这时候输出的结果为：

这是因为咱们将常量 C 修改成了字符串 "Shenfq"，常量 D、E 会默认与上一条常量保持同步，因此会获得上述结果。可是， iota 是支持从新恢复累加，只须要在指定位置从新赋值一次 iota 便可。

func main() {
	const (
		A = iota
		B
		C = "Shenfq"
		D = iota // 恢复累加状态
		E
	)
	fmt.Println(A, B, C, D, E)
}

复制代码

因为 C 占用了本来 2 的位置，因此 D 恢复后，也是从 3 开始的。

iota 这种累加的特性，特别像咱们在其余语言中使用的枚举，因此在 go 语言中，咱们能够直接将 iota 当作枚举来使用。

type ButtonType int
const (
  Default ButtonType = iota
  Primary
  Warning
  Error
)
复制代码