Golang-基本语法2

http://c.biancheng.net/golang/syntax/

Go语言变量的声明（使用var关键字）

Go语言是静态类型语言，因此变量（variable）是有明确类型的，编译器也会检查变量类型的正确性。在数学概念中，变量表示没有固定值且可改变的数。但从计算机系统实现角度来看，变量是一段或多段用来存储数据的内存。

声明变量的一般形式是使用 var 关键字：

var name type

其中，var 是声明变量的关键字，name 是变量名，type 是变量的类型。

需要注意的是，Go语言和许多编程语言不同，它在声明变量时将变量的类型放在变量的名称之后。这样做的好处就是可以避免像C语言中那样含糊不清的声明形式，例如：int* a, b; 。其中只有 a 是指针而 b 不是。如果你想要这两个变量都是指针，则需要将它们分开书写。而在 Go 中，则可以和轻松地将它们都声明为指针类型：

var a, b *int

Go语言的基本类型有：

  • bool
  • string
  • int、int8、int16、int32、int64
  • uint、uint8、uint16、uint32、uint64、uintptr
  • byte // uint8 的别名
  • rune // int32 的别名 代表一个 Unicode 码
  • float32、float64
  • complex64、complex128


当一个变量被声明之后，系统自动赋予它该类型的零值：int 为 0，float 为 0.0，bool 为 false，string 为空字符串，指针为 nil 等。所有的内存在 Go 中都是经过初始化的。

变量的命名规则遵循骆驼命名法，即首个单词小写，每个新单词的首字母大写，例如：numShips 和 startDate 。

变量的声明有几种形式，通过下面几节进行整理归纳。

标准格式

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

var 变量名 变量类型

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

批量格式

觉得每行都用 var 声明变量比较烦琐？没关系，还有一种为懒人提供的定义变量的方法：

  1. var (
  2. a int
  3. b string
  4. c []float32
  5. d func() bool
  6. e struct {
  7. x int
  8. }
  9. )

使用关键字 var 和括号，可以将一组变量定义放在一起。

简短格式

除 var 关键字外，还可使用更加简短的变量定义和初始化语法。

名字 := 表达式

需要注意的是，简短模式（short variable declaration）有以下限制：

  • 定义变量，同时显式初始化。
  • 不能提供数据类型。
  • 只能用在函数内部。


和 var 形式声明语句一样，简短变量声明语句也可以用来声明和初始化一组变量：

i, j := 0, 1

下面通过一段代码来演示简短格式变量声明的基本样式。

纯文本复制
  1. func main() {
  2. x:=100
  3. a,s:=1, "abc"
  4. }

因为简洁和灵活的特点，简短变量声明被广泛用于大部分的局部变量的声明和初始化。var 形式的声明语句往往是用于需要显式指定变量类型地方，或者因为变量稍后会被重新赋值而初始值无关紧要的地方。

编程最简单的算法之一，莫过于变量交换。交换变量的常见算法需要一个中间变量进行变量的临时保存。用传统方法编写变量交换代码如下：

  1. var a int = 100
  2. var b int = 200
  3. var t int
  5. t = a
  6. a = b
  7. b = t
  9. fmt.Println(a, b)

在计算机刚发明时，内存非常“精贵”。这种变量交换往往是非常奢侈的。于是计算机“大牛”发明了一些算法来避免使用中间变量：

  1. var a int = 100
  2. var b int = 200
  4. a = a ^ b
  5. b = b ^ a
  6. a = a ^ b
  8. fmt.Println(a, b)

这样的算法很多，但是都有一定的数值范围和类型要求。

到了Go语言时，内存不再是紧缺资源，而且写法可以更简单。使用 Go 的“多重赋值”特性，可以轻松完成变量交换的任务：

  1. var a int = 100
  2. var b int = 200
  4. b, a = a, b
  6. fmt.Println(a, b)

多重赋值时，变量的左值和右值按从左到右的顺序赋值。

多重赋值在Go语言的错误处理和函数返回值中会大量地使用。例如使用Go语言进行排序时就需要使用交换，代码如下：

纯文本复制
  1. type IntSlice []int
  3. func (p IntSlice) Len() int { return len(p) }
  4. func (p IntSlice) Less(i, j int) bool { return p[i] < p[j] }
  5. func (p IntSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }

代码说明如下：

  • 第 1 行，将 IntSlice 声明为 []int 类型。
  • 第 3 行，为 IntSlice 类型编写一个 Len 方法，提供切片的长度。
  • 第 4 行，根据提供的 i、j 元素索引，获取元素后进行比较，返回比较结果。
  • 第 5 行，根据提供的 i、j 元素索引，交换两个元素的值。

Go语言变量的作用域

一个变量（常量、类型或函数）在程序中都有一定的作用范围，称之为作用域。

