变量与常量

目录

• 标识符与关键字
• 变量声明
• 变量的初始化
• 类型推导
• 短边量声明
• 匿名变量
• 常量
• iota
• 几个常见的iota示例

标识符与关键字

• 标识符

  在编程语言中标识符就是程序员定义的具有特殊意义的词，比如变量名、常量名、函数名等等。

  Go语言中标识符由字母数字_(下划线)组成,并且只能以字母和_开头。

  跟python起名字一样

• 关键字

  关键字是指编程语言中预习定义好的具有特殊含义的标识符。关键字和保留下来都不建议做变量名

  GO语言中25关键字

  

变量声明

GO语言的变量声明格式为:

var 变量名  变量类型

变量名声明以关键var开头，变量类型放在变量的后面,行尾无需加括号。

• 批量声明

  每个声明就需要写var关键字会比较繁琐,go语言中还支持批量声明:

  var(
  	a int
  	b string
  	c bool
  	d float32
  )
  

  

变量的初始化

Go语言在声明变量的时候,会自动对变量的内存区域进行初始化操作。每个变量会被初始化成其类名的默认值，

整型和浮点型默认值为 0.

字符串变量的默认值为 空字符串

布尔类型默认为 false

切片、函数、指针变量的默认值为nil

当然我们也可以在声明变量的时候为其指定初始值。变量初始化标准格式如下:

var 变量名 类型 = 数据

或者一次初始化多个值

var name, age = "jason", 20

类型推导

有时候我们会将变量的类型省略掉，这个时候编译器会根据等号右边的值来推导变量的类型完成初始化。

var name, age, price = "jason", 20, 20.19

短边量声明

在函数内部，可以使用更简洁的 :=方式声明并初始化变量

短变量不能在全局使用

var a = 100
func main(){
    b := 200
    fmt.Println(a, b)
}

匿名变量

在使多重赋值的时候，如果想要忽略某个值， 可以使用匿名变量(anonymous variable).匿名变量用一个下环线_表示,例如:

func foo() (int, string, string) {
	return 10, "Jason", "tony"
}
func main() {
	x, _, b := foo()
	// _, y := foo()  错误 ， day01\变量1.go:36:7: assignment mismatch: 2 variables but foo returns 3 values
	fmt.Printf("b: %v\n", b)
	fmt.Println("x=", x)
	// fmt.Println("y=", y)
}

匿名变量不占用名称空间，不会分配内存，所以匿名变量之间不存在重复声明。（在Lua等编程语言里，匿名变量也被叫哑元变量。)

注意事项

1. 函数外的每个语句必须以关键字开始(var, const, func等)
2. :=不能再函数外使用。
3. _多用于占位,表示忽略值

常量

相对于变量,常量是恒定不变的值,多用于程序运行期间不会改变的那些之。常量的声明和变量声明非常类似，只是把var换成const，常量在定义的时候必须赋值

	const pi = 3.1415
	const e = 2.7182
	pi = 100
	// fmt.Printf("pi: %v\n", pi) //  cannot assign to pi (declared const)  无法赋值给变量pi

常量不能更改，更改则报错

用 const关键字必须赋值 不赋值报错

	const (
		pi int    = 100
		e  string = ""
	)
	fmt.Printf("pi: %v\n", pi)
	fmt.Printf("e: %v\n", e)

	const (
		pi = 100
		e  = ""
	)

但是你给第一个赋值了，后面的可以不用赋值

	const (
		pi = 100
		e
	)
	fmt.Printf("pi: %v\n", pi)
	fmt.Printf("e: %v\n", e)

}

iota

iota是go语言的常量计数器,只能在常量的表达式中使用

iota在const关键字出现时将被重置为0。const中每增加一行常量声明将使iota计数一次(iota可以理解为const语块的索引)。使用iota能简化定义,在定义枚举时很有用。

	const (
		n1 = iota
		n2 = iota
		n3
		n4
	)
	fmt.Printf("n1: %v\n", n1)
	fmt.Printf("n2: %v\n", n2)
	fmt.Printf("n3: %v\n", n3)
	fmt.Printf("n4: %v\n", n4)

几个常见的iota示例

使用_跳过某些值

const(
	n1 = iota
 	n2
 	_
 	n3
)

iota声明中间插队

const(
	n1 = iota
	n2 = 100
	n3
	n4

)
fmt.Println(n1)
fmt.Println(n2)
fmt.Println(n3)
fmt.Println(n4)

const(
	n1 = iota
	n2 = 100
	n3 = iota
	n4

)
fmt.Println(n1)
fmt.Println(n2)
fmt.Println(n3)
fmt.Println(n4)

定义数量级(这里的<<表示左移操作, 1<<10表示将 1 的二进制表示向左移10位,也就是由 1变成了10000000000，也就是10进制的1024)。同理2<<2表示将2的二进制表示往左移 2 位，也就是由10变成了1000,也就是十进制的8

const(
	_ = iota
    KB = 1 << (10 * iota)
    MB = 1 << (10 * iota)
    GB = 1 << (10 * iota)
	 TB = 1 << (10 * iota)
	 PB = 1 << (10 * iota)
)

多个iota定义在一行

	const (
		a, b = iota + 1, iota + 1
		c, d // 必须要与上面一样 定义两个常量 要不然报错
		e, f
	)
	fmt.Println(a, b)
	fmt.Println(c, d)
	fmt.Println(e, f)

可以把iota当成const的索引值

第一行 0 + 1

第二行 1 + 1

第三行 2 + 2