Go 语言变量

编程中可以说最常见的就是变量了，主要被用来存储各种类型数据。

关于变量的类型，主要有:

• 整型
• 浮点型
• 布尔型
• 结构体
• …

Go 语言中不同类型的变量，需要先声明，才能够被使用。

Go 语言 - 声明变量

1. 标准格式

Go 语言中声明变量需以 var 关键字开头，变量名放在中间，变量类型放在最后。

var 变量名 变量类型

注意： 行尾无分号 ; 。

下面是 Go 语言常见的基本变量声明:

// 声明一个整型的变量，被用来保存整数数值
var a int                 

// 声明一个字符串类型的变量
var b string   

// 声明一个 32 位浮点切片类型的变量          
var c []float32       

// 声明一个返回值为布尔型的函数变量，将函数以变量的形式保存起来    
var d func() bool    

// 声明一个结构体类型的变量，结构体中声明了一个整型的 `f` 变量     
var e struct {            
	f int
}

2. 批量格式

若觉得每次前面都要定义 var 非常繁琐, 还可以通过 var 和括号来批量声明：

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

Go 语言 - 初始化与定义变量

Go 语言中，初始化变量有如下几种写法：

1. 标准格式

var 变量名 变量类型 = 变量值

例如想初始化一个人的年龄，可以这样写：

// 初始化一个整型，变量名为 age, 初始值为 18 的变量
var age int = 18 

2. 编译器推导类型格式

我们还可以在上述格式的基础上，再精简点：

var age = 18

无需定义 变量类型，编译器会根据等号右边的变量值，来推断 age 的变量类型。

3. 短变量声明与初始化

还可以在第二种的基础上，再做简化：

age := 18

这也是 Go 语言中变量推导的一种写法，但是与上面不同的是：

注意： 因为使用了 := , 而不是赋值的 =, 这就限制了等号左边的变量名必须是没有定义过的变量名，否则将会发生编译错误。

举个反例，代码如下：

// 声明一个整型 age 变量
var age int

// 再次声明与赋值
age := 18

编译报错如下：no new variables on left side of :=

PS: 报错信息意思表示： := 左边的变量已经被声明了。

Go语言 - 多变量同时赋值

假设这样一个场景，需要交互互相两个变量的值，先看看传统的写法：

var a int = 100  // 定义变量 a
var b int = 200  // 定义变量 b
var c int        // 定义一个中间变量

// 开始互相交互 a 与 b 变量的值
c = a
a = b
b = c

fmt.Println(a, b)

为了达到交换后数据的正确性，通常都需要定义一个临时中间变量来做中转，如上所示。

代码输出结果：200 100

但是，在 Go 语言中利用多重赋值的特性，还可以这样写：

var a int = 100
var b int = 200

a, b = b, a
fmt.Println(a, b)

代码运行结果同样是：200 100

Go 语言 - 匿名变量

匿名变量就是一个没有名字的变量，通常用下划线 _ 来表示。

这玩意什么场景下会用到呢？

举个例子，假设有这种场景，需要调用某个函数 findStudent()，来查询数据库中某个学生的数据，函数会返回两个数值，分别是：

• 学生姓名；
• 学生年龄；

但是呢，我们只需要获取学生的姓名就行了，年龄并不需要，但是又不想为其单独声明一个变量，这时匿名变量就有用武之地了：

func findStudent() (string, int) {
  return "犬小哈", 100
}

name, _ := findStudent()

fmt.Println(name)

代码输出：犬小哈

注意： 匿名变量不占用命名空间，也不会占用内存。匿名变量与匿名变量直接不会因为多次声明而无法使用。

参考资料

Golang 【basic_leaming】变量、常量、变量命名规则

Go 语言整型（整数类型）

在 Go 语言中，整型分为以下两个大类：

• 有符号类型，按长度分为: int8 、int16、int32、int64
• 无符号类型，与上面对应的分别是: uint8、uint16、uint32、uint64

PS: 这里 unit8 就是我们熟知的 byte型，int16 对应 C 语言中的 short型，int64对应 C 语言中的 long 类型。

1 自动匹配平台的 int 和 unit

看了上面这些类型，你可能在想，这也太繁琐了，有没有一种类型，它能根据平台 CPU 机器字节大小来调整长度呢？

