Golang 变量

2024-01-09

字数统计: 3.5k字 | 阅读时长≈ 13分

Golang 官方文档: golang.google.cn
C 语言中文网: Golang 简介

Golang 变量的声明

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

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

1	var name type

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

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

1	var a,b *int

Golang 的基本类型有:

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。

变量的声明形式

标准格式，Golang 的变量声明的标准格式为:
1
var name type
变量声明以关键字 var 开头，后面变量名称，再跟变量类型，行尾无须分号结束
批量格式，觉得每行都用 var 声明变量比较繁琐？还有一种为懒人提供的定义变量的方法:
1
2
3
4
5
6
7
8
9
var (
a int
b string
c []float32
d func() bool
e struct {
x int
}
)
使用关键字 var 和括号，可以将一组变量定义放在一起。
简短格式，除 var 关键字外，还可以使用更加简短的变量定义和初始化语法，如下:
1
名字 := 表达式
需要注意的是，简短模式有以下限制:
- 定义变量，同时显式初始化
- 不能提供数据类型
- 只能用在函数内部
和 var 形式声明语句一样，简短变量声明语句也可以用来声明和初始化一组变量:
1
i,j := 0,1
下面通过一段代码来演示简短格式变量声明的基本样式
1
2
3
4
func main() {
x := 100
a,s := 1, "abc"
}

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

变量的初始化

Golang 在声明变量时，自动对变量对应的内存区域进行初始化操作。每个变量会初始化其类型的默认值，例如:

整型和浮点型变量的默认值为 0 和 0.0
字符串变量的默认值为空字符串
布尔型变量的默认值为 false
切片，函数，指针变量的默认值为 nil

变量初始化的标准格式
1
var 变量名类型 = 表达式
例如，游戏中，玩家的血量初始值为 100，可以这样写
1
var hp int = 100
这句代码中，hp 为变量名，类型为 int，hp 的初始值为 100，上面代码中，100 和 int 同为 int 类型，int 可以认为是冗余信息，因此可以进一步简化初始化的写法

编译器推导类型的格式，在标准格式的基础上，将 int 省略后，编译器会尝试根据等号右边的表达式推导出 hp 变量的类型

1	var hp = 100

等号右边的部分在编译原理里被称作右值（rvalue），下面是编译器很具右值推导变量类型完成初始化的例子

package main

import (
    "fmt"
)

var attack = 40   // 右值为整型
var defence = 20  // 右值为整型
var damageRate float32 = 0.17  
// 表达式的右值中使用了 0.17。由于Go语言和C语言一样，编译器会尽量提高精确度，以避免计算中的精度损失。所以这里如果不指定 damageRate 变量的类型，Go语言编译器会将 damageRate 类型推导为 float64，我们这里不需要 float64 的精度，所以需要强制指定类型为 float32。
var damage = float32(attack-defence) * damageRate  
// 将 attack 和 defence 相减后的数值结果依然为整型，使用 float32() 将结果转换为 float32 类型，再与 float32 类型的 damageRate 相乘后，damage 类型也是 float32 类型。

func main() {
    fmt.Println(damage)
}

短变量声明并初始化，var 的变量声明还有一种更为精简的写法。例如:
1
hp := 100
这是 golang 的推导声明写法，编译器会自动根据右值类型推断出左值的对应类型

注意: 由于使用了 :=，而不是赋值的 =，因此推导声明写法的左值变量必须是没有定义过的变量。若定义过，将会发生编译错误。

如果 hp 已经被声明过，但依然使用 := 时，编译器会报错，代码如下
1
2
3
4
5
// 声明 hp 变量
var hp int

// 再次声明并赋值
hp := 10
编译报错如下:
1
2
no new variables on left side of :=
# 意思是，在“:=”的左边没有新变量出现，意思就是“:=”的左边变量已经被声明了。
短变量声明的形式在开发中的例子较多，比如：
1
conn, err := net.Dial("tcp","127.0.0.1:8080")
net.Dial 提供按指定协议和地址发起网络连接，这个函数有两个返回值，一个是连接对象（conn），一个是错误对象（err）。如果是标准格式将会变成：
1
2
3
var conn net.Conn
var err error
conn, err = net.Dial("tcp", "127.0.0.1:8080")
因此，短变量声明并初始化的格式在开发中使用比较普遍。

注意：在多个短变量声明和赋值中，至少有一个新声明的变量出现在左值中，即便其他变量名可能是重复声明的，编译器也不会报错，代码如下：
1
2
conn, err := net.Dial("tcp", "127.0.0.1:8080")
conn2, err := net.Dial("tcp", "127.0.0.1:8080")
上面的代码片段，编译器不会报 err 重复定义。

多个变量同时赋值

