（四）golang变量

变量声明

标准格式

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

var 变量名 变量类型

变量声明以关键字 var 开头，后置变量类型，行尾无须分号。

批量格式

以为每行都用 var 声明变量比较烦琐？不要紧，还有一种为懒人提供的定义变量的方法：

var (
    a int
    b string
    c []float32
    d func() bool
    e struct {
        x int
    }
)

使用关键字var和括号，能够将一组变量定义放在一块儿。

变量初始化

变量初始化的标准格式

var 变量名 类型 = 表达式
var hp int = 100

编译器推导类型的格式

var hp = 100

短变量声明并初始化

hp := 100

注意：在多个短变量声明和赋值中，至少有一个新声明的变量出如今左值中，即使其余变量名多是重复声明的，编译器也不会报错，代码以下：

conn, err := net.Dial("tcp", "127.0.0.1:8080")
conn2, err := net.Dial("tcp", "127.0.0.1:8080")

上面的代码片断，编译器不会报err重复定义。
go语言能够多个变量同时赋值，使用多重赋值时，若是不须要在左值中接收变量，可使用匿名变量（anonymous variable）_。

golang字符串

字符串转义符

package main
import (
    "fmt"
)
func main() {
    fmt.Println("str := \"c:\\Go\\bin\\go.exe\"")
}

定义多行字符串

在源码中，将字符串的值以双引号书写的方式是字符串的常见表达方式，被称为字符串字面量（string literal）。这种双引号字面量不能跨行。若是须要在源码中嵌入一个多行字符串时，就必须使用`字符，代码以下：

const str = ` 第一行
第二行
第三行
\r\n
`
fmt.Println(str)

代码运行结果：

第一行
第二行
第三行
\r\n

`叫反引号,两个反引号间的字符串将被原样赋值到 str 变量中。在这种方式下，反引号间换行将被做为字符串中的换行，可是全部的转义字符均无效，文本将会原样输出。

Go语言字符类型（byte和rune）

字符串中的每个元素叫作“字符”，在遍历或者单个获取字符串元素时能够得到字符。

Go 语言的字符有如下两种：
一种是 uint8 类型，或者叫 byte 型，表明了 ASCII 码的一个字符。
另外一种是 rune 类型，表明一个 UTF-8 字符。当须要处理中文、日文或者其余复合字符时，则须要用到 rune 类型。rune 类型实际是一个 int32。

使用 fmt.Printf 中的%T动词能够输出变量的实际类型，使用这个方法能够查看 byte 和 rune 的原本类型，代码以下：

var a byte = 'a'
fmt.Printf("%d %T\n", a, a)
var b rune = '你'
fmt.Printf("%d %T\n", b, b)

例子输出结果：

97 uint8
20320 int32

能够发现，byte 类型的 a 变量，实际类型是 uint8，其值为 'a'，对应的 ASCII 编码为 97。

rune 类型的 b 变量的实际类型是 int32，对应的 Unicode 码就是 20320。

Go 使用了特殊的 rune 类型来处理 Unicode，让基于 Unicode 的文本处理更为方便，也可使用 byte 型进行默认字符串处理，性能和扩展性都有照顾。

go语言指针

Go语言变量生命期
指针（pointer）概念在 Go 语言中被拆分为两个核心概念：
类型指针，容许对这个指针类型的数据进行修改。传递数据使用指针，而无须拷贝数据。类型指针不能进行偏移和运算。
切片，由指向起始元素的原始指针、元素数量和容量组成。

受益于这样的约束和拆分，Go 语言的指针类型变量拥有指针的高效访问，但又不会发生指针偏移，从而避免非法修改关键性数据问题。同时，垃圾回收也比较容易对不会发生偏移的指针进行检索和回收。

切片比原始指针具有更强大的特性，更为安全。切片发生越界时，运行时会报出宕机，并打出堆栈，而原始指针只会崩溃。
每一个变量在运行时都拥有一个地址，这个地址表明变量在内存中的位置。Go 语言中使用&做符放在变量前面对变量进行“取地址”操做。

格式以下：

ptr := &v    // v的类型为T

其中 v 表明被取地址的变量，被取地址的 v 使用 ptr 变量进行接收，ptr 的类型就为T，称作 T 的指针类型。表明指针。

