Go 数据类型篇（一）：变量、作用域、常量和枚举

你可以在代码仓库获取本系列教程源码：nonfu/golang-tutorial。

变量使用入门

变量是几乎所有编程语言中最基本的组成元素。从本质上说，变量相当于是对一块数据存储空间的命名，程序可以通过定义一个变量来申请一块数据存储空间，之后可以通过引用变量名来使用这块存储空间。

由于 Go 语言是强类型静态语言，所以变量声明与赋值方式与 PHP/Python/JavaScript 等动态原因相比有很大的区别。

变量声明和命名规则

对于纯粹的变量声明，Go 语言引入了关键字 var，并且将类型信息放在变量名之后，此外，变量声明语句不需要使用分号作为结束符（实际上，所有的 Go 语句都不需要分号作为结束符，这一点和 JavaScript/Python 很像），比如我们要声明一个类型为 int 的变量 v1，示例如下：

var v1 int 

相应的，PHP 是动态语言（昵称「鸭子类型」），变量在声明时没有类型之说，变量类型是在运行时动态判断的，不需要关键字 var 修饰，而是以 $ 作为变量名前缀实现类似的效果，也没有这种纯粹的声明语句（类的成员变量除外），因为 Go 语言中这种纯粹的声明语句用于定义变量类型，PHP 这么做则毫无意义。

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