有的，那就是：

• 有符号类型: int
• 无符号类型： uint

这里 int 是应用最广泛的数值类型。

这两种类型都有同样的大小，32 或 64bit，但是我们不能对此做任何的假设, 因为不同的编译器即使在相同的硬件平台上可能产生不同的大小。

1.1、什么情况要使用 int 和 unit

实际应用中，切片或者 map 的元素数量均可通过 int 来表示。

但是，在二进制传输、读写文件的结构描述时，为了保证文件的结构不受不同编译目标平台的字节长度影响，不要使用 int 和 unit。

2 整数类型 uintptr

最后，还有一种无符号的整数类型 uintptr，它没有指定具体的 bit 大小但是足以容纳指针。uintptr 类型只有在底层编程时才需要，特别是 Go 语言和 C 语言函数库或操作系统接口相交互的地方。

尽管在某些特定的运行环境下 int、uint 和 uintptr 的大小可能相等，但是它们依然是不同的类型，比如 int 和 int32，虽然 int 类型的大小也可能是 32 bit，但是在需要把 int 类型当做 int32 类型使用的时候必须显示的对类型进行转换，反之亦然。

Go 语言中有符号整数采用 2 的补码形式表示，也就是最高 bit 位用来表示符号位，一个 n-bit 的有符号数的取值范围是从 -2(n-1) 到 2(n-1)-1。无符号整数的所有 bit 位都用于表示非负数，取值范围是 0 到 2n-1。例如，int8 类型整数的取值范围是从 -128 到 127，而 uint8 类型整数的取值范围是从 0 到 255。

Go 语言浮点型 (小数类型)

Go 语言中提供了两种精度浮点型 float32 和 float64。

这两种浮点型数据格式遵循 IEEE754 浮点数国际标准，该浮点数规范被所有现代的CPU支持。

浮点型 Float32

float32，即我们常说的单精度，存储占用4个字节，也即 4*8=32 位，其中 1 位用来符号，8 位用来指数，剩下的 23 位表示尾数。

浮点型 Float64

float64, 即我们熟悉的双精度，存储占用8个字节，也即8*8=64位，其中1位用来符号，11位用来指数，剩下的52位表示尾数。

浮点数精度

float32 的浮点数最大值约为 3.4e38, 可以通过 match 包的方法来获取: match.MaxFloat32。

float64 的浮点数最大值约为 1.8e308, 可以通过 match 包的方法来获取： match.MaxFloat64。

它们分别能表示的最小值近似为 1.4e-45 和 4.9e-324。

一个 float32 类型的浮点数可以提供大约 6 个十进制数的精度，而 float64 则可以提供约 15 个十进制数的精度；

通常应该优先使用 float64 类型，因为 float32 类型的累计计算误差很容易扩散，并且 float32 能精确表示的正整数并不是很大（注意：因为float32的有效bit位只有23个，其它的bit位用于指数和符号；

当整数大于 23bit 能表达的范围时，float32的表示将出现误差）：

var f float32 = 16777216 // 1 << 24
fmt.Println(f == f+1)    // "true"!

浮点数的字面值可以直接写小数部分，如下所示：

const e = 2.71828

小数点前面或后面的数字都可能被省略（例如.707或1.）。
很小或很大的数最好用科学计数法书写，通过e或E来指定指数部分：

const Avogadro = 6.02214129e23  // 阿伏伽德罗常数
const Planck   = 6.62606957e-34 // 普朗克常数

打印浮点数

通过 Printf 函数打印浮点数时, 可以使用 “%f” 来控制保留几位小数, 代码如下：

package main

import (
	"fmt"
	"math"
)

func main() {
	// 打印默认宽度和精度的圆周率， \n 为换行符
	fmt.Printf("%f\n", math.Pi)

	// 打印默认宽度, 精度（小数点后的位数)为2的圆周率
	fmt.Printf("%.2f\n", math.Pi)
}

运行结果如下：

3.141593
3.14

Go 语言布尔型 (bool)

在 Go 语言中，以关键字 bool 来声明布尔类型。
布尔类型只有 true 和 false 两种值。

