文章目录
一、Go语言变量的声明(使用var关键字)
Go语言是静态类型语言,因此变量(variable)是有明确类型的,编译器也会检查变量类型的正确性。在数学概念中,变量表示没有固定值且可改变的数。但从计算机系统实现角度来看,变量是一段或多段用来存储数据的内存。
声明变量的一般形式是使用 var 关键字:
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
还有一种是指针类型:保存的是指向目标变量的地址。指针字面量使用*后跟其指向的类型名表示(*T)。Go同样支持多级指针(例如**T,表示指针的指针),通过在变量名前加&来获取变量的地址。
所有的内存在 Go 中都是经过初始化的。当一个变量被声明之后,系统自动赋予它该类型的零值:
int 为 0,
float 为 0.0,
bool 为 false,
string 为空字符串,
指针为 nil
变量的命名规则遵循骆驼命名法,即首个单词小写,每个新单词的首字母大写,例如:numShips 和 startDate 。
变量的声明有几种形式,通过下面几节进行整理归纳。
1.1、标准格式
Go语言的变量声明的标准格式为:
var 变量名 变量类型
1.2、批量格式
使用关键字 var 和括号,可以将一组变量定义放在一起。如下:
var (
a int
b string
c []float32 // 数组元素都是float32
d func() bool // 定义函数类型返回值是bool类型
e struct { // 定义对象属性类型
x int
}
)
1.3、简短格式
名字 := 表达式
需要注意的是,简短模式(short variable declaration)有以下限制:
- 定义变量,同时显式初始化。
- 不能提供数据类型。
- 只能用在函数内部。
和 var 形式声明语句一样,简短变量声明语句也可以用来声明和初始化一组变量:
i, j := 0, 1
package main
import "fmt"
var a string
var (
b int
c int
)
func main() {
/* 测试变量 */
a = 4 //故意赋值错误类型,报错:cannot use 4 (type untyped int) as type string in assignment
b = "golang" //故意赋值错误类型,报错:cannot use "golang" (type untyped string) as type int in assignment
c = 10
d := 15
f,g := 6, "测试"
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Println(d)
fmt.Println(f)
fmt.Println(g)
}
因为简洁和灵活的特点,简短变量声明被广泛用于大部分的局部变量的声明和初始化。var 形式的声明语句往往是用于需要显式指定变量类型地方,或者因为变量稍后会被重新赋值而初始值无关紧要的地方。
二、Go语言变量的初始化
Go语言在声明变量时,自动对变量对应的内存区域进行初始化操作。每个变量会初始化其类型的默认值,例如:
- 整型和浮点型变量的默认值为 0 和 0.0。
- 字符串变量的默认值为空字符串。
- 布尔型变量默认为 bool。
- 切片、函数、指针变量的默认为 nil。
当然,依然可以在变量声明时赋予变量一个初始值。
2.1、变量初始化的标准格式
var 变量名 类型 = 表达式
如下:
var student-name string = "xiaozhang"
2.2、编译器推导类型的格式
在标准格式的基础上,将 int 省略后,编译器会尝试根据等号右边的表达式推导 hp 变量的类型。这就类似于python 的变量初始化了。等号右边的部分在编译原理里被称做右值(rvalue)
var student-name = "xiaozhang"
如下:
var attack = 40
var defence = 20
var damageRate float32 = 0.17
var damage = float32(attack-defence) * damageRate
fmt.Println(damage)
/*
第 1 和 2 行,右值为整型,attack 和 defence 变量的类型为 int。
第 3 行,表达式的右值中使用了 0.17。由于Go语言和C语言一样,编译器会尽量提高精确度,以避免计算中的精度损失。所以这里如果不指定 damageRate 变量的类型,Go语言编译器会将 damageRate 类型推导为 float64,我们这里不需要 float64 的精度,所以需要强制指定类型为 float32。
第 4 行,将 attack 和 defence 相减后的数值结果依然为整型,使用 float32() 将结果转换为 float32 类型,再与 float32 类型的 damageRate 相乘后,damage 类型也是 float32 类型。
提示:damage 变量的右值是一个复杂的表达式,整个过程既有 attack 和 defence 的运算还有强制类型转换。
第 5 行,输出 damage 的值。
*/
2.3、短变量声明并初始化
student-name string := "xiaozhang"
这是Go语言的推导声明写法,编译器会自动根据右值类型推断出左值的对应类型。
- 注意:由于使用了
:=
,而不是赋值的=
,因此推导声明写法的左值变量必须是没有定义过的变量。若定义过,将会发生编译错误。
如下:
package main
import "fmt"
var a string = "python"
var (
b int
c int
)
func main() {
/* 测试变量 */
a := "golang"
b = 4
c := 51
d := 15
f,g := 6, "测试"
var h string
h := "nihaoi" // no new variables on left side of :=
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Println(d)
fmt.Println(f)
fmt.Println(g)
fmt.Println(h)
}
如上,对全局变量是可以重新赋值,但在函数作用域内是不可以对变量使用:= 重复赋值的
变量声明的形式在开发中的例子较多,比如:
conn, err := net.Dial("tcp","127.0.0.1:8080")
net.Dial
提供按指定协议和地址发起网络连接,这个函数有两个返回值,一个是连接对象(conn),一个是错误对象(err)。如果是标准格式将会变成:
var conn net.Conn
var err error
conn, err = net.Dial("tcp", "127.0.0.1:8080")
因此,短变量声明并初始化的格式在开发中使用比较普遍。
注意:在多个短变量声明和赋值中,至少有一个新声明的变量出现在左值中,即便其他变量名可能是重复声明的,编译器也不会报错,代码如下:
纯文本复制
conn, err := net.Dial("tcp", "127.0.0.1:8080")
conn2, err := net.Dial("tcp", "127.0.0.1:8080")
上面的代码片段,编译器不会报 err 重复定义。
三、Go语言变量交换赋值
交换变量的常见算法需要一个中间变量进行变量的临时保存。用传统方法编写变量交换代码如下:
var a int = 100
var b int = 200
var t int
t = a
a = b
b = t
fmt.Println(a, b)
在计算机刚发明时,内存非常"精贵"。这种变量交换往往是非常奢侈的。于是计算机"大牛"发明了一些算法来避免使用中间变量:
var a int = 100
var b int = 200
a = a ^ b
b = b ^ a
a = a ^ b
fmt.Println(a, b)
这样的算法很多,但是都有一定的数值范围和类型要求。
到了Go语言时,内存不再是紧缺资源,而且写法可以更简单。使用 Go 的"多重赋值"特性,可以轻松完成变量交换的任务:
var a int = 100
var b int = 200
b, a = a, b
fmt.Println(a, b)
多重赋值时,变量的左值和右值按从左到右的顺序赋值。
多重赋值在Go语言的错误处理和函数返回值中会大量地使用。例如使用Go语言进行排序时就需要使用交换,代码如下:
type IntSlice []int
func (p IntSlice) Len() int { return len(p) }
func (p IntSlice) Less(i, j int) bool { return p[i] < p[j] }
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语言匿名变量(没有名字的变量)
在编码过程中,可能会遇到没有名称的变量、类型或方法。虽然这不是必须的,但有时候这样做可以极大地增强代码的灵活性,这些变量被统称为匿名变量。
匿名变量的特点是一个下画线_
,_
本身就是一个特殊的标识符,被称为空白标识符。它可以像其他标识符那样用于变量的声明或赋值(任何类型都可以赋值给它),但任何赋给这个标识符的值都将被抛弃,因此这些值不能在后续的代码中使用,也不可以使用这个标识符作为变量对其它变量进行赋值或运算。使用匿名变量时,只需要在变量声明的地方使用下画线替换即可。例如:
func GetData() (int, int) {
return 100, 200
}
func main(){
a, _ := GetData()
// _, b := GetData()
fmt.Println(a)
// fmt.Println(a, b)
}
GetData()
是一个函数,拥有两个整型返回值。每次调用将会返回 100 和 200 两个数值。
代码说明如下:
- 第 5 行只需要获取第一个返回值,所以将第二个返回值的变量设为下画线(匿名变量)。
- 第 6 行将第一个返回值的变量设为匿名变量。
匿名变量不占用内存空间,不会分配内存。匿名变量与匿名变量之间也不会因为多次声明而无法使用。
匿名变量可以调用返回多个值的函数时值获取一个值
五、Go语言变量的作用域
一个变量(常量、类型或函数)在程序中都有一定的作用范围,称之为作用域。
了解变量的作用域对我们学习Go语言来说是比较重要的,因为Go语言会在编译时检查每个变量是否使用过,一旦出现未使用的变量,就会报编译错误。如果不能理解变量的作用域,就有可能会带来一些不明所以的编译错误。
根据变量定义位置的不同,可以分为以下三个类型:
- 函数内定义的变量称为局部变量
- 函数外定义的变量称为全局变量
- 函数定义中的变量称为形式参数
5.1、局部变量
在函数体内声明的变量称之为局部变量,它们的作用域只在函数体内,函数的参数和返回值变量都属于局部变量。
局部变量不是一直存在的,它只在定义它的函数被调用后存在,函数调用结束后这个局部变量就会被销毁。
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)
}
5.2、全局变量
在函数体外声明的变量称之为全局变量,全局变量只需要在一个源文件中定义,就可以在所有源文件中使用,当然,不包含这个全局变量的源文件需要使用"import"关键字引入全局变量所在的源文件之后才能使用这个全局变量。
全局变量声明必须以 var 关键字开头,如果想要在外部包中使用全局变量的首字母必须大写。
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)
}
Go语言程序中全局变量与局部变量名称可以相同,但是函数体内的局部变量会被优先考虑。
package main
import "fmt"
//声明全局变量
var a float32 = 3.14
func main() {
//声明局部变量
var a int = 3
fmt.Printf("a = %d\n", a)
}
5.3、形式参数
在定义函数时函数名后面括号中的变量叫做形式参数(简称形参)。形式参数只在函数调用时才会生效,函数调用结束后就会被销毁,在函数未被调用时,函数的形参并不占用实际的存储单元,也没有实际值。
形式参数会作为函数的局部变量来使用。
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
}