了解变量的作用域对我们学习Go语言来说是比较重要的，因为Go语言会在编译时检查每个变量是否使用过，一旦出现未使用的变量，就会报编译错误。如果不能理解变量的作用域，就有可能会带来一些不明所以的编译错误。

根据变量定义位置的不同，可以分为以下三个类型：

  • 函数内定义的变量称为局部变量
  • 函数外定义的变量称为全局变量
  • 函数定义中的变量称为形式参数


下面就来分别介绍一下。

局部变量

在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，函数的参数和返回值变量都属于局部变量。

局部变量不是一直存在的，它只在定义它的函数被调用后存在，函数调用结束后这个局部变量就会被销毁。

【示例】下面的 main() 函数中使用到了局部变量 a、b、c。

  1. package main
  3. import (
  4. "fmt"
  5. )
  7. func main() {
  8. //声明局部变量 a 和 b 并赋值
  9. var a int = 3
  10. var b int = 4
  11. //声明局部变量 c 并计算 a 和 b 的和
  12. c := a + b
  13. fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
  14. }

运行结果如下所示：

a = 3, b = 4, c = 7

全局变量

在函数体外声明的变量称之为全局变量，全局变量只需要在一个源文件中定义，就可以在所有源文件中使用，当然，不包含这个全局变量的源文件需要使用“import”关键字引入全局变量所在的源文件之后才能使用这个全局变量。

全局变量声明必须以 var 关键字开头，如果想要在外部包中使用全局变量的首字母必须大写。

【示例】下面代码中，第 6 行定义了全局变量 c。

  1. package main
  3. import "fmt"
  5. //声明全局变量
  6. var c int
  8. func main() {
  9. //声明局部变量
  10. var a, b int
  12. //初始化参数
  13. a = 3
  14. b = 4
  15. c = a + b
  17. fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
  18. }

运行结果如下所示：

a = 3, b = 4, c = 7

Go语言程序中全局变量与局部变量名称可以相同，但是函数体内的局部变量会被优先考虑。

  1. package main
  3. import "fmt"
  5. //声明全局变量
  6. var a float32 = 3.14
  8. func main() {
  9. //声明局部变量
  10. var a int = 3
  12. fmt.Printf("a = %d\n", a)
  13. }

运行结果如下所示：

a = 3

形式参数

在定义函数时函数名后面括号中的变量叫做形式参数（简称形参）。形式参数只在函数调用时才会生效，函数调用结束后就会被销毁，在函数未被调用时，函数的形参并不占用实际的存储单元，也没有实际值。

形式参数会作为函数的局部变量来使用。

【示例】下面代码中第 21 行定义了形式参数 a 和 b。

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. //全局变量 a
  8. var a int = 13
  10. func main() {
  11.     //局部变量 a 和 b
  12.     var a int = 3
  13.     var b int = 4
  15.     fmt.Printf("main() 函数中 a = %d\n", a)
  16. fmt.Printf("main() 函数中 b = %d\n", b)
  17.     c := sum(a, b)
  18.     fmt.Printf("main() 函数中 c = %d\n", c)
  19. }
  21. func sum(a, b int) int {
  22.     fmt.Printf("sum() 函数中 a = %d\n", a)
  23.     fmt.Printf("sum() 函数中 b = %d\n", b)
  24.     num := a + b
  25.     return num
  26. }

运行结果如下所示：

main() 函数中 a = 3
main() 函数中 b = 4
sum() 函数中 a = 3
sum() 函数中 b = 4
main() 函数中 c = 7

Go语言的数值类型分为以下几种：整数、浮点数、复数，其中每一种都包含了不同大小的数值类型，例如有符号整数包含 int8、int16、int32、int64 等，每种数值类型都决定了对应的大小范围和是否支持正负符号。本节我们主要介绍一下整数类型。

Go语言同时提供了有符号和无符号的整数类型，其中包括 int8、int16、int32 和 int64 四种大小截然不同的有符号整数类型，分别对应 8、16、32、64 bit（二进制位）大小的有符号整数，与此对应的是 uint8、uint16、uint32 和 uint64 四种无符号整数类型。

此外还有两种整数类型 int 和 uint，它们分别对应特定 CPU 平台的字长（机器字大小），其中 int 表示有符号整数，应用最为广泛，uint 表示无符号整数。实际开发中由于编译器和计算机硬件的不同，int 和 uint 所能表示的整数大小会在 32bit 或 64bit 之间变化。

大多数情况下，我们只需要 int 一种整型即可，它可以用于循环计数器（for 循环中控制循环次数的变量）、数组和切片的索引，以及任何通用目的的整型运算符，通常 int 类型的处理速度也是最快的。

用来表示 Unicode 字符的 rune 类型和 int32 类型是等价的，通常用于表示一个 Unicode 码点。这两个名称可以互换使用。同样，byte 和 uint8 也是等价类型，byte 类型一般用于强调数值是一个原始的数据而不是一个小的整数。