if 和 for 语句的条件部分都是布尔类型的值，并且 == 和 < 等比较操作也会产生布尔型的值。

一元操作符 ! 对应逻辑非操作，因此 !true 的值为 false，更罗嗦的说法是(!true==false)==true，虽然表达方式不一样，不过我们一般会采用简洁的布尔表达式，就像用 x 来表示 x==true。

布尔值可以和 &&（AND）和 ||（OR）操作符结合，并且有短路行为：
如果运算符左边值已经可以确定整个布尔表达式的值，
那么运算符右边的值将不再被求值，因此下面的表达式总是安全的：

s != "" && s[0] == 'x' 
// 其中s[0]操作如果应用于空字符串将会导致 panic 异常。

因为 && 的优先级比 || 高（PS：&&对应逻辑乘法，|| 对应逻辑加法，乘法比加法优先级要高），下面形式的布尔表达式是不需要加小括弧的：

if 'a' <= c && c <= 'z' ||
    'A' <= c && c <= 'Z' ||
    '0' <= c && c <= '9' {
    // ...ASCII letter or digit...
}

关于布尔型类型转换

Go 语言中布尔类型无法参与数值运算，也无法与其他类型进行转换 ：

package main

import "fmt"

func main()  {
	var a bool
	fmt.Print(int(a) * 2) 
	// 将变量 a 强制转换为 int 类型，并乘以 2
}

运行上面的代码，会发生编译错误:

cannot convert a (type bool) to type int
无法将 bool 类型转换为 int 类型

Go 语言字符串

在 Go 语言中，字符串是一个不可改变的字节序列，类型为原生数据类型，同 int 、bool 、float32 、float64 是一样的。

字符串的值通过双引号来包裹，Go 语言中，我们可以直接添加非 ASCII 码字符, 代码如下：

str := "zhiqihei,shouqibai"
ch := "知其黑、受其白"

1 计算字符串的长度

Go 语言内置的 len() 函数可以获取切片、字符串、通道(channel) 等的长度。

package main

import "fmt"

func main()  {
  str1 := "zhiqihei,shouqibai"
  fmt.Println(len(str1))
  
  str2 := "知其黑、受其白"
  fmt.Println(len(str2))
}

代码运行结果如下：

PS E:\golang\src> go run .\main.go
18
21
PS E:\golang\src>

len() 函数返回值为 int 类型，表示字符串的 ASCII 字符的个数或字节长度。

你可能会奇怪，字符串 str2 的长度居然是21，这是因为 Go 语言的字符串都以 UTF-8 格式保存，每个中文占用 3 个字节，所以 7 ✖️ 3 = 21 个字节。

如果希望按照习惯上的字符个数类计算，可以使用 UTF-8 包提供的 RuneCountInString() 来统计 Uncode 字符数量：

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	str2 := "知其黑、受其白"
	fmt.Println(utf8.RuneCountInString(str2))
}

PS E:\golang\src> go run .\main.go
7
PS E:\golang\src>

注意: i 必须满足 0 ≤ i< len(str) 条件约束。如果试图访问超出字符串索引范围的字节将会导致 panic 异常：

c := str[len(str)] // panic: index out of range

2 遍历字符串

遍历字符串有如下两种写法：

2.1 遍历每一个 ASCII 字符

遍历 ASCII 字符通过 for 循环来，使用字符串的下标来获取，代码如下：

package main

import "fmt"

func main() {
	str := "知其黑，受其白 wgchen.blog.csdn.net/"

	for i := 0; i < len(str); i++ {
		fmt.Printf("ascii: %c %d\n", str[i], str[i])
	}
}

PS E:\golang\src> go run .\main.go
ascii: ç 231
ascii: Ÿ 159
ascii: ¥ 165
ascii: å 229
ascii: 
 133
ascii: ¶ 182
ascii: é 233
ascii: » 187
ascii: ‘ 145
ascii: ï 239
ascii: ¼ 188
ascii: Π140
ascii: å 229
ascii:  143
ascii: — 151
ascii: å 229
ascii: 
 133