编程最简单的算法之一，莫过于变量交换。交换变量的常见算法需要一个中间变量进行变量的临时保存。

用传统方法编写变量交换代码如下
1
2
3
4
5
6
7
8
9
10
var a int = 100
var b int = 200
var t int

func main() {
t = a
a = b
b = t
fmt.Println(a, b)
}
在计算机刚发明时，内存非常“精贵”。这种变量交换往往是非常奢侈的。于是计算机“大牛”发明了一些算法来避免使用中间变量：
1
2
3
4
5
6
7
8
9
var a int = 100
var b int = 200

func main() {
a = a ^ b
b = b ^ a
a = a ^ b
fmt.Println(a, b)
}
这样的算法很多，但是都有一定的数值范围和类型要求。
到了 golang 时，内存不再是紧缺资源，而且写法可以更简单，使用 golang 的多重赋值特性，可以轻松完成变量交换的任务
1
2
3
4
5
6
7
var a int = 100
var b int = 200

func main() {
a, b = b, a
fmt.Println(a, b)
}
多重赋值时，变量的左值和右值按从左到右的顺序赋值。
多重赋值在 golang 的错误处理和函数返回值中会大量地使用。例如使用 golang 进行排序时就需要使用交换，代码如下

type IntSlice []int  // 将 IntSlice 声明为 []int 类型

func (p IntSlice) Len() int { return len(p) }  // 为 IntSlice 类型编写一个 Len 方法,提供切片的长度
func (p IntSlice) Less(i, j int) { return p[i] < p[j] }   // 根据提供的 i, j 元素索引，获取元素后进行比较，返回比较结果
func (p IntSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }  // 根据提供的 i,j 元素索引，交换两个元素的值

匿名变量

在编码过程中，可能会遇到没有名称的变量，类型或方法。虽然这不是必须的，但有时候这样做可以极大地增强代码的灵活性，这些变量被统称为 匿名变量.

匿名变量的特点是一个下画线 _，_ 本身就是一个特殊的标识符，被称为空白标识符。它可以像其他标识符那样用于变量的声明或赋值（任何类型都可以赋值给它），但任何赋给这个标识符的值都将被抛弃，因此这些值不能在后续的代码中使用，也不可以使用这个标识符作为变量对其它变量进行赋值或运算。使用匿名变量时，只需要在变量声明的地方使用下画线替换即可。例如：

func GetData() (int, int) {
    return 100, 200
}

func main(){
    a, _ := GetData()   // 只需要获取第一个返回值，所以第二个返回值的变量设置为下划线(匿名变量)
    _, b := GetData()   // 将第一个返回值的变量设置为匿名变量
    fmt.Println(a, b)   // 打印出的结果为 100 200
}

GetData() 是一个函数，拥有两个整型返回值。每次调用将会返回 100 和 200 两个数值。

注意: 匿名变量不占用内存空间，不会分配内存。匿名变量与匿名变量之间也不会因为多次声明而无法使用。

变量的作用域

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

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

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

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

局部变量

在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，函数的参数和返回值变量都属于局部变量。局部变量不是一直存在的，它只在定义它的函数被调用后存在，函数调用结束后这个局部变量就会被销毁。

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

package main

import (
    "fmt"
)

func main() {
    //声明局部变量 a 和 b 并赋值
    var a int = 3
    var b int = 4
  
    // 声明局部变量 c 并计算 a 和 b 的和
    c := a + b
    fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
}

运行结果如下

1	a = 3, b = 4, c = 7

全局变量

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

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

下面代码中，第六行定义了全局变量 c

package main

import "fmt"

//声明全局变量
var c int

func main() {
    //声明局部变量
    var a, b int

    //初始化参数
    a = 3
    b = 4
    c = a + b

    fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
}

运行结果如下

1	a = 3, b = 4, c = 7

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

package main

import "fmt"

// 声明全局变量
var a float32 = 3.14

func main() {
    // 声明局部变量
    var a int = 3

    fmt.Printf("a = %d\n", a)
}

运行结果如下

a = 3

形式参数

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

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

下面代码中第 21 行定义了形式参数 a 和 b

package main

import (
    "fmt"
)

// 全局变量 a
var a int = 13

func main() {
    // 局部变量 a 和 b
    var a int = 3
    var b int = 4

    fmt.Printf("main() 函数中 a = %d\n", a)
    fmt.Printf("main() 函数中 b = %d\n", b)
    c := sum(a, b)
    fmt.Printf("main() 函数中 c = %d\n", c)
}

func sum(a, b int) int {
    fmt.Printf("sum() 函数中 a = %d\n", a)
    fmt.Printf("sum() 函数中 b = %d\n", b)
    num := a + b
    return num
}

运行结果如下

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