Golang变量&常量 标识符&关键字

变量与常量

变量（Variable）

变量表示内存中的一个存储区域，该区域有自己的名称(变量名)和类型(数据类型)。

方法 1
    var a int       //声明          声明后若不赋值，使用默认值
    a = 10          //赋值
    fmt.Println(a)  //使用

方法 2
    var a = 10      //声明并赋值    根据值自行判定数据类型（类型推导）
    fmt.Println(a)  //使用  

方法 3
    a := 10         //声明并赋值    “:=” 方式赋值时，必须是一个没有声明过的变量，否则会导致编译错误 no new variables on left side of :=
    fmt.Println(a)  //使用

golang 提供多变量声明与赋值

//一次性声明多个全局变量[在go中函数外部定义变量就是全局变量]
方式一：
    var a = 1
    var b = 2
    fmt.Println(a, b) 
 
方式二：
    var (
        a    = 1
        b    = 2
    )
    fmt.Println(a, b) 

方式三：
    var a, b = 1, 2
	fmt.Println(a, b)

方法四：
    a, b := 1, 2
	fmt.Println(a, b)

匿名变量（anonymous variable）

在使用多重赋值时，如果不需要在左值中接收变量，可以使用匿名变量
匿名变量的表现是一个下画线_，使用匿名变量时，只需要在变量声明的地方使用下画线替换即可。
匿名变量不占用命名空间，不会分配内存。匿名变量与匿名变量之间也不会因为多次声明而无法使用。

提示：在 Lua 等编程语言里，匿名变量也被叫做哑元变量。

    func GetData() (int, int) {
        return 100, 200
    }
    a, _ := GetData()
    _, b := GetData()
    fmt.Println(a, b)

常量（constant）

golang中，常量是指编译期间运算得出且不可改变的值。
golang常量定义的关键字为const。
常量中的数据类型只能是布尔型、数字型(整数型、浮点型和复数)和字符串型。

    // 定义单个常量
    const Pi float64 = 3.14159265358979323846

    // 定义多个常量
    const (
        Size int64 = 1024
        Eof  int64 = -1
    )

golang常量定义可以限定常量类型，也可以不限定。如果常量定义时没有限定类型，那么它与字面常量一样，是一个无类型常量。

    // 定义单个常量
    const Pi = 3.14159265358979323846 // 无类型浮点常量

    // 定义多个常量
    const (
        Size = 1024 // 无类型整型常量
        Eof  = -1   // 无类型整型常量
    )

无论是变量还是常量，不同类型的都不能显式的声明在一行:

    var a int, b float32 = 1, 2.4   //编译器不通过
    const c int, d float32 = 3, 4.4 //编译器不通过
    const c, d float32 = 3, 4 //编译通过(此时c和d都是float32类型)
    const c, d = 3, 4.4  //编译通过(此时c是int类型，d是float64类型)

当我们定义常量时，如果多个常量的值相同，后面的常量可以直接不赋值，默认等同于上面已赋值的常量的值

package main

import "fmt"
const (
    a = "itbsl"
    c
    d
)
func main() {
    fmt.Println(a, c, d)
}

结果

itbsl itbsl itbsl

我们可以通过reflect.Typeof(变量名)打印变量或常量的类型

常量可以用len()、cap()、unsafe.Sizeof()常量计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不通过，因为在编译期间自定义函数均属于未知，因此无法用于常量的赋值

golang常量定义的右值可以是一个在编译期运算的常量表达式，这与c语言中宏的性质是一样的。

    const Mask = 1 << 3            // correct
    const Path = os.Getenv("PATH") // incorrect : const initializer os.Getenv("PATH") is not a constant

字面常量（literal）

字面常量（literal），是指程序中硬编码的常量。
golang中字面常量是无类型的，只要该字面常量在相应类型的值域范围内，就可作为该类型的常量。

预定义常量

golang预定义了这些常量：true、false和iota

• true和false

预定义常量true和false所属的基础类型为bool

• iota

预定义常量iota所属的基础类型为int
iota可认为是一个可被编译器修改的常量：在每一个const关键字出现时值重置为0，然后在下一个const出现之前，每出现一次iota，其所代表的数字会自动增1
如果两个const赋值语句的表达式一样，那么可以省略后一个赋值表达式

枚举

golang并不支持众多其他语言中支持的enum关键字。
在golang中定义枚举值的方式：在const后跟一对圆括号的方式定义一组常量。

标识符与关键字

标识符

Golang对各种变量、方法、函数等命名时使用的字符序列成为标识符

Go中函数、变量、常量、类型、语句标签和包的名称遵循一个简单的规则：名称的开头是一个字母(Unicode中的字符即可)或下划线，后面可以跟任意数量的字符、数字和下划线，并区分大小写。

如果一个实体在函数中声名，她只在函数局部有效。如果在函数外声明，它将对包里面的所有源文件可见。实体第一个字母的大小写决定其可见性是否跨包。如果名称以大写字母开头，它是导出的，意味着它对包外是可见和可访问的，可以被自己包之外的其他程序所引用，像fmt包中的Printf。包名总是由小写字母组成。

包名：保持package的名字和目录保持一致，尽量采取有意义的包名，简短、有意义，不要和标准库冲突
变量名，函数名，常量名：尽量使用驼峰法
首字母大写可被其他包访问（类似Public），首字母小写只能在本包内使用（类似Private）

关键字

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

预定义标识符

另外，还有36个内置的预声明的常量、类型和函数:(还有一种说法叫做预定义标识符)

• 常量:

true            false            iota            nil

• 类型:

int        int8        int16        int32        int64
uint       uint8       uint16       uint32       uint64      uintptr
float32    float64     complex64    complex128
bool       byte        rune         string       error

• 函数:

make            len            cap            new            append           copy       
close           delete         complex        real           imag             panic        
recover