ascii: ¶ 182
ascii: ç 231
ascii: ™ 153
ascii: ½ 189
ascii:   32
ascii: w 119
ascii: g 103
ascii: c 99
ascii: h 104
ascii: e 101
ascii: n 110
ascii: . 46
ascii: b 98
ascii: l 108
ascii: o 111
ascii: g 103
ascii: . 46
ascii: c 99
ascii: s 115
ascii: d 100
ascii: n 110
ascii: . 46
ascii: n 110
ascii: e 101
ascii: t 116
ascii: / 47
PS E:\golang\src>

可以看到，由于没有使用 Unicode 编码，汉字部分全部为乱码。

2.2 按 Unicode 字符遍历字符串

Unicode 字符遍历使用 for range:

package main

import "fmt"

func main() {
	str := "知其黑，受其白 wgchen.blog.csdn.net/"

	for _, s := range str {
		fmt.Printf("Unicode: %c %d\n", s, s)
	}
}

PS E:\golang\src> go run .\main.go
Unicode: 知 30693
Unicode: 其 20854
Unicode: 黑 40657
Unicode: ， 65292
Unicode: 受 21463
Unicode: 其 20854
Unicode: 白 30333
Unicode:   32
Unicode: w 119
Unicode: g 103
Unicode: c 99
Unicode: h 104
Unicode: e 101
Unicode: n 110
Unicode: . 46
Unicode: b 98
Unicode: l 108
Unicode: o 111
Unicode: g 103
Unicode: . 46
Unicode: c 99
Unicode: s 115
Unicode: d 100
Unicode: n 110
Unicode: . 46
Unicode: n 110
Unicode: e 101
Unicode: t 116
Unicode: / 47
PS E:\golang\src>

可以看到，中文正常显示了。

3 获取字符串某一段字符

可以通过 str[i:j] 基于原始的 str 字符串的第 i 个字节开始到第 j 个字节（并不包含 j 本身）生成一个新字符串。生成的新字符串将包含 j-i 个字节。

package main

import (
	"fmt"
	"strings"
)

func main() {
	str := "wgchen.blog.csdn.net"

	fmt.Println(str[0:1]) // 输出 w

	// 通过 strings.Index() 函数获取字符 . 的下标
	index := strings.Index(str, ".")
	fmt.Println(str[0:index]) // 输出 wgchen
}

同样，如果索引超出字符串范围或者j小于i的话将导致 panic 异常。

不管 i 还是 j 都可以不填写，若不填写，将采用 0 作为开始位置，采用len(s) 作为结束的位置。

package main

import (
	"fmt"
)

func main() {
	str := "wgchen.blog.csdn.net"
	fmt.Println(str[:10]) // "wgchen.blo"
	fmt.Println(str[11:]) // ".csdn.net"
	fmt.Println(str[:])   // "wgchen.blog.csdn.net"
}

补充知识点：

• strings.Index: 正向搜索子字符串，并获取下标位置；
• strings.LastIndex: 反向搜索子字符串，并获取下标位置；

4 修改字符串

Go 语言中，无法直接修改字符串中的字符，只能通过重新构造一个新的字符串并赋值给原来的字符串实现：

package main

import (
	"fmt"
)

func main() {
	str := "wgchen.blog.csdn.net"

	// 将字符串转换为字符串数组
	strBytes := []byte(str)

	// 将 .com 替换为空格
	for i := 10; i < len(str); i++ {
		strBytes[i] = ' '
	}

	fmt.Println(string(strBytes))
	// wgchen.blo
}

看上面的代码，貌似我们是直接通过修改字符串而达到的目的，其实真实的情况是，同 Java、C# 一样，字符串默认是不可变的。

不可变有很多好处，如天生的线程安全，大家使用的都是只读的，并发情况下，省去了加锁的开销；

另外，方便内存共享，而不必使用写时复制（Copy On Write）等技术；
字符串 hash 值也只需要制作一份。

所以说，上面代码实际修改的是 []byte, []byte 在 Go 语言中是可变的，它本身就是个切片。

代码中最后打印输出时，实际上通过 string() 将 []byte 转为字符串，重新创造了一个新的字符串。

总结：

• Go 语言中字符串是不可变的；
• 修改字符串时，可以将字符串转换成 []byte 进行修改；
• []byte 和 string 可以通过类型转换互转。

5 拼接字符串

Go 语言同绝大数其他语言一样，通过操作符 + 可以将两个字符串连接构造一个新字符串：

