Go语言变量与常量

Go语言变量

变量是一个数学定义，它是一个符号，表示某一个事物的取值。在编程语言里，它表示计算机能表示的抽象值概念或者说是计算结果。变量的体现在它的实际值可能在不断地变动。

Go语言变量由数字、大小写字母、下划线组成，但首字母不能是数字。这一点同其他语言。

Go语言标准的变量声明使用var关键字：

var variable type

Go语言也允许一次性声明多个同类型变量：

var variable1, variable2 type

Go语言一共支持三种变量声明：

1. 明确指定变量类型，如果变量未经初始化，则默认赋值为零值。
2. 根据赋值自行判定变量类型。
3. 省略var(:= 左边如果不是新的变量，会报编译错误)

明确指定变量类型

var vname type
vname = value

实例

package main

import "fmt"

func main() {
	var a, b, c int = 1, 2, 3
	fmt.Println(a, b, c)

	var v1 string
	v1 = "Steve"
	fmt.Println(v1)

	var v2 string
	fmt.Println(v2)

	var v3 int
	fmt.Println(v3)

	var v4 float32
	fmt.Println(v4)

	var v5 bool
	fmt.Println(v5)

}


// 1 2 3
// Steve
// 
// 0
// 0
// false
//

零值：

• 数值类型（包括complex64/128）为 0

• 布尔类型为 false

• 字符串为 “”（空字符串）

• 以下几种类型为 nil：

var a *int // 指针
var a []int // 数组名
var a map[string] int // map
var a chan int // chan
var a func(string) int // 函数
var a error // error是接口

根据赋值自行判定变量类型

var vname = value

实例

package main
import "fmt"
func main() {
    var v = true
    fmt.Println(v)
}

// true

省略var转而使用:=

vname = value

实例

package main
import "fmt"
func main() {
    name := "Steve" // 等价于var name string = "Steve"

    fmt.Println(name)
}

// Steve

在变量初始化的时候可以省略变量的类型由系统自动推断，这使得声明语句里的var关键字有些多余，因而可以使用:=来隐式指定这是一个变量声明。

使用a := 1这种类型的声明时，a的类型将由编译器自动推断，但是这种类型的声明只能用于函数体内部，而不能用于全局变量的声明或赋值。

使用:=(数学意义为定义为)操作符可以高效地创建一个新的变量，这被称作初始化声明。

Go语言常量

常量与变量的定义相对应，它也表示抽象化的值概念，但它指向的数值一经定义后就不能再被修改。

Go语言中常量的数据类型只能是布尔型、数字型(整型、浮点型和复数)和字符串类型，而不能是其他类型。

常量的定义格式如下：

const cname type = value

同样可以省略类型说明符，因为编译器可以自行推断。

• 显式类型定义

const b string = "abc"

• 隐式类型定义

const b = "abc"

Go语言没有枚举类型，可以使用常量来实现枚举：

const (
	Low = 0
	Mid = 1
	High = 2
)

常量可以用len()(元素个数), cap()(数组切片分配的空间大小), unsafe.Sizeof()(常量占据的空间大小，以Byte为单位)函数计算常量的相关信息。但常量表达式中的函数必须是内置函数，否则编译报错。

实例：

package main

import "unsafe"

const (
	name = "Steve"
	length = len(name)
	size = unsafe.Sizeof(name)
)

func main() {
	println(name, length, size)
}

// Steve 5 16

iota

iota英文原意微量; 极少量。注意不是itoa，itoa指的是整型转字符串。

iota是Go语言所引入的一个特殊常量，它特殊之处在于它的值可以被编译器修改。(iota本身代表一个常量，而不是变量，参见下面的任何一个例子)

iota在const关键字出现时将被重置为0，而后在const中每新增一行赋值为iota的常量声明将使iota计数一次。

iota可用于递增枚举

const (
	a = iota // 0
	b = iota // 1
	c = iota // 2
)

可以简写为

const (
	a = iota
	b
	c
)

实例：

package main

import (
	"fmt"
)

func main() {
	const (
		a = iota    // iota = 0
 		b           // iota = 1
		c           // iota = 2
		d = "Steve" // iota = 3
		e           // iota = 4
		f           // iota = 5
		g = 10      // iota = 6
		h           // iota = 7
		i           // iota = 8
		j = iota    // iota = 9
		k           // iota = 10
		l           // iota = 11
	)
	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)
	fmt.Println(d)
	fmt.Println(e)
	fmt.Println(f)
	fmt.Println(g)
	fmt.Println(h)
	fmt.Println(i)
	fmt.Println(j)
	fmt.Println(k)
	fmt.Println(l)
}

0
1
2
Steve
Steve
Steve
10
10
10
9
10
11

该例说明，即使常量不是声明为iota，iota的值也会自增。

下面再看一个实例

package main

import "fmt"
const (
	i=1<<iota       // 1 << 0 = 1
	j=1<<iota       // 1 << 1 = 2
	k               // 1 << 2 = 4
	l               // 1 << 3 = 8
	m = 2 << iota   // 2 << 4 = 32
	n               // 2 << 5 = 64
	o               // 2 << 6 = 128
)

func main() {
	fmt.Println("i=",i)
	fmt.Println("j=",j)
	fmt.Println("k=",k)
	fmt.Println("l=",l)
	fmt.Println("m=",m)
	fmt.Println("n=",n)
	fmt.Println("o=",o)
}

// i= 1
// j= 2
// k= 4
// l= 8
// m= 32
// n= 64
// o= 128

该例说明，iota在为常量赋值时，它只会自增；而省略了运算符的写法时，常量会按照相同运算符运行，但作为操作数的iota已自增1。