var (
    v1 int 
    v2 string
）

此外，Go 语言支持多种数据类型，关于数据类型，学院君将在后续教程中详细介绍，这里先了解下即可：

var v1 int            // 整型
var v2 string         // 字符串
var v3 bool           // 布尔型
var v4 [10]int        // 数组，数组元素类型为整型
var v5 struct {       // 结构体，成员变量 f 的类型为64位浮点型
    f float64
} 
var v6 *int           // 指针，指向整型
var v7 map[string]int   // map（字典），key为字符串类型，value为整型
var v8 func(a int) int  // 函数，参数类型为整型，返回值类型为整型

需要注意的是，变量在声明之后，系统会自动将变量值初始化为对应类型的零值，比如上述 v1 的值为 0，v2 的值空字符串，v3 的值为 false，依次类推，我们打印上述变量的值，可以看到如下输出：

如果变量名包含多个单词，Go 语言变量命名规则遵循驼峰命名法，即首个单词小写，每个新单词的首字母大写，如 userName，但如果你的全局变量希望能够被外部包所使用，则需要将首个单词的首字母也大写。

变量初始化

如果声明变量时想要同时对变量值进行初始化，可以通过以下这些方式：

var v1 int = 10   // 方式一，常规的初始化操作
var v2 = 10       // 方式二，此时变量类型会被编译器自动推导出来
v3 := 10          // 方式三，可以省略 var，编译器可以自动推导出v3的类型

以上三种用法的效果是完全一样的。与第一种用法相比，第三种用法更简捷，推荐用这种方式对变量进行初始化。这里 Go 语言也引入了很多其他语言中没有的运算符 :=，用于明确表达同时对变量进行声明和初始化。

此外我们还看到，对变量同时进行声明和初始化时，指定类型已不再是必需的，Go 编译器可以从初始化表达式的右值推导出该变量应该声明为哪种类型（纯粹的变量声明时可不能省略类型，那样会编译器会报错），这让 Go 语言看起来有点像动态类型语言，但是与 PHP/Python/JavaScript 等动态语言不同的是，这个推导是在编译期做的，而不是运行时，所以 Go 语言还是不折不扣的静态语言。

另外，出现在 := 运算符左侧的变量应该是未声明过的，否则会导致编译错误，比如下面这个写法：

var i int 
i := 2

会导致如下这种编译错误：

no new variables on left side of :=

在 PHP/Python 等动态语言中，由于变量类型是运行时动态判定的，因此变量声明和初始化是一体的，即通过初始化的方式完成变量的声明，类的成员变量除外。

变量赋值与多重赋值

在 Go 语言中，变量初始化和变量赋值是两个不同的概念，变量初始化集变量声明和赋值为一条语句，变量赋值则是先声明变量，再对其进行赋值，初始化只能执行一次，赋值则可以执行多次，下面是变量赋值过程：

var v10 int 
v10 = 123

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

i, j = j, i

在不支持多重赋值的语言中，比如 PHP，交互两个变量的内容需要引入一个中间变量：

$t = $i; $i = $j; $j = $t;

匿名变量

我们在使用传统的强类型语言编程时，经常会出现这种情况，即在调用函数时为了获取一个值，却因为该函数返回多个值而不得不定义一堆没用的变量。

在 Go 语言中，这种情况可以通过结合使用多重赋值和匿名变量来避免这种丑陋的写法，让代码看起来更加优雅，多重赋值上面已经介绍过，匿名变量则通过下划线 _ 来声明，任何赋予它的值都会被丢弃。

我们来看个例子，假设 GetName() 函数的定义如下，它返回两个值，分别为 userName 和 nickName：

func GetName() (userName, nickName string) { 
    return "nonfu", "学院君"
}

若只想获得 nickName，则函数调用语句可以用如下方式实现：

_, nickName := GetName()

这种用法可以让代码可读性非常好。

变量的作用域

每个变量在程序中都有一定的作用范围，称之为作用域。如果一个变量在函数体外声明，则被认为是全局变量，可以在整个包甚至外部包（变量名以大写字母开头）使用，不管你声明在哪个源文件里或在哪个源文件里调用该变量。在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，函数的参数和返回值变量也是局部变量。

尽管变量的标识符必须是唯一的，但你可以在某个代码块的内层代码块中使用相同名称的变量，此时外部的同名变量将会暂时隐藏（结束内部代码块的执行后隐藏的外部同名变量又会出现，而内部同名变量则被释放），你任何的操作都只会影响内部代码块的局部变量。

关于变量的作用域后面我们在介绍到函数、包、流程控制代码块时会通过具体实例来演示，这里先埋根线，知道有这回事即可。

常量使用入门

在 Go 语言中，常量是指编译期间就已知且不可改变的值，常量只可以是数值类型（包括整型、 浮点型和复数类型）、布尔类型、字符串类型等标量类型。和 PHP/C 一样，在 Go 语言中，我们可以通过 const 关键字来定义常量（遵循 C 语言的约定）。

常量定义

通过 const 关键字定义常量时，可以指定常量类型，也可以省略（底层会自动推导），常见的常量定义方式如下：

const Pi float64 = 3.14159265358979323846 
const zero = 0.0 // 无类型浮点常量 
const (          // 通过一个 const 关键字定义多个常量，和 var 类似
    size int64 = 1024
    eof = -1  // 无类型整型常量 
) 
const u, v float32 = 0, 3  // u = 0.0, v = 3.0，常量的多重赋值 
const a, b, c = 3, 4, "foo" // a = 3, b = 4, c = "foo", 无类型整型和字符串常量

结合 Go 语言变量定义方式，可以看到 Go 这种变量和常量的声明方式可读性很好，从左往右，第一个标识符 var 或 const 表明声明的是变量还是常量，第二个标识符标识变量或常量的内存存储块别名，以便后续引用，第三个标识符表示变量或常量的数据类型，可以省略，省略的情况下底层会在编译期自动推导对应的变量或常量类型。

由于常量的赋值是一个编译期行为，所以右值不能出现任何需要运行期才能得出结果的表达式，比如试图以如下方式定义常量就会导致编译错误：

func GetNumber() int {
    return 100
}

const num = GetNumber()

原因很简单，GetNumber() 只有在运行期才能知道返回结果，在编译期并不能确定，所以无法作为常量定义的右值。

此外常量之所以叫常量意思是它的值是恒定不变的，如果你试图在运行时修改常量的值，则会在编译期报错。

预定义常量

Go 语言预定义了这些常量：true、false 和 iota。

前面两个熟悉其他语言的应该都很熟悉，是布尔类型的真假值，iota 比较特殊，可以被认为是一个可被编译器修改的常量，在每一个 const 关键字出现时被重置为 0，然后在下一个 const 出现之前，每出现一次 iota，其所代表的数字会自动增 1。

从以下的例子可以基本理解 iota 的用法：

package main

const (    // iota 被重置为 0
    c0 = iota   // c0 = 0
    c1 = iota   // c1 = 1
    c2 = iota   // c2 = 2
)

const (
    u = iota * 2;  // u = 0
    v = iota * 2;  // v = 2
    w = iota * 2;  // w = 4
)

const x = iota;  // x = 0
const y = iota;  // y = 0

如果两个 const 的赋值语句的表达式是一样的，那么还可以省略后一个赋值表达式。因此，上面的前两个 const 语句可简写为：

const ( 
    c0 = iota 
    c1 
    c2 
)

const ( 
    u = iota * 2 
    v 
    w 
)

枚举

此外，常量还可以用于枚举。

枚举中包含了一系列相关的常量，比如下面关于一个星期中每天的定义。Go 语言并不支持其他语言用于表示枚举的 enum 关键字，而是通过在 const 后跟一对圆括号定义一组常量的方式来实现枚举。

下面是一个常规的 Go 语言枚举表示法，其中定义了一系列整型常量：

const (
    Sunday = iota 
    Monday 
    Tuesday 
    Wednesday 
    Thursday 
    Friday 
    Saturday 
    numberOfDays
)

常量的作用域

和函数体外声明的变量一样，以大写字母开头的常量在包外可见（类似于 public 修饰的类属性），比如上面介绍的 Pi、Sunday 等，而以小写字母开头的常量只能在包内访问（类似于通过 protected 修饰的类属性），比如 zero、numberOfDays 等，后面在介绍包的可见性时还会详细介绍。

函数体内声明的常量只能在函数体内生效。