package main

import (
	"fmt"
)

func main() {
	str2 := "wgchen.blog.csdn.net"
	str1 := "hello "

	fmt.Println(str1 + str2) 
	// "hello wgchen.blog.csdn.net"
}

除了使用 + 来拼接字符串，Go 语言中也有类似于 Java 语言中 StringBuilder 的机制，来进行更高效率的字符串拼接。

代码如下：

package main

import (
	"bytes"
	"fmt"
)

func main() {
	str1 := "hello "
	str2 := "wgchen.blog.csdn.net"

	// 声明字节缓冲
	var stringBuilder bytes.Buffer

	// 将字符串写入缓冲
	stringBuilder.WriteString(str1)
	stringBuilder.WriteString(str2)

	// 将缓冲以字符形式输出
	fmt.Println(stringBuilder.String())
	// hello wgchen.blog.csdn.net
}

bytes.Buffer 做缓冲使用，我们可以通过 WriteString 函数往里面写入各种字节数组。

字符串也是一种字节数组。

最后，再通过 stringBuilder.String() 将缓冲转换为字符串。

6 字符串比较

字符串可以用 == 、 <、> 进行比较；

比较通过逐个字节比较完成的，因此比较的结果是字符串自然编码的顺序。

package main

import "fmt"

func main() {
	str1 := "wgchen.blog.csdn.net"

	str2 := "wgchen.blog.csdn.net"

	// 是否相等标志位
	isSame := false
	if str1 == str2 {
		isSame = true
	}

	fmt.Println(isSame)
}

PS E:\golang\src> go run .\main.go
true
PS E:\golang\src>

7 字符串转义符

Go 语言中，常见转义符包括回车、换行、单双引号、制表符等：

转义符	含义
\r	回车符
\n	换行符
\t	制表符
\'	单引号
\''	双引号
\\	反斜杠

下面是一段示例代码, 简单演示了如何使用双引号与反斜杠：

package main

import "fmt"

func main() {
	fmt.Println("我爱 \"知其黑、受其白教程\" 域名: wgchen\\blog\\csdn\\net")
}

PS E:\golang\src> go run .\main.go
我爱 "知其黑、受其白教程" 域名: wgchen\blog\csdn\net
PS E:\golang\src>

8 定义多行字符串

Go 语言中，字符串双引号的书写方式最为常见，但是不能用来表示多行。如果需要使用多行字符串，需要使用 ` 字符，示例代码如下：

package main

import "fmt"

func main() {
	str := `第一行
第二行
第三行
\r\n`

	fmt.Println(str)
}

PS E:\golang\src> go run .\main.go
第一行
第二行
第三行
\r\n
PS E:\golang\src>

PS: 反引号 ` 在键盘上 1 键左边的位置，被反引号包裹的字符串将会被原样赋值给 str 变量。

注意： 被反引号包裹的转义符会被当成正常字符串看待，原样被输出。

9 Go 语言字符串格式化常用动词

字符串格式化应用场景十分丰富，格式如下：

fmt.Sprintf(格式化样式, 参数列表)

• 格式化样式: 字符串形式，动词以 % 开头；
• 参数列表: 多个参数通过逗号隔开，个数需要与格式化样式中的动词一一对应，否则会报错。

常见动词以及功能如下：

动词	功能
%b	整型以二进制方式显示
%o	整型以八进制方式显示
%d	整型以十进制方式显示
%x	整型以十六进制方式显示
%X	整型以十六进制、字母大写方式显示
%T	输出Go语言语法格式的类型和值
%f	浮点数
%p	指针，十六进制方式显示
%v	按值原本的值输出
%+v	在%v的基础上，对结构体字段名和值进行展开
%#v	输出Go语言语法格式的值
%%	输出%本体
%U	Unicode字符
%s	输出以原生的UTF8字节表示的字符，如果console 不支持 utf8 编码，则会乱码

下面是一些代码示例：

package main

import (
	"fmt"
)

func main() {
	a := 1
	b := 2

	// 两整型参数格式化
	fmt.Printf("第一个数: %d, 第二个数: %d\n", a, b)

	str1 := "hello "
	str2 := "wgchen.blog.csdn.net"

	// 两字符串参数格式化
	content := fmt.Sprintf("1: %s, 2: %s\n", str1, str2)

	fmt.Println(content)
}