指针实际用法，经过下面的例子了解：

package main
import (
    "fmt"
)
func main() {
    var cat int = 1
    var str string = "banana"
    fmt.Printf("%p %p", &cat, &str)
}

运行结果：

0xc042052088 0xc0420461b0

建立指针的另外一种方法——new() 函数

Go 语言还提供了另一种方法来建立指针变量，格式以下：
new(类型)

通常这样写：

str := new(string)
*str = "ninja"
fmt.Println(*str)

new() 函数能够建立一个对应类型的指针，建立过程会分配内存。被建立的指针指向的值为默认值。

Go语言变量生命期，Go语言变量逃逸分析

讨论变量生命期以前，先来了解下计算机组成里两个很是重要的概念：堆和栈。

栈

栈（Stack）是一种拥有特殊规则的线性表数据结构。
1) 概念
栈只容许往线性表的一端放入数据，以后在这一端取出数据，按照后进先出（LIFO，Last InFirst Out）的顺序，以下图所示。

图：栈的操做及扩展

往栈中放入元素的过程叫作入栈。入栈会增长栈的元素数量，最后放入的元素老是位于栈的顶部，最早放入的元素老是位于栈的底部。

从栈中取出元素时，只能从栈顶部取出。取出元素后，栈的数量会变少。最早放入的元素老是最后被取出，最后放入的元素老是最早被取出。不容许从栈底获取数据，也不容许对栈成员（除栈顶外的成员）进行任何查看和修改操做。

栈的原理相似于将书籍一本一本地堆起来。书按顺序一本一本从顶部放入，要取书时只能从顶部一本一本取出。
2) 变量和栈有什么关系
栈可用于内存分配，栈的分配和回收速度很是快。下面代码展现栈在内存分配上的做用，代码以下：

func calc(a, b int) int {
    var c int
    c = a * b
    var x int
    x = c * 10
    return x
}

代码说明以下：
第 1 行，传入 a、b 两个整型参数。
第 2 行，声明 c 整型变量，运行时，c 会分配一段内存用以存储 c 的数值。
第 3 行，将 a 和 b 相乘后赋予 c。
第 5 行，声明 x 整型变量，x 也会被分配一段内存。
第 6 行，让 c 乘以 10 后存储到 x 变量中。
第 8 行，返回 x 的值。

上面的代码在没有任何优化状况下，会进行 c 和 x 变量的分配过程。Go 语言默认状况下会将 c 和 x 分配在栈上，这两个变量在 calc() 函数退出时就再也不使用，函数结束时，保存 c 和 x 的栈内存再出栈释放内存，整个分配内存的过程经过栈的分配和回收都会很是迅速。

堆

堆在内存分配中相似于往一个房间里摆放各类家具，家具的尺寸有大有小。分配内存时，须要找一块足够装下家具的空间再摆放家具。通过反复摆放和腾空家具后，房间里的空间会变得乱七八糟，此时再往空间里摆放家具会存在虽然有足够的空间，但各空间分布在不一样的区域，没法有一段连续的空间来摆放家具的问题。此时，内存分配器就须要对这些空间进行调整优化，以下图所示。

图：堆的分配及空间

堆分配内存和栈分配内存相比，堆适合不可预知大小的内存分配。可是为此付出的代价是分配速度较慢，并且会造成内存碎片。
变量逃逸（Escape Analysis）——自动决定变量分配方式，提升运行效率
堆和栈各有优缺点，该怎么在编程中处理这个问题呢？在 C/C++ 语言中，须要开发者本身学习如何进行内存分配，选用怎样的内存分配方式来适应不一样的算法需求。好比，函数局部变量尽可能使用栈；全局变量、结构体成员使用堆分配等。程序员不得不花费不少年的时间在不一样的项目中学习、记忆这些概念并加以实践和使用。

Go 语言将这个过程整合到编译器中，命名为“变量逃逸分析”。这个技术由编译器分析代码的特征和代码生命期，决定应该如何堆仍是栈进行内存分配，即便程序员使用 Go 语言完成了整个工程后也不会感觉到这个过程。
1) 逃逸分析
使用下面的代码来展示 Go 语言如何经过命令行分析变量逃逸，代码以下：

