go语言基础之变量和常量

一、标识符与关键字

（1） 标识符

在编程语言中，标识符是由程序员定义的具有某种特殊意义的符号，如：变量名、常量名、函数名等等。在go语言中，标识符由_(下划线)、字母和数字组成，并且只能由字母或_下划线开头，如：abc、_123、a123。

（2）关键字

关键字是指编程语言中预先定义好的具有特殊含义的标识符。
go语言中有25个关键字：

break	  default		 func	 interface	select
case	  defer		     go		 map		struct
chan	  else		     goto	 package	switch	
const	  fallthrough    if 	 range		type
continue  for			 import  return		var

此外，go语言中还有37个保留字：

constant(4个):  ture  false  iota  nil

Types（19）:    int  int8  int16  int64
                unit  unit8  unit16  unit32  unit64  unitptr
                float32  float64  complex128  complex64
                bool  byte  rune  string  error

Functions（14）:  make  len  cap  new  append copy  close
                  complex  real  imag  panic  recover

---

二、变量（variable）

（1）来历：

程序在运行过程中，数据是保存在内存的。
在代码中，我们可以通过两种方式去内存中访问数据，
第一种是直接引用该数据的内存地址去访问它，
第二种是通过创建变量将数据的内存地址保存起来，然后通过引用变量名去访问它数据。
前者会使得代码的可读性变差并且也容易出错，而后者能把程序中准备使用的每一段数据都赋给一个简短易于记忆的名字，因此其可读性更强。

简言之，变量就是一块存放（可变）数据的内存空间，引用变量名就可以到该内存空间上访问（查找or修改）数据。

（2）变量类型：

不同变量保存的数据的类型可能会不一样。经过半个多世纪的发展，编程语言已经基本形成了一套固定的类型，常见变量的数据类型有：整型、浮点型、布尔型等。
go语言中的每一个变量都有自己的类型，并且变量必须经过声明才能开始使用。

（3）声明：

1. 在使用变量前，大多数程序语言通常都需要先在代码中声明变量，即创建该变量，其目的是事先告诉编译器在程序中使用哪些变量以及这些变量的数据类型和变量的长度，这是因为在编译代码前，编译器需要知道如何给语句开辟内存存储区，这样可以优化程序的执行。
2. 对go语言，go语言中的变量需要声明后才能使用，同一作用域内不支持重复声明。 并且go语言的变量声明后必须使用。
   

1 标准声明

go语言的变量声明格式为：

var 变量名 变量类型

变量声明以关键字var开头，变量类型放在变量名的后面，行尾无需分号（注意与c语言区分）。

var name string  //字符串型变量
var age int      //整型变量
var isOk bool    //整型变量

2 批量声明

每声明一个变量就需要写var关键字会比较繁琐，go语言中还支持批量变量声明，如：

var（
    a string
    b int
    c bool
    d float32
）

3 变量的初始化

**Go语言在声明变量的时候，会自动对变量对应的内存区域进行初始化操作。每个变量会被初始化成其类型的默认值，**例如： 整型和浮点型变量的默认值为0。 字符串变量的默认值为空字符串。 布尔型变量默认为false。 切片、函数、指针变量的默认为nil。
当然，我们也可在声明变量同时为其指定初始值。如下：

var 变量名 类型 = 表达式

如：

var name string = "Q1mi"
var age int = 18

//或者一次初始化多个变量
var name, age = "Q1mi", 20

4. 类型推导

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

var name = "Q1mi" 
var age = 18

5. 短变量声明

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

package main 

import ( 
    "fmt"
) 

// 全局变量m 
var m = 100 

func main() { 
    n := 10 
    m := 200 // 此处声明局部变量m 
    fmt.Println(m, n) 
}

---

三、常量

（1）定义：

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

const pi=3.1415
const e=2.7182

声明pi和e两个常量后，它们的值在整个程序运行过程中就不会改变了。
和变量声明一样，常量也可以批量声明：

const （
    pi=3.1415
    e=2.7182
）

const同时声明多个常量时，如果省略了值则表示和上面一行的值相同。 例如：

const (
    n1 = 100
    n2
    n3
) 

上面示例中，常量n1、n2、n3的值都是100。

（2）iota

1. iota定义：

iota是go语言的常量计数器，只能在常量的表达式中使用。
使用iota能简化定义，在定义枚举是非常有用。
iota在const关键字出现时将被重置为0。const中每新增一行常量声明将使iota计数一次，即iota自动累加1(iota可理解为const语句块中的行索引)，直到下一个const出现，才把iota重新置为0。
自增默认是int类型，可以自行进行显示指定类型
示例：

const (
 one   = iota //iota初始值为0
 two   = iota //自增1
 three = iota //再自增1
)
fmt.Println("one 的值为：", one)
fmt.Println("two 的值为：", two)
fmt.Println("three 的值为：", three)

输出：

one 的值为： 0
two 的值为： 1
three 的值为： 2

可以看到，每一项都自增了1。

在定义时，可以不需要每次都写 iota，结合const的特性，iota除了首项之外，后续常量不显示写 iota，都会自增

const (
 one   = iota //iota初始值为0
 two     
 three
 four
)
fmt.Println("one 的值为：", one)
fmt.Println("two 的值为：", two)
fmt.Println("three 的值为：", three)
fmt.Println("four 的值为：", four)

输出：

one 的值为： 0
two 的值为： 1
three 的值为： 2
four 的值为： 3

2. 几个常见的iota示例：

1. 使用_(下划线)跳过某些值

const（
    n1=iota //0
    n2      //1
    _   
    n3=		//3
）

2. iota声明中插队
如果中断iota自增，则必须显式恢复。且后续自增值按行序递增

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

3.iota参与计算
比如，定义b，kb，mb…等等

const(
    b=1<<(iota*10) // iota初始值为0 ，所以 1 << (0 * 10),其二进制位左移十位
    kb                    // 1 << (1 * 10)
    mb                    // 1 << (2 * 10)
    gb                    // 1 << (3 * 10)
    tb                    // 1 << (4 * 10)
）
    fmt.Println(b,kb,mb,gb,tb)

输出：

1 1024 1048576 1073741824 1099511627776