PS E:\golang\src> go run .\main.go
第一个数: 1, 第二个数: 2
1: hello , 2: wgchen.blog.csdn.net

PS E:\golang\src>

Go 语言字符（byte与rune）

Go 语言中，字符串的每一个元素叫做字符，主要分为以下两种：

1、uint8 类型，或者叫 byte 型，代表了 ASCII 码的一个字符。
提示：byte 类型是 unit8 的别名。

2、rune 类型，代表了一个 UTF-8 字符。
通常情况下，当需要处理中文、日文、韩文等复合字符时，需要用到 rune 类型。

我们可以在 fmt.Println 中通过 %T 来输出变量的实际类型，代码如下：

package main

import "fmt"

func main() {
	var a byte = 'q'
	fmt.Printf("%d %T\n", a, a)
	// byte 的实际类型其实是个 uint8, 对应的 ASCII 编码为 113

	var b rune = '犬'
	fmt.Printf("%d %T\n", b, b)
	// rune 的实际类型其实是 int32, 对应的 Unicode 编码为 29356
}

得出结论：

• byte 的实际类型其实是个 uint8, 对应的 ASCII 编码为 113；
• rune 的实际类型其实是 int32, 对应的 Unicode 编码为 29356；

Go 语言中，使用了 rune 类型来处理 Unicode 编码，这样让基于 Unicode 的文本处理更为方便，同时也可以用 byte 进行默认的字符串处理，这样对性能和拓展性都有照顾。

UTF-8 和 Unicode 有何区别？

Unicode 与 ASCII 都是一种字符集。

字符集为每个字符分配一个唯一的 ID，我们使用到的所有字符在 Unicode 字符集中都有一个唯一的 ID，例如 q 字符在 Unicode 与 ASCII 中的编码都是 113。汉字“犬”在 Unicode 中的编码为 29356，在不同国家的字符集中，字符所对应的 ID 也会不同。

而无论任何情况下，Unicode 中的字符的 ID 都是不会变化的。

UTF-8 是编码规则，将 Unicode 中的字符 ID 以某种方式进行编码。UTF-8 是一种变长编码规则，从 1 到 4 个字节不等。

编码规则如下：

• 0xxxxxx 表示文字符号 0～127，兼容 ASCII 字符集。
• 从 128 到 0x10ffff 表示其他字符。

在这种规则之下，拉丁文语系的字符编码一般情况下， 每个字符占用一个字节，而中文每个字符占用 3 个字节。

参考资料:整型、浮点型、布尔型、字符串、Go 语言字符（byte与rune）

Golang 【basic_leaming】基本数据类型

Go 语言常量定义与声明 (const)

相对于 Go 语言变量 ，常量是一个不可改变的值，如圆周率 π 等。

常量在代码的编译期就已经确定了，而不是运行时。

每种常量的潜在类型都是基础类型：boolean、string 或 数字。

1 Go 语言常量定义 & 声明

const pi = 3.141592
const domain = "wgchen.blog.csdn.net"

PS E:\golang\src> go run .\main.go
3.141592 wgchen.blog.csdn.net
PS E:\golang\src>

2 定义多个 Go 语言常量

在 Go 语言 中，常量也是可以同时定义多个的，方式和变量很类似。

代码如下:

const (
 	pi = 3.141592
 	domain = "wgchen.blog.csdn.net"
)

上面提到，常量因为在代码编译期就已经确定了，所以可以用于数组声明。

代码如下:

const size = 10
var arr [size]int 
// 定义一个长度为 10 的 int 数组

3 iota 常量生成器生成枚举

常量声明可以使用 iota 常量生成器初始化，它用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式。

在一个 const 声明语句中，在第一个声明的常量所在的行，iota 默认会被置为 0，然后在每一个有常量声明的行自动加一。

大部分场景下，会用 iota 来生成枚举 。

Go 语言枚举类型（iota自增）

Go 语言中其实是没有枚举类型的，但是，可以使用常量 iota 来模拟枚举。

1 Go 语言定义枚举类型

下面这段代码，我们尝试定义一个性别枚举:

