Task03: 变量、常量、枚举（1天） 组队学习 Go编程语言

变量 、常量、枚举

变量

变量，计算机语言能存储计算结果或表示值的抽象概念。可以通过变量名访问，变量名由字母、数字、下划线组成，其中首个字符不能为数字。

声明变量的一般形式是使用 var 关键字：

var identifier type
var identifier1, identifier2 type

GO语言的变量声明方式与C和C++语言有明显的不同。对于纯粹的变量声明，GO语言引入了关键字var，而类型信息放在变量名之后，示例如下：

var  v1 int //整型
	var v2 stirng //字符型
	var v3[10]int  //数组
	var v4 []int //数组切片
	var v5 struct{
		f int
	}
	var v6 *int //指针
	var v7 map[string]int //map key为string类型 value为int类型
	var v8 func(a int) int

变量语句声明不需要使用分号作为结束符。与其他面向对象语言相比，GO语言摒弃了语句必须以分号作为语句结束标记的习惯。

var关键字的另一种用法是可以将若干个需要声明的变量放在一起，免得程序员需要重复写var关键字。

var{
		v1 int
		v2 stinrg
	}

多变量声明：
//类型相同多个变量, 非全局变量

var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3

var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型，自动推断
vname1, vname2, vname3 := v1, v2, v3 // 出现在 := 左侧的变量不能是已经被声明过的，否则会导致编译错误

// 这种因式分解关键字的写法一般用于声明全局变量
var (
  vname1 v_type1
  vname2 v_type2
)

注意:

“：=” 赋值操作符,高效创建新变量，初始化声明：a := 50 或 b := false，a 和 b 的类型（int 和 bool）将由编译器自动推断。
这是使用变量的首选形式，但是它只能被用在函数体内，而不可以用于全局变量的声明与赋值。
在相同的代码块中，我们不可以再次对于相同名称的变量使用初始化声明，但可以赋值；
声明了一个局部变量却没有在相同的代码块中使用它，同样会得到编译错误
全局变量可以声明但不用。
_ 实际上是一个只写变量，你不能得到它的值。这样做是因为 Go 语言中必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值。

变量赋值

在Go语法中，变量初始化和变量赋值是两个不同的概念。下面为声明一个变量之后的赋值过程:

var v4 int
	v4 = 111

Go语言的变量赋值与多数语言一致，但Go语言中提供了多重赋值功能,比如下面这个交换i和j变量的语句：

i, j = j, i

Go 语言中 = 和 := 有什么区别

// = 使用必须使用先var声明例如：
var a
a=100
//或
var b = 100
//或
var c int = 100

// := 是声明并赋值，并且系统自动推断类型，不需要var关键字
d := 100

常量

常量是一个简单值的标识符，在程序运行时，不会被修改的量。数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。 常量的定义格式：（省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。）

const identifier [type] = value
const b = "abc"

多个相同类型的声明可以简写为：

const c_name1, c_name2 = value1, value2

常量定义上可以分为显式和隐式：

显式：

const identifier [type] = value

隐式：

const identifier = value  // 通常叫无类型常量

特殊常量：iota
iota在const关键字出现时被重置为0
const体中每新增一行常量声明将使iota计数一次（即加1）

const (
		n1 = iota //0
		n2        //1
		n3        //2
		n4        //3
	)

iota常见使用方法：
跳值使用法

const (
		n1 = iota //0
		n2        //1
		_
		n4        //3
	)

插队使用法

const (
		n1 = iota //0
		n2 = 100  //100
		n3 = iota //2
		n4        //3
	)
const n5 = iota //0

单行使用法

const n = iota //0	

表达式隐式使用法

const (
		a, b = iota + 1, iota + 2 //1,2
		c, d                      //2,3
		e, f                      //3,4
	)

iota 表示从 0 开始自动加 1，所以 i=1<<0, j=3<<1（<< 表示左移的意思），即：i=1, j=6，这没问题，关键在 k 和 l，从输出结果看 k=3<<2，l=3<<3。

简单表述:

i=1：左移 0 位,不变仍为 1;
j=3：左移 1 位,变为二进制 110, 即 6; k=3：左移 2 位,变为二进制
1100, 即 12;
l=3：左移 3 位,变为二进制 11000,即 24。 注：<<n==*(2^n)。 ```

枚举

枚举，将变量的值一一列举出来，变量只限于列举出来的值的范围内取值。Go语言中没有枚举这种数据类型的，但是可以使用const配合iota模式来实现

1 、普通枚举

const (
	a = 0
	b = 1
	c = 2
	d = 3
)

const (
	 cpp = 0
	 java = 1
	 python = 2
	 golang = 3
)

2、 自增枚举

*** iota只能用于常量表达式
它默认开始值是0，const中每增加一行加1,同行值相同

fmt.Println(iota)  //undefined: iota
// 它默认开始值是0，const中每增加一行加1
const (
	a = iota //0
	c        //1
	d        //2
)

每次 const 出现时，都会让 iota 初始化为0

const d = iota    // a=0
const (
	  e = iota     //b=0
	  f            //c=1
)

*** 如果中断iota，必须显式恢复！！！

const ( 

    Low = iota    //0

    Medium        //1

    High = 100   //100

    Super        //100

    Band = iota  //4

)

*** 如果是同一行,值都一样

const (
i          = iota
j1, j2, j3 = iota, iota, iota
k          = iota
)

*** 可跳过的值

const (
		k1 = iota // 0
		k2        // 1
		_         //2
		_         //3
		k3       // 4
	)

*** 中间插入一个值

const (
	Sun = iota //Sun = 0
	Mon        // Mon = 1
	Tue = 7    //7
	Thu = iota // 3
	Fri        //4
)

*** 若中间中断iota，必须显式恢复。

const (
  a = iota    //0
  b           //1
  c = 100     //100
  d           //100
  e = iota    //4
)