最后，还有一种无符号的整数类型 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。

哪些情况下使用 int 和 uint

程序逻辑对整型范围没有特殊需求。例如，对象的长度使用内建 len() 函数返回，这个长度可以根据不同平台的字节长度进行变化。实际使用中，切片或 map 的元素数量等都可以用 int 来表示。

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

Go语言提供了两种精度的浮点数 float32 和 float64，它们的算术规范由 IEEE754 浮点数国际标准定义，该浮点数规范被所有现代的 CPU 支持。

这些浮点数类型的取值范围可以从很微小到很巨大。浮点数取值范围的极限值可以在 math 包中找到：

  • 常量 math.MaxFloat32 表示 float32 能取到的最大数值，大约是 3.4e38；
  • 常量 math.MaxFloat64 表示 float64 能取到的最大数值，大约是 1.8e308；
  • float32 和 float64 能表示的最小值分别为 1.4e-45 和 4.9e-324。


一个 float32 类型的浮点数可以提供大约 6 个十进制数的精度，而 float64 则可以提供约 15 个十进制数的精度，通常应该优先使用 float64 类型，因为 float32 类型的累计计算误差很容易扩散，并且 float32 能精确表示的正整数并不是很大。

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

浮点数在声明的时候可以只写整数部分或者小数部分，像下面这样：

  1. const e = .71828 // 0.71828
  2. const f = 1. // 1

很小或很大的数最好用科学计数法书写，通过 e 或 E 来指定指数部分：

纯文本复制
  1. const Avogadro = 6.02214129e23 // 阿伏伽德罗常数
  2. const Planck = 6.62606957e-34 // 普朗克常数

用 Printf 函数打印浮点数时可以使用“%f”来控制保留几位小数

纯文本复制
  1. package main
  3. import (
  4.     "fmt"
  5.     "math"
  6. )
  8. func main() {
  9.     fmt.Printf("%f\n", math.Pi)
  10.     fmt.Printf("%.2f\n", math.Pi)
  11. }

运行结果如下所示：

3.141593
3.14

在计算机中，复数是由两个浮点数表示的，其中一个表示实部（real），一个表示虚部（imag）。

Go语言中复数的类型有两种，分别是  complex128（64 位实数和虚数）和 complex64（32 位实数和虚数），其中 complex128 为复数的默认类型。

复数的值由三部分组成 RE + IMi，其中 RE 是实数部分，IM 是虚数部分，RE 和 IM 均为 float 类型，而最后的 i 是虚数单位。

声明复数的语法格式如下所示：

var name complex128 = complex(x, y)

其中 name 为复数的变量名，complex128 为复数的类型，“=”后面的 complex 为Go语言的内置函数用于为复数赋值，x、y 分别表示构成该复数的两个 float64 类型的数值，x 为实部，y 为虚部。

上面的声明语句也可以简写为下面的形式：

name := complex(x, y)

对于一个复数z := complex(x, y)，可以通过Go语言的内置函数real(z) 来获得该复数的实部，也就是 x；通过imag(z) 获得该复数的虚部，也就是 y。

【示例】使用内置的 complex 函数构建复数，并使用 real 和 imag 函数返回复数的实部和虚部：

纯文本复制
  1. var x complex128 = complex(1, 2) // 1+2i
  2. var y complex128 = complex(3, 4) // 3+4i
  3. fmt.Println(x*y) // "(-5+10i)"
  4. fmt.Println(real(x*y)) // "-5"
  5. fmt.Println(imag(x*y)) // "10"

如果大家对复数的运算法则不是很了解，可以查阅《复数运算法则》，其中详细的讲解了复数的加减乘除操作。

复数也可以用==和!=进行相等比较，只有两个复数的实部和虚部都相等的时候它们才是相等的。

Go语言内置的 math/cmplx 包中提供了很多操作复数的公共方法，实际操作中建议大家使用复数默认的 complex128 类型，因为这些内置的包中都使用 complex128 类型作为参数。

一个布尔类型的值只有两种：true 或 false。if 和 for 语句的条件部分都是布尔类型的值，并且==和<等比较操作也会产生布尔型的值。

一元操作符!对应逻辑非操作，因此!true的值为 false，更复杂一些的写法是(!true==false) ==true，实际开发中我们应尽量采用比较简洁的布尔表达式，就像用 x 来表示x==true。

  1. var aVar = 10
  2. aVar == 5 // false
  3. aVar == 10 // true
  4. aVar != 5 // true
  5. aVar != 10 // false

Go语言对于值之间的比较有非常严格的限制，只有两个相同类型的值才可以进行比较，如果值的类型是接口（interface），那么它们也必须都实现了相同的接口。如果其中一个值是常量，那么另外一个值可以不是常量，但是类型必须和该常量类型相同。如果以上条件都不满足，则必须将其中一个值的类型转换为和另外一个值的类型相同之后才可以进行比较。

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

  1. s != "" && s[0] == 'x'