package main

import "fmt"

// 定义一个名为 Sex 类型, 实际类型为 int
type Sex int

// 定义性别男女
const (
	// 将枚举值 Woman 定义为 Sex 类型，并搭配 iota 开始生成枚举值，默认从 0 开始
	Woman Sex = iota
	Man
)

func main() {
	// 输出枚举值
	fmt.Println(Woman, Man)

	// 使用枚举类型，并赋值
	var sex Sex = Man
	fmt.Println(sex)
}

PS E:\golang\src> go run .\main.go
0 1
1
PS E:\golang\src>

const 声明内的每一行常量声明，将会自动套用前面 iota 格式，并自动增加。有点类似于 Excel 表格自动填充功能。

也就是说，第一行 Woman 枚举值定义了 0， 那么 Man 的值会自动加一，值变成了1。

当然，iota 除了每次自增 1 以外，我们还可以利用 iota 来完成一些更复杂的操作。

下面这段代码用来生成一些标志位：

package main

import "fmt"

const (
	Flag1 = 1 << iota // 移位操作，左移一位
	Flag2
	Flag3
	Flag4
)

func main() {
	// 输出枚举整型值
	fmt.Printf("%d %d %d %d\n", Flag1, Flag2, Flag3, Flag4)
	// 输出枚举二进制格式的值
	fmt.Printf("%b %b %b %b", Flag1, Flag2, Flag3, Flag4)
}

PS E:\golang\src> go run .\main.go
1 2 4 8
1 10 100 1000
PS E:\golang\src>

2 Go 语言枚举值转换字符串

在实际应用场景中，通常需要获取枚举值对应的字符串描述。

Go 语言中，我们可以这样做：

package main

import "fmt"

// 定义一个名为 Sex 类型
type Sex int

const (
	Woman Sex = iota // 开始生成枚举值，默认从 0 开始
	Man
)

// 定义一个 Sex 类型的方法 String(), 返回字符串
func (s Sex) String() string {
	switch s {
	case Woman:
		return "女"
	case Man:
		return "男"
	}
	return "N/A"
}

func main() {
	// 输出枚举 Woman 的字符串描述，以及整型值
	fmt.Printf("%s %d", Woman, Woman)
}

PS E:\golang\src> go run .\main.go
女 0
PS E:\golang\src>

一旦某个类型需要输出字符串时，Go 语言会自动寻找 String() 方法并调用。

Go 语言指针

大部分面向对象语言都很少有用到指针的场景了，但是在Go语言中有大量的指针应用场景，要想学好 Go 语言，指针是必须了解的。

1 什么是指针

每一个变量都会分配一块内存，数据保存在内存中，内存有一个地址，就像门牌号，通过这个地址就可以找到里面存储的数据。

指针就是保存这个内存地址的变量。

2 Go 语言指针

在 Go 语言中， 指针包括两个核心概念:

• 类型指针
  允许对这个指针类型的数据进行修改。
  传递数据使用指针，而无需拷贝数据。
  类型指针不能进行偏移和运算。

• 切片
  由指向起始元素的原始指针、元素数量和容量组成。

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

切片比原始指针具备更强大的特性，而且更为安全。切片在发生越界时，运行时会报出宕机，并打出堆栈，而原始指针只会崩溃。

3 C/C++中的指针

说到 C/C++ 中的指针，会让许多人“谈虎色变”，尤其是对指针的偏移、运算和转换。 其实，指针是 C/C++ 语言拥有极高性能的根本所在，在操作大块数据和做偏移时即方便又便捷。因此，操作系统依然使用C语言及指针的特性进行编写。

要明白指针，需要知道几个概念：指针地址、指针类型和指针取值，下面将展开详细说明。

4 Go 语言指针地址和指针类型

每个变量在程序运行时都有一个地址，这个地址代表变量在内存中的位置。

Go 语言中，通过 & 操作符对变量进行 “取地址” 操作，格式如下：

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

上面代码中，v 表示被取地址的变量，取到的地址用变量 p 进行接收， p 的类型为 “*T”, 称为 T 的指针类型。*代表指针。

下面的代码示例，演示了指针的取地址用法:

package main

import "fmt"

