目录
文章目录
值语义和引用语义
在 C 语言中,所有变量都是值语义的。变量名所指向的内存位置,就是变量值所储存的地方。指针变量亦如此,指针变量名所指向的内存位置,就是储存指针变量值(一个内存地址)的地方。
在 Python 中,所有变量都是引用语义的。变量名所指向的内存位置所存储的内容,实际上是变量值在内存中的地址。
而 Golang 则显式的值语义和引用语义都引入了程序设计中,布尔型、数字类型、字符串类型都属于值语义,变量名指向变量值。当使用 = 赋值运算符将一个变量的值赋值给另一个变量时,如:j = i,实际上是在内存中将变量 i 的数值进行了拷贝:
而 Golang 中更复杂的数据类型通常使用引用语义。一个引用类型的变量 r1 存储的是 r1 的值所在的内存地址,或内存地址中的首地址。当使用赋值语句 r2 = r1 时,只有引用(地址)被复制,如果 r1 的值被改变了,那么这个值的所有引用都会指向被修改后的内容,在这个例子中,r2 也会受到影响:
变量(var)
Golang 使用关键字 var 来声明一个变量。格式如下:
var identifier type
也可以一次声明多个变量,称为 “并行赋值”,也可用于接受多返回值函数的返回值:
var identifier1, identifier2 type
声明全局变量:
// 这种因式分解关键字的写法一般用于声明全局变量
var (
identifier1 type
identifier2 type
)
注意:
- 不可以在同一个代码块中重复声明一个同名变量。
- 在函数块中,不可以仅声明,但不可以一个变量。
- 全局变量是可以仅声明,而不使用的。
- 并行赋值时,可以在赋值运算符的左侧使用空白标识符 “_”,表示抛弃值,常用接受多返回值的函数调用,进行对齐补位。空白标识符的本质是一个只写(wo)变量,你不能得到它的值。这样做是因为 Golang 中你必须使用所有被声明的变量,但有时你并不需要使用从一个函数返回中得到的所有返回值。
变量声明:显式指定数据类型
与 C 语言一般,可以在一条语句中完成变量的声明、定义以及初始化。如果没有初始化,则变量默认为零值。
示例:
package main
import "fmt"
func main() {
var num int
fmt.Println(num)
var name string = "fanguiju"
fmt.Println(name)
}
注意,不同数据类型的零值亦不相同。例如:布尔类型的零值为 false,数值类型的零值为 0,字符串的零值为空(""),以下几种类型为 nil:
var a *int // 声明指针变量
var a []int // 声明数组变量
var a map[string]int // 声明 Map 变量
var a chan int // 声明 channel 变量
var a func(string) int // 声明函数变量,类型为 func(string)
var a error // 声明 error 接口变量
变量声明与定义:根据初始化数值自动判定数据类型
示例:
package main
import "fmt"
func main() {
// var a bool = true
var b = true
fmt.Println(b)
}
变量声明与定义:简短形似,使用 := 运算符
上述可知,Golang 支持在初始化变量的时候省略显式书写数据类型。基于这样的前提,声明语句写上 var 关键字就显得有些多余了。所以,Golang 可以使用 := 赋值运算符来省略书写 var 关键字和数据类型的预定义标识符,是一种简易的写法,通过初始化的数值来确定变量的数据类型。
注意,:= 运算法的简短形式只能在函数中使用,否则编译错误。
示例:
package main
import "fmt"
func main() {
f := "fanguiju" // 相对于:var f string = "fanguiju"
fmt.Println(f)
}
但需要注意的是,:= 运算符的左值必须是新声明的变量。不能使用 := 来为已经声明或定义过的变量进行赋值,会导致编译错误。
var intVal int
intVal := 1 // 编译错误
同时声明多个变量
例如:
var vname1, vname2, vname3 string = "A", "B", "C"
// or
var vname1, vname2, vname3 = "A", "B", "C"
// or
vname1, vname2, vname3 := "A", "B", "C"
常量(const)
Golang 中使用 const 关键字来声明常量,常量的数据类型只可以是:布尔类型、数字类型和字符串类型。
声明格式:
const identifier type = value
与变量声明类似的,可以省略显式书写数据类型:
const b = "abc"
也可以进行并行赋值:
const c_name1, c_name2 = value1, value2
注意,定义常量不能使用 := 运算符。
Golang 内置的标准函数中:len()、cap()、unsafe.Sizeof() 返回的都是一个常量,所以应该直接赋值与一个常量:
package main
import (
"fmt"
"unsafe"
)
// 批量声明定义常量对象
const (
a = "abc"
b = len(a)
c = unsafe.Sizeof(a)
)
func main() {
fmt.Println(a, b, c)
}
结果:
abc 3 16
使用 iota 常量来实现 “枚举类型”
Golang 原生不具备 C 语言中的枚举类型关键字 enum,但可以使用 const 关键字和 iota 常量来实现。
通常的,使用因式分解的方式声明多个常量时,后一个常量成员会继承前一个常量成员的数值(若前一个成员有初始化,后一个成员没有初始化的情况下),如下:
package main
import "fmt"
const (
Unknown = 1
Female
Male
)
func main() {
fmt.Println(Unknown, Female, Male)
}
结果:
1 1 1
再者,iota 是一个特殊的常量,其数值可以被编译器所修改。iota 在 const 关键字出现时会被重置为 0,批量创建常量时,在同一 “批” 中,每新增一行常量声明,就会使 iota 计数一次。所以,iota 的本质可理解为 const 语句块中的行索引。
package main
import "fmt"
const (
a = iota
b = iota
c = iota
)
/* 也可以简写为如下形式:
*
* const (
* a = iota
* b
* c
* )
*/
func main() {
fmt.Println(a, b, c)
}
结果:
0 1 2
示例:
package main
import "fmt"
const (
a = iota // 0
b // 1
c // 2
d = "ha" // 独立值,iota += 1
e // 继承上一个值,iota += 1
f = 100 // 独立值,iota +=1
g // 继承上一个值,iota +=1
h = iota // 7(恢复计数)
i // 8
)
func main() {
fmt.Println(a, b, c, d, e, f, g, h, i)
}
运行结果:
0 1 2 ha ha 100 100 7 8
再看个有趣的的 iota 示例:
package main
import "fmt"
const (
i = 1 << iota // 位左移运算符 1 位
j = 3 << iota // 位左移运算符 2 位
k // 位左移运算符 3 位
l // 位左移运算符 4 位
)
func main() {
fmt.Println("i=", i)
fmt.Println("j=", j)
fmt.Println("k=", k)
fmt.Println("l=", l)
}
结果:
i= 1
j= 6
k= 12
l= 24
简单表述:
i = 1 << iota
:iota 为 0,左移 0 位,二进制 001,不变,仍为 1;j = 3 << iota
:iota 为 1,左移 1 位,二进制 110,即 6;k = 3 << iota
:iota 为 2,左移 2 位,二进制 1100,即 12;l = 3 << iota
:iota 为 3,左移 3 位,二进制 11000,即 24。
作用域
作用域是已声明标识符所表示的常量、类型、变量、函数或包在源代码中的作用范围。
注意,声明了的局部变量必须被引用,否则会触发异常。全局变量则不需要,因为编译器会考虑该全局变量是否会在其他地方被引用。
局部变量
在函数体内声明的变量称之为局部变量,它们的作用域只在函数体内,形式参数和返回值变量也是局部变量。
package main
import "fmt"
func main() {
/* 声明局部变量 */
var a, b, c int
/* 初始化参数 */
a = 10
b = 20
c = a + b
fmt.Printf ("结果: a = %d, b = %d and c = %d\n", a, b, c)
}
全局变量
在函数体外声明的变量称之为全局变量,全局变量可以在整个包甚至外部包(被导出后)使用。全局变量可以在任何函数中使用。
package main
import "fmt"
/* 声明全局变量 */
var g int
func main() {
/* 声明局部变量 */
var a, b int
/* 初始化参数 */
a = 10
b = 20
g = a + b
fmt.Printf("结果: a = %d, b = %d and g = %d\n", a, b, g)
}
注意:当全局变量和局部变量重名时,优先考虑局部变量。
package main
import "fmt"
/* 声明全局变量 */
var g int = 20
func main() {
/* 声明局部变量 */
var g int = 10
fmt.Printf ("结果: g = %d\n", g)
}
结果:
结果: g = 10