package main
import "fmt"
// 本函数测试入口参数和返回值状况
func dummy(b int) int {
    // 声明一个c赋值进入参数并返回
    var c int
    c = b
    return c
}
// 空函数, 什么也不作
func void() {
}
func main() {
    // 声明a变量并打印
    var a int
    // 调用void()函数
    void()
    // 打印a变量的值和dummy()函数返回
    fmt.Println(a, dummy(0))
}

代码说明以下：
第 6 行，dummy() 函数拥有一个参数，返回一个整型值，测试函数参数和返回值分析状况。
第 9 行，声明 c 变量，这里演示函数临时变量经过函数返回值返回后的状况。
第 16 行，这是一个空函数，测试没有任何参数函数的分析状况。
第 23 行，在 main() 中声明 a 变量，测试 main() 中变量的分析状况。
第 26 行，调用 void() 函数，没有返回值，测试 void() 调用后的分析状况。
第 29 行，打印 a 和 dummy(0) 的返回值，测试函数返回值没有变量接收时的分析状况。

接着使用以下命令行运行上面的代码：

$ go run -gcflags "-m -l" main.go

使用 go run 运行程序时，-gcflags 参数是编译参数。其中 -m 表示进行内存分配分析，-l 表示避免程序内联，也就是避免进行程序优化。

运行结果以下：

# command-line-arguments
./main.go:29:13: a escapes to heap
./main.go:29:22: dummy(0) escapes to heap
./main.go:29:13: main ... argument does not escape
0 0

程序运行结果分析以下：
输出第 2 行告知“main 的第 29 行的变量 a 逃逸到堆”。
第 3 行告知“dummy(0)调用逃逸到堆”。因为 dummy() 函数会返回一个整型值，这个值被 fmt.Println 使用后仍是会在其声明后继续在 main() 函数中存在。
第 4 行，这句提示是默认的，能够忽略。

上面例子中变量 c 是整型，其值经过 dummy() 的返回值“逃出”了 dummy() 函数。c 变量值被复制并做为 dummy() 函数返回值返回，即便 c 变量在 dummy() 函数中分配的内存被释放，也不会影响 main() 中使用 dummy() 返回的值。c 变量使用栈分配不会影响结果。
2) 取地址发生逃逸
下面的例子使用结构体作数据，了解在堆上分配的状况，代码以下：

package main
import "fmt"
// 声明空结构体测试结构体逃逸状况
type Data struct {
}
func dummy() *Data {
    // 实例化c为Data类型
    var c Data
    //返回函数局部变量地址
    return &c
}
func main() {
    fmt.Println(dummy())
}

代码说明以下：
第 6 行，声明一个空的结构体作结构体逃逸分析。
第 9 行，将 dummy() 函数的返回值修改成 *Data 指针类型。
第 12 行，将 c 变量声明为 Data 类型，此时 c 的结构体为值类型。
第 15 行，取函数局部变量 c 的地址并返回。Go 语言的特性容许这样作。
第 20 行，打印 dummy() 函数的返回值。

执行逃逸分析：

$ go run -gcflags "-m -l" main.go
# command-line-arguments
./main.go:15:9: &c escapes to heap
./main.go:12:6: moved to heap: c
./main.go:20:19: dummy() escapes to heap
./main.go:20:13: main ... argument does not escape
&{}

注意第 4 行出现了新的提示：将 c 移到堆中。这句话表示，Go 编译器已经确认若是将 c 变量分配在栈上是没法保证程序最终结果的。若是坚持这样作，dummy() 的返回值将是 Data 结构的一个不可预知的内存地址。这种状况通常是 C/C++ 语言中容易犯错的地方：引用了一个函数局部变量的地址。

Go 语言最终选择将 c 的 Data 结构分配在堆上。而后由垃圾回收器去回收 c 的内存。
3) 原则
在使用 Go 语言进行编程时，Go 语言的设计者不但愿开发者将精力放在内存应该分配在栈仍是堆上的问题。编译器会自动帮助开发者完成这个纠结的选择。但变量逃逸分析也是须要了解的一个编译器技术，这个技术不只用于 Go 语言，在 Java 等语言的编译器优化上也使用了相似的技术。

编译器以为变量应该分配在堆和栈上的原则是：变量是否被取地址。变量是否发生逃逸。