其中 s[0] 操作如果应用于空字符串将会导致 panic 异常。

因为&&的优先级比||高（&& 对应逻辑乘法，|| 对应逻辑加法，乘法比加法优先级要高），所以下面的布尔表达式可以不加小括号：

  1. if 'a' <= c && c <= 'z' ||
  2. 'A' <= c && c <= 'Z' ||
  3. '0' <= c && c <= '9' {
  4. // ...ASCII字母或数字...
  5. }

布尔值并不会隐式转换为数字值 0 或 1，反之亦然，必须使用 if 语句显式的进行转换：

  1. i := 0
  2. if b {
  3. i = 1
  4. }

如果需要经常做类似的转换，可以将转换的代码封装成一个函数，如下所示：

  1. // 如果b为真，btoi返回1；如果为假，btoi返回0
  2. func btoi(b bool) int {
  3. if b {
  4. return 1
  5. }
  6. return 0
  7. }

数字到布尔型的逆转换非常简单，不过为了保持对称，我们也可以封装一个函数：

  1. // itob报告是否为非零。
  2. func itob(i int) bool { return i != 0 }

Go语言中不允许将整型强制转换为布尔型，代码如下：

  1. var n bool
  2. fmt.Println(int(n) * 2)

编译错误，输出如下：

cannot convert n (type bool) to type int

布尔型无法参与数值运算，也无法与其他类型进行转换。

Go语言字符串

一个字符串是一个不可改变的字节序列，字符串可以包含任意的数据，但是通常是用来包含可读的文本，字符串是 UTF-8 字符的一个序列（当字符为 ASCII 码表上的字符时则占用 1 个字节，其它字符根据需要占用 2-4 个字节）。

UTF-8 是一种被广泛使用的编码格式，是文本文件的标准编码，其中包括 XML 和 JSON 在内也都使用该编码。由于该编码对占用字节长度的不定性，在Go语言中字符串也可能根据需要占用 1 至 4 个字节，这与其它编程语言如 C++、Java 或者 Python 不同（Java 始终使用 2 个字节）。Go语言这样做不仅减少了内存和硬盘空间占用，同时也不用像其它语言那样需要对使用 UTF-8 字符集的文本进行编码和解码。

字符串是一种值类型，且值不可变，即创建某个文本后将无法再次修改这个文本的内容，更深入地讲，字符串是字节的定长数组。

定义字符串

可以使用双引号""来定义字符串，字符串中可以使用转义字符来实现换行、缩进等效果，常用的转义字符包括：

  • \n：换行符
  • \r：回车符
  • \t：tab 键
  • \u 或 \U：Unicode 字符
  • \\：反斜杠自身
  1. package main
  3. import (
  4. "fmt"
  5. )
  7. func main() {
  8. var str = "C语言中文网\nGo语言教程"
  9. fmt.Println(str)
  10. }

运行结果为：

C语言中文网
Go语言教程

一般的比较运算符（==、!=、<、<=、>=、>）是通过在内存中按字节比较来实现字符串比较的，因此比较的结果是字符串自然编码的顺序。字符串所占的字节长度可以通过函数 len() 来获取，例如 len(str)。

字符串的内容（纯字节）可以通过标准索引法来获取，在方括号[ ]内写入索引，索引从 0 开始计数：

  • 字符串 str 的第 1 个字节：str[0]
  • 第 i 个字节：str[i - 1]
  • 最后 1 个字节：str[len(str)-1]


需要注意的是，这种转换方案只对纯 ASCII 码的字符串有效。

注意：获取字符串中某个字节的地址属于非法行为，例如 &str[i]。

字符串拼接符“+”

两个字符串 s1 和 s2 可以通过 s := s1 + s2 拼接在一起。将 s2 追加到 s1 尾部并生成一个新的字符串 s。

可以通过下面的方式来对代码中多行的字符串进行拼接：

  1. str := "Beginning of the string " +
  2. "second part of the string"

提示：因为编译器会在行尾自动补全分号，所以拼接字符串用的加号“+”必须放在第一行末尾。

也可以使用“+=”来对字符串进行拼接：

  1. s := "hel" + "lo,"
  2. s += "world!"
  3. fmt.Println(s) //输出 “hello, world!”

字符串实现基于 UTF-8 编码

Go语言中字符串的内部实现使用 UTF-8 编码，通过 rune 类型，可以方便地对每个 UTF-8 字符进行访问。当然，Go语言也支持按照传统的 ASCII 码方式逐字符进行访问。

关于字符串的 UTF-8 字符访问的详细方法，后面的章节将会详细介绍。

定义多行字符串

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

纯文本复制
  1. const str = `第一行
  2. 第二行
  3. 第三行
  4. \r\n
  5. `
  6. fmt.Println(str)

