使用 var 申明的叫变量，有些数据在运行过程不会被改变或则防止被改变，使用常量更好，常量的意思就是申明赋值后就不会再改变了，如果某个地方不小心改变了它，编译器就会报错。

常量类型也是可以推导值，下面等价:

 const score int = 10
const score = 10  

常量对数据的类型有限制，只能是布尔、数字和字符串，数字包含整数、浮点数、虚数。比如:

 const space byte = 0x20  

之前的代码我们使用过 unsafe.Sizeof 计算字节大小，这个函数其实是在编译器就能确定的，它只和变量的类型有关系，和变量指向的缓冲区长度没有关系，比如对于字符串来讲，因为 go 内部用 2 个字段来表示字符串类型，2 个字段各占用 8 个字节，所以对字符串使用 unsafe.Sizeof 返回 16，因为这个大小在编译器就能确定，不会再更改了，所以 unsafe.Sizeof 的结果其实可以直接赋值给 const 常量。学过 C 语言的要特别注意，此 sizeof 不是 C 的那个 sizeof。

 // CompileSizedof 编译器确定所以可以给 const 赋值
func CompileSizedof() {
  str := "english 中文"
  const byteInSize = unsafe.Sizeof(str)
  // 不管 str 是什么内容 byteInSize 都是 16
  // 字符串在 go 内部用 2 个字段表示(一个地址值和一个长度值，都占用 8 个字节)
  fmt.Println(byteInSize)
}  

下面的字符串的类型定义:

 // #L1973:6
// StringHeader is the runtime representation of a string.
// It cannot be used safely or portably and its representation may
// change in a later release.
// Moreover, the Data field is not sufficient to guarantee the data
// it references will not be garbage collected, so programs must keep
// a separate, correctly typed pointer to the underlying data.
type StringHeader struct {
Data uintptr
Len  int
}  

uintptr 是一个地址值，在 64 位它的定义是:

 typedef unsigned long long int  uint64;
typedef uint64                  uintptr;  

类型和平台有关系，官方文档里的解释 int 至少是 32 位，也就是在 64 位(AMD64/X86-64)的电脑上，它就是 64 位的，如果你本地运行结果不是 16，请确认一下你的电脑的 cpu 架构以及你的 go 版本是不是过低(在 1.1 以下)。

扯远了，说常量呢。

go 语言里经常把常量用作枚举，可以如下定义:

 const (
  appple = 0
  banana = 1
  orange = 2
)  

不过这样 0 1 2 给维护增加了负担，go 语言定义了一个特殊的常量叫 iota，编译的时候会被编译器修改，它的作用是在 const 第一行被设置成 0，每增加一行，它的值就会累加一次，就像是 const 的索引。所以下面的定义还是 0 1 2:

 const (
  appple = iota
  banana = iota
  orange = iota
)  

简写如下:

 const (
  appple = iota
  banana
  orange
)  

所以当你看到这个奇怪的关键字时不要紧张，每行它就累加 1。

在编译期不能确定的就是变量了，它的值在运行期会被修改，编译器会给它分配一个内存地址和相应的内存空间，这个内存地址在运行的时候是确定的，如果把这个内存地址赋值给另外一个变量，这个变量就是指针变量，表示它是指向那个内存地址。怎么获得一个变量的地址呢? 使用 & 操作符，用 %p 来格式化。

 // PrintAddr 打印变量的地址
func PrintAddr() {
  score := 10
  fmt.Printf("%p\n", &score) // 打印 0xc00001c118 
}  

持有变量地址的指针变量可以通过 * 操作符读取它地址里存放的值，并且修改它。

 // HoldVarAddr 持有变量的内存地址
func HoldVarAddr() {
  score := 10
  addr := &score
  *addr = 20
  fmt.Println(score) // 打印 20
}  

在都用函数的过程，默认参数是按照值传递的，对于普通的变量类型，传递的参数会被拷贝一份压入堆栈，这种情况下函数体内的代码不会影响到传入的参数本身，因为他们的内存地址并不是同一个位置。所以下面的代码无法修改 score 的值。

 // 不能修改入参 score 参数值
// 函数调用的时候参数被拷贝
func cannotUpdateScore(score int) {
  fmt.Println(&score) // 0xc00001c138
  score++
  fmt.Println(score) // 11
}

// IncScoreFailed 调高分数
func IncScoreFailed() {
  score := 10
  fmt.Println(&score) // 0xc00001c130
  cannotUpdateScore(score)
  fmt.Println(score) // 10
}  

运行可发现上面两个 score 的内存地址是不同的，如果希望 score 参数被修改，就得传入它的内存地址，函数调用的时候这个内存地址值被拷贝，传过去，函数修改了内存地址中存放的值，使得 score 被修改了。

 // 可以修改入参 score 参数值
// 函数调用的时候参数被拷贝
func canUpdateScore(ptrScore *int) {
  fmt.Println(ptrScore) // 已经是地址了 0xc00001c140
  *ptrScore++
  fmt.Println(*ptrScore) // 11
}

// IncScoreSuccessed 调高分数
func IncScoreSuccessed() {
  score := 10
  fmt.Println(&score) // 0xc00001c140
  canUpdateScore(&score)
  fmt.Println(score) // 11
}  

传过去的内存地址都是 0xc00001c140，把这个内存地址的值累加后，反应到了原来指向这个内存地址的 score 变量上，也就是 ptrScore 和 &score 都持有 score 的把柄，可以随意的操纵它。

在 go 语言里面，除了调用 unsafe 包的函数外，不能直接对指针进行运算，修改指针的内存地址值。在上面的代码中，对 ptrScore++ 是不被允许的。

本章节的代码