func main() {
	// 声明一个整型的 man 变量
	var man int = 1
	// 声明一个字符串类型 domain 变量
	var domain string = "知其黑，受其白 wgchen.blog.csdn.net"

	// 通过 %p 输出 man 和 domain 变量取地址后的指针值，指针值带有 0x 的十六进制前缀
	fmt.Printf("%p %p", &man, &domain)
}

PS E:\golang\src> go run .\main.go
0xc00000e098 0xc000050250
PS E:\golang\src>

注意：代码每次运行的结果是不同的，表示 man 和 domain 两个变量在运行时的地址。

在 32 位平台上，运行结果是 32 位地址；在 64 位平台上，运行结果是 64 位地址。

总结: 变量、指针和地址三者的关系是：每个变量都拥有地址，指针的值表示这个地址。

5 获取指针指向的值

我们已经知道了如何通过 & 获取变量的指针，那么要如何通过指针取值呢？

代码如下：

package main

import "fmt"

func main() {
	// 准备一个字符串类型的变量
	var domain string = "知其黑，受其白 wgchen.blog.csdn.net"

	// 获取字符串的指针， p 类型为*string
	p := &domain

	// 打印变量 p 的类型
	fmt.Printf("p type: %T\n", p)

	// 打印变量 p 的指针地址
	fmt.Printf("address: %p\n", p)

	// 通过 * 对指针进行取值操作
	value := *p

	// 取值后的类型
	fmt.Printf("value type: %T\n", value)

	// 指针取值后指向变量的值
	fmt.Printf("value type: %s\n", value)
}

PS E:\golang\src> go run .\main.go
p type: *string
address: 0xc000050240
value type: string
value type: 知其黑，受其白 wgchen.blog.csdn.net
PS E:\golang\src>

• &， 取地址操作符，功能是取出变量在内存中的地址；
• *，取值操作符，功能是取出地址指向的实际值。

小结：

变量、指针地址、指针变量、取地址、取值的相互关系和特性如下：

• 对变量进行取地址 (&) 操作，可以获取这个变量的指针变量；
• 指针变量的值是指针地址；
• 对指针变量进行取值 （*） 操作，可以获取指针变量指向的实际值。

6 使用指针修改值

指针不但可以取值，同时还可以修改值。

在前面 Go 语言变量 小节中说到了多重赋值的方法进行数值交互，使用指针同样可以。

代码如下：

package main

import "fmt"

// 数值交换函数
func swap(a, b *int) {
	// 取 a 指针的值，赋给临时变量 t
	t := *a

	// 取 b 指针的值，赋给 a 指针指向的变量
	*a = *b

	// 将 a 指针的值赋给 b 指针指向的变量
	*b = t
}

func main() {
	// 声明两个变量 x, y, 值分别为 1，2
	x, y := 1, 2

	// 交换变量值
	swap(&x, &y)

	// 输出交换后的 x, y 值
	fmt.Println(x, y)
}

PS E:\golang\src> go run .\main.go
2 1
PS E:\golang\src>

假设，我们在上面 swap() 函数中交换的是指针值，情况会如何呢?

package main

import "fmt"

func swap(a, b *int) {
	b, a = a, b
}

func main() {
	// 声明两个变量 x, y, 值分别为 1，2
	x, y := 1, 2

	// 交换变量值
	swap(&x, &y)

	// 输出交换后的 x, y 值
	fmt.Println(x, y)
}

PS E:\golang\src> go run .\main.go
1 2
PS E:\golang\src>

可以看到，值交换失败了。

上面 swap() 函数交换的是 a 和 b 的地址，交换完毕后，它们实际指向的值并没有发生改变。

这就好比放在桌子上的两个钱包，将位置交换后，里面存放的钱并没有发现改变一样。

7 通过 new() 函数来创建指针

Go 语言中还提供了 new() 函数来创建指针，格式如下:

new (类型)

代码如下：

package main

import "fmt"

func main() {
	str := new(string)
	*str = "wgchen.blog.csdn.net"

	fmt.Println(*str)
}

PS E:\golang\src> go run .\main.go
wgchen.blog.csdn.net
PS E:\golang\src>

new() 函数可以创建一个对应类型的指针，同时会分配内存。被创建的指针指向的值为默认值。