代码运行结果：

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

反引号`，是键盘上 1 键左边的键，两个反引号间的字符串将被原样赋值到 str 变量中。

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

字符串中的每一个元素叫做“字符”，在遍历或者单个获取字符串元素时可以获得字符。

Go语言的字符有以下两种：

  • 一种是 uint8 类型，或者叫 byte 型，代表了 ASCII 码的一个字符。
  • 另一种是 rune 类型，代表一个 UTF-8 字符，当需要处理中文、日文或者其他复合字符时，则需要用到 rune 类型。rune 类型等价于 int32 类型。


byte 类型是 uint8 的别名，对于只占用 1 个字节的传统 ASCII 编码的字符来说，完全没有问题，例如 var ch byte = 'A'，字符使用单引号括起来。

在 ASCII 码表中，A 的值是 65，使用 16 进制表示则为 41，所以下面的写法是等效的：

var ch byte = 65 或 var ch byte = '\x41'      //（\x 总是紧跟着长度为 2 的 16 进制数）

另外一种可能的写法是\后面紧跟着长度为 3 的八进制数，例如 \377。

Go语言同样支持 Unicode（UTF-8），因此字符同样称为 Unicode 代码点或者 runes，并在内存中使用 int 来表示。在文档中，一般使用格式 U+hhhh 来表示，其中 h 表示一个 16 进制数。

在书写 Unicode 字符时，需要在 16 进制数之前加上前缀\u或者\U。因为 Unicode 至少占用 2 个字节，所以我们使用 int16 或者 int 类型来表示。如果需要使用到 4 字节，则使用\u前缀，如果需要使用到 8 个字节，则使用\U前缀。

  1. var ch int = '\u0041'
  2. var ch2 int = '\u03B2'
  3. var ch3 int = '\U00101234'
  4. fmt.Printf("%d - %d - %d\n", ch, ch2, ch3) // integer
  5. fmt.Printf("%c - %c - %c\n", ch, ch2, ch3) // character
  6. fmt.Printf("%X - %X - %X\n", ch, ch2, ch3) // UTF-8 bytes
  7. fmt.Printf("%U - %U - %U", ch, ch2, ch3) // UTF-8 code point

Go语言指针详解，看这一篇文章就够了

与 Java 和 .NET 等编程语言不同，Go语言为程序员提供了控制数据结构指针的能力，但是，并不能进行指针运算。Go语言允许你控制特定集合的数据结构、分配的数量以及内存访问模式，这对于构建运行良好的系统是非常重要的。指针对于性能的影响不言而喻，如果你想要做系统编程、操作系统或者网络应用，指针更是不可或缺的一部分。

指针（pointer）在Go语言中可以被拆分为两个核心概念：

  • 类型指针，允许对这个指针类型的数据进行修改，传递数据可以直接使用指针，而无须拷贝数据，类型指针不能进行偏移和运算。
  • 切片，由指向起始元素的原始指针、元素数量和容量组成。


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

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

C/C++中的指针

说到 C/C++ 中的指针，会让许多人“谈虎色变”，尤其是对指针的偏移、运算和转换。

其实，指针是 C/C++ 语言拥有极高性能的根本所在，在操作大块数据和做偏移时即方便又便捷。因此，操作系统依然使用C语言及指针的特性进行编写。

C/C++ 中指针饱受诟病的根本原因是指针的运算和内存释放，C/C++ 语言中的裸指针可以自由偏移，甚至可以在某些情况下偏移进入操作系统的核心区域，我们的计算机操作系统经常需要更新、修复漏洞的本质，就是为解决指针越界访问所导致的“缓冲区溢出”的问题。

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

认识指针地址和指针类型

一个指针变量可以指向任何一个值的内存地址，它所指向的值的内存地址在 32 和 64 位机器上分别占用 4 或 8 个字节，占用字节的大小与所指向的值的大小无关。当一个指针被定义后没有分配到任何变量时，它的默认值为 nil。指针变量通常缩写为 ptr。

每个变量在运行时都拥有一个地址，这个地址代表变量在内存中的位置。Go语言中使用在变量名前面添加&操作符（前缀）来获取变量的内存地址（取地址操作），格式如下：

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

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

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

  1. package main
  3. import (
  4. "fmt"
  5. )
  7. func main() {
  8. var cat int = 1
  9. var str string = "banana"
  10. fmt.Printf("%p %p", &cat, &str)
  11. }

运行结果：

0xc042052088 0xc0420461b0

代码说明如下：

  • 第 8 行，声明整型变量 cat。
  • 第 9 行，声明字符串变量 str。
  • 第 10 行，使用 fmt.Printf 的动词%p打印 cat 和 str 变量的内存地址，指针的值是带有0x十六进制前缀的一组数据。


提示：变量、指针和地址三者的关系是，每个变量都拥有地址，指针的值就是地址。

从指针获取指针指向的值

当使用&操作符对普通变量进行取地址操作并得到变量的指针后，可以对指针使用*操作符，也就是指针取值，代码如下。

  1. package main
  3. import (
  4. "fmt"
  5. )
  7. func main() {
  9. // 准备一个字符串类型
  10. var house = "Malibu Point 10880, 90265"
  12. // 对字符串取地址, ptr类型为*string
  13. ptr := &house
  15. // 打印ptr的类型
  16. fmt.Printf("ptr type: %T\n", ptr)
  18. // 打印ptr的指针地址
  19. fmt.Printf("address: %p\n", ptr)
  21. // 对指针进行取值操作
  22. value := *ptr
  24. // 取值后的类型
  25. fmt.Printf("value type: %T\n", value)
  27. // 指针取值后就是指向变量的值
  28. fmt.Printf("value: %s\n", value)
  30. }

运行结果：

ptr type: *string
address: 0xc0420401b0
value type: string
value: Malibu Point 10880, 90265

代码说明如下：

  • 第 10 行，准备一个字符串并赋值。
  • 第 13 行，对字符串取地址，将指针保存到变量 ptr 中。
  • 第 16 行，打印变量 ptr 的类型，其类型为 *string。
  • 第 19 行，打印 ptr 的指针地址，地址每次运行都会发生变化。
  • 第 22 行，对 ptr 指针变量进行取值操作，变量 value 的类型为 string。
  • 第 25 行，打印取值后 value 的类型。
  • 第 28 行，打印 value 的值。


取地址操作符&和取值操作符*是一对互补操作符，&取出地址，*根据地址取出地址指向的值。

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

  • 对变量进行取地址操作使用&操作符，可以获得这个变量的指针变量。
  • 指针变量的值是指针地址。
  • 对指针变量进行取值操作使用*操作符，可以获得指针变量指向的原变量的值。

使用指针修改值

通过指针不仅可以取值，也可以修改值。

前面已经演示了使用多重赋值的方法进行数值交换，使用指针同样可以进行数值交换，代码如下：

  1. package main
  3. import "fmt"
  5. // 交换函数
  6. func swap(a, b *int) {
  8. // 取a指针的值, 赋给临时变量t
  9. t := *a
  11. // 取b指针的值, 赋给a指针指向的变量
  12. *a = *b
  14. // 将a指针的值赋给b指针指向的变量
  15. *b = t
  16. }
  18. func main() {
  20. // 准备两个变量, 赋值1和2
  21. x, y := 1, 2
  23. // 交换变量值
  24. swap(&x, &y)
  26. // 输出变量值
  27. fmt.Println(x, y)
  28. }

运行结果：

2 1

代码说明如下：

  • 第 6 行，定义一个交换函数，参数为 a、b，类型都为 *int 指针类型。
  • 第 9 行，取指针 a 的值，并把值赋给变量 t，t 此时是 int 类型。
  • 第 12 行，取 b 的指针值，赋给指针 a 指向的变量。注意，此时*a的意思不是取 a 指针的值，而是“a 指向的变量”。
  • 第 15 行，将 t 的值赋给指针 b 指向的变量。
  • 第 21 行，准备 x、y 两个变量，分别赋值为 1 和 2，类型为 int。
  • 第 24 行，取出 x 和 y 的地址作为参数传给 swap() 函数进行调用。
  • 第 27 行，交换完毕时，输出 x 和 y 的值。


*操作符作为右值时，意义是取指针的值，作为左值时，也就是放在赋值操作符的左边时，表示 a 指针指向的变量。其实归纳起来，*操作符的根本意义就是操作指针指向的变量。当操作在右值时，就是取指向变量的值，当操作在左值时，就是将值设置给指向的变量。

如果在 swap() 函数中交换操作的是指针值，会发生什么情况？可以参考下面代码：

  1. package main
  3. import "fmt"
  5. func swap(a, b *int) {
  6. b, a = a, b
  7. }
  9. func main() {
  10. x, y := 1, 2
  11. swap(&x, &y)
  12. fmt.Println(x, y)
  13. }

运行结果：

1 2

结果表明，交换是不成功的。上面代码中的 swap() 函数交换的是 a 和 b 的地址，在交换完毕后，a 和 b 的变量值确实被交换。但和 a、b 关联的两个变量并没有实际关联。这就像写有两座房子的卡片放在桌上一字摊开，交换两座房子的卡片后并不会对两座房子有任何影响。

示例：使用指针变量获取命令行的输入信息

Go语言内置的 flag 包实现了对命令行参数的解析，flag 包使得开发命令行工具更为简单。

下面的代码通过提前定义一些命令行指令和对应的变量，并在运行时输入对应的参数，经过 flag 包的解析后即可获取命令行的数据。

【示例】获取命令行输入：

  1. package main
  3. // 导入系统包
  4. import (
  5. "flag"
  6. "fmt"
  7. )
  9. // 定义命令行参数
  10. var mode = flag.String("mode", "", "process mode")
  12. func main() {
  14. // 解析命令行参数
  15. flag.Parse()
  17. // 输出命令行参数
  18. fmt.Println(*mode)
  19. }

将这段代码命名为 main.go，然后使用如下命令行运行：

go run main.go --mode=fast

命令行输出结果如下：

fast

代码说明如下：

  • 第 10 行，通过 flag.String，定义一个 mode 变量，这个变量的类型是 *string。后面 3 个参数分别如下：
    • 参数名称：在命令行输入参数时，使用这个名称。
    • 参数值的默认值：与 flag 所使用的函数创建变量类型对应，String 对应字符串、Int 对应整型、Bool 对应布尔型等。
    • 参数说明：使用 -help 时，会出现在说明中。
  • 第 15 行，解析命令行参数，并将结果写入到变量 mode 中。
  • 第 18 行，打印 mode 指针所指向的变量。


由于之前已经使用 flag.String 注册了一个名为 mode 的命令行参数，flag 底层知道怎么解析命令行，并且将值赋给 mode*string 指针，在 Parse 调用完毕后，无须从 flag 获取值，而是通过自己注册的这个 mode 指针获取到最终的值。代码运行流程如下图所示。


图：命令行参数与变量的关系

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

Go语言还提供了另外一种方法来创建指针变量，格式如下：

new(类型)

一般这样写：

  1. str := new(string)
  2. *str = "Go语言教程"
  4. fmt.Println(*str)

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

Go语言常量和const关键字

Go语言中的常量使用关键字 const 定义，用于存储不会改变的数据，常量是在编译时被创建的，即使定义在函数内部也是如此，并且只能是布尔型、数字型（整数型、浮点型和复数）和字符串型。由于编译时的限制，定义常量的表达式必须为能被编译器求值的常量表达式。

常量的定义格式和变量的声明语法类似：const name [type] = value，例如：

const pi = 3.14159 // 相当于 math.Pi 的近似值

在Go语言中，你可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。

  • 显式类型定义： const b string = "abc"
  • 隐式类型定义： const b = "abc"


常量的值必须是能够在编译时就能够确定的，可以在其赋值表达式中涉及计算过程，但是所有用于计算的值必须在编译期间就能获得。

  • 正确的做法：const c1 = 2/3
  • 错误的做法：const c2 = getNumber() // 引发构建错误: getNumber() 用做值


和变量声明一样，可以批量声明多个常量：

  1. const (
  2. e = 2.7182818
  3. pi = 3.1415926
  4. )

所有常量的运算都可以在编译期完成，这样不仅可以减少运行时的工作，也方便其他代码的编译优化，当操作数是常量时，一些运行时的错误也可以在编译时被发现，例如整数除零、字符串索引越界、任何导致无效浮点数的操作等。

常量间的所有算术运算、逻辑运算和比较运算的结果也是常量，对常量的类型转换操作或以下函数调用都是返回常量结果：len、cap、real、imag、complex 和 unsafe.Sizeof。

因为它们的值是在编译期就确定的，因此常量可以是构成类型的一部分，例如用于指定数组类型的长度：

  1. const IPv4Len = 4
  3. // parseIPv4 解析一个 IPv4 地址 (d.d.d.d).
  4. func parseIPv4(s string) IP {
  5. var p [IPv4Len]byte
  6. // ...
  7. }

一个常量的声明也可以包含一个类型和一个值，但是如果没有显式指明类型，那么将从右边的表达式推断类型。在下面的代码中，time.Duration 是一个命名类型，底层类型是 int64，time.Minute 是对应类型的常量。下面声明的两个常量都是 time.Duration 类型，可以通过 %T 参数打印类型信息：

  1. const noDelay time.Duration = 0
  2. const timeout = 5 * time.Minute
  3. fmt.Printf("%T %[1]v\n", noDelay) // "time.Duration 0"
  4. fmt.Printf("%T %[1]v\n", timeout) // "time.Duration 5m0s"
  5. fmt.Printf("%T %[1]v\n", time.Minute) // "time.Duration 1m0s"

如果是批量声明的常量，除了第一个外其它的常量右边的初始化表达式都可以省略，如果省略初始化表达式则表示使用前面常量的初始化表达式，对应的常量类型也是一样的。例如：

  1. const (
  2. a = 1
  3. b
  4. c = 2
  5. d
  6. )
  8. fmt.Println(a, b, c, d) // "1 1 2 2"

如果只是简单地复制右边的常量表达式，其实并没有太实用的价值。但是它可以带来其它的特性，那就是 iota 常量生成器语法。

iota 常量生成器

常量声明可以使用 iota 常量生成器初始化，它用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式。在一个 const 声明语句中，在第一个声明的常量所在的行，iota 将会被置为 0，然后在每一个有常量声明的行加一。

【示例 1】首先定义一个 Weekday 命名类型，然后为一周的每天定义了一个常量，从周日 0 开始。在其它编程语言中，这种类型一般被称为枚举类型。

  1. type Weekday int
  3. const (
  4. Sunday Weekday = iota
  5. Monday
  6. Tuesday
  7. Wednesday
  8. Thursday
  9. Friday
  10. Saturday
  11. )

周日将对应 0，周一为 1，以此类推。

无类型常量

Go语言的常量有个不同寻常之处。虽然一个常量可以有任意一个确定的基础类型，例如 int 或 float64，或者是类似 time.Duration 这样的基础类型，但是许多常量并没有一个明确的基础类型。

编译器为这些没有明确的基础类型的数字常量提供比基础类型更高精度的算术运算，可以认为至少有 256bit 的运算精度。这里有六种未明确类型的常量类型，分别是无类型的布尔型、无类型的整数、无类型的字符、无类型的浮点数、无类型的复数、无类型的字符串。

通过延迟明确常量的具体类型，不仅可以提供更高的运算精度，而且可以直接用于更多的表达式而不需要显式的类型转换。

【示例 2】math.Pi 无类型的浮点数常量，可以直接用于任意需要浮点数或复数的地方：

  1. var x float32 = math.Pi
  2. var y float64 = math.Pi
  3. var z complex128 = math.Pi

如果 math.Pi 被确定为特定类型，比如 float64，那么结果精度可能会不一样，同时对于需要 float32 或 complex128 类型值的地方则需要一个明确的强制类型转换：

纯文本复制
  1. const Pi64 float64 = math.Pi
  3. var x float32 = float32(Pi64)
  4. var y float64 = Pi64
  5. var z complex128 = complex128(Pi64)

对于常量面值，不同的写法可能会对应不同的类型。例如 0、0.0、0i 和 \u0000 虽然有着相同的常量值，但是它们分别对应无类型的整数、无类型的浮点数、无类型的复数和无类型的字符等不同的常量类型。同样，true 和 false 也是无类型的布尔类型，字符串面值常量是无类型的字符串类型。

Go语言关键字与标识符简述

Go语言的词法元素包括 5 种，分别是标识符（identifier）、关键字（keyword）、操作符（operator）、分隔符（delimiter）、字面量（literal），它们是组成Go语言代码和程序的最基本单位。

本节我们主要来介绍一下Go语言中的关键字和标识符。

关键字

关键字即是被Go语言赋予了特殊含义的单词，也可以称为保留字。

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


之所以刻意地将Go语言中的关键字保持的这么少，是为了简化在编译过程中的代码解析。和其它语言一样，关键字不能够作标识符使用。

标识符

标识符是指Go语言对各种变量、方法、函数等命名时使用的字符序列，标识符由若干个字母、下划线_、和数字组成，且第一个字符必须是字母。通俗的讲就是凡可以自己定义的名称都可以叫做标识符。

下划线_是一个特殊的标识符，称为空白标识符，它可以像其他标识符那样用于变量的声明或赋值（任何类型都可以赋值给它），但任何赋给这个标识符的值都将被抛弃，因此这些值不能在后续的代码中使用，也不可以使用_作为变量对其它变量进行赋值或运算。

在使用标识符之前必须进行声明，声明一个标识符就是将这个标识符与常量、类型、变量、函数或者代码包绑定在一起。在同一个代码块内标识符的名称不能重复。

标识符的命名需要遵守以下规则：

  • 由 26 个英文字母、0~9、_组成；
  • 不能以数字开头，例如 var 1num int 是错误的；
  • Go语言中严格区分大小写；
  • 标识符不能包含空格；
  • 不能以系统保留关键字作为标识符，比如 break，if 等等。


命名标识符时还需要注意以下几点：

  • 标识符的命名要尽量采取简短且有意义；
  • 不能和标准库中的包名重复；
  • 为变量、函数、常量命名时采用驼峰命名法，例如 stuName、getVal；


当然Go语言中的变量、函数、常量名称的首字母也可以大写，如果首字母大写，则表示它可以被其它的包访问（类似于 Java 中的 public）；如果首字母小写，则表示它只能在本包中使用 (类似于 Java 中 private）。

在Go语言中还存在着一些特殊的标识符，叫做预定义标识符，如下表所示：

append bool byte cap close complex complex64 complex128 uint16
copy false float32 float64 imag int int8 int16 uint32
int32 int64 iota len make new nil panic uint64
print println real recover string true uint uint8 uintptr


预定义标识符一共有 36 个，主要包含Go语言中的基础数据类型和内置函数，这些预定义标识符也不可以当做标识符来使用。

 

posted @ 2022-04-07 10:58  hanease  阅读(52)  评论(0)  编辑  收藏  举报