Go 常量和变量

星期六, 3月 7, 2020 | 12分钟阅读 | 更新于 星期四, 4月 23, 2020

@

一、有名常量和无名常量

各种基本数据类型的字面表示形式(除了false和true)都属于无名常量(unnamed constant),或者叫字面常量(literal constant)。false和true是预声明的两个有名常量。 在Go中,有些值的类型是不确定的。换句话说,有些值的类型有很多可能性。这些值称为类型不确定值。对于大多数类型不确定值来说,它们各自都有一个默认类型,除了预声明的nil。nil是没有默认类型的。与类型不确定值相对应的概念称为类型确定值。无名常量都属于类型不确定值。事实上,Go中大多数的类型不确定值都属于字面常量和有名常量。 一个字面常量的默认类型取决于它的字面表示形式:

  • 一个字符串字面值的默认类型是预声明的string类型。
  • 一个布尔字面值的默认类型是预声明的bool类型。
  • 一个整数型字面值的默认类型是预声明的int类型。
  • 一个rune字面值的默认类型是预声明的rune(亦即int32)类型。
  • 一个浮点数字面值的默认类型是预声明的float64类型。
  • 如果一个字面值含有虚部字面形式,则此字面值的默认类型是预声明的complex128类型。

二、类型不确定常量的显式类型转换

和很多语言一样,Go也支持类型转换。一个显式类型转换的形式为T(v),其表示将一个值v转换为类型T。编译器将T(v)的转换结果视为一个类型为T的类型确定值。当然,对于一个特定的类型T,T(v)并非对任意的值v都合法。

对于一个类型不确定常量值v,有两种情形显式转换T(v)是合法的:

  • v可以表示为T类型的一个值。转换结果为一个类型为T的类型确定常量值。
  • v的默认类型是一个整数类型(int或者rune)并且T是一个字符串类型。转换T(v)将v看作是一个Unicode码点。转换结果为一个类型为T的字符串常量。此字符串常量只包含一个Unicode码点,并且可以看作是此Unicode码点的UTF-8表示形式。对于不在合法的Unicode码点取值范围内的整数v,转换结果等同于字符串字面值"\uFFFD"(亦即"\xef\xbf\xbd")。

事实上,第二种情形并不要求v必须是一个常量。如果v是一个常量,则转换结果也是一个常量。如果v不是一个常量,则转换结果也不是一个常量。 一些合法的转换例子:

// 结果为complex128类型的1.0+0.0i。虚部被舍入了。
complex128(1 + -1e-1000i)
// 结果为float32类型的0.5。这里也舍入了。
float32(0.49999999)
// 只要目标类型不是整数类型,舍入都是允许的。
float32(17000000000000000)
float32(123)
uint(1.0)
int8(-123)
int16(6+0i)
complex128(789)
string(65)          // "A"
string('A')         // "A"
string('\u68ee')    // "森"
string(-1)          // "\uFFFD"
string(0xFFFD)      // "\uFFFD"
string(0x2FFFFFFFF) // "\uFFFD"

下面是一些非法的转换:

int(1.23)     // 1.23不能被表示为int类型值。
uint8(-1)     // -1不能被表示为uint8类型值。
float64(1+2i) // 1+2i不能被表示为float64类型值。
// -1e+1000不能被表示为float64类型值。不允许溢出。
float64(-1e1000)
// 0x10000000000000000做为int值将溢出。
int(0x10000000000000000)
// 字面值65.0的默认类型是float64(不是一个整数类型)。
string(65.0)
// 66+0i的默认类型是complex128(不是一个整数类型)。
string(66+0i)

Go支持类型推断(type deduction or type inference)。 类型推断是指在某些场合下,程序员可以在代码中使用一些类型不确定值, 编译器会自动推断出这些类型不确定值在特定情景下应被视为某些特定类型的值。在Go代码中,如果某处需要一个特定类型的值并且一个类型不确定值可以表示为此特定类型的值, 则此类型不确定值可以使用在此处。Go编译器将此类型不确定值视为此特定类型的类型确定值。 这种情形常常出现在运算符运算、函数调用和赋值语句中。有些场景对某些类型不确定值并没有特定的类型要求。 在这种情况下,Go编译器将这些类型不确定值视为类型为它们各自的默认类型的类型确定值。

三、常量声明(constant declaration)

1、类型不确定有名常量

和无名字面常量一样,有名常量也必须都是布尔、数字或者字符串值。 在Go中,关键字const用来声明有名常量。 下面是一些常量声明的例子。

package main

// 声明了两个单独的有名常量。(是的,
// 非ASCII字符可以用做标识符。)
const π = 3.1416
const Pi = π // 等价于:Pi == 3.1416

// 声明了一组有名常量。
const (
	No         = !Yes
	Yes        = true
	MaxDegrees = 360
	Unit       = "弧度"
)

func main() {
	// 声明了三个局部有名常量。
	const DoublePi, HalfPi, Unit2 = π * 2, π * 0.5, "度"
}

上面每行含有一个等号=的语句称为一个常量描述(constant specification)。 每个const关键字对应一个常量声明。一个常量声明中可以有若干个常量描述。 上面的例子中含有4个常量声明。除了第3个,其它的常量声明中都各自只有一个常量描述。 第3个常量声明中有4个常量描述。 常量声明中的等号=表示“绑定”而非“赋值”。 每个常量描述将一个或多个字面量绑定到各自对应的有名常量上。 或者说,每个有名常量其实代表着一个字面常量。 注意,常量可以直接声明在包中,也可以声明在函数体中。 声明在函数体中的常量称为局部常量(local constant),直接声明在包中的常量称为包级常量(package-level constant)。 包级常量也常常被称为全局常量。

2、类型确定有名常量

我们可以在声明一些常量的时候指定这些常量的确切类型。 这样声明的常量称为类型确定有名常量。 在下面这个例子中,所有这4个声明的常量都是类型确定的。 X和Y的类型都是float32, A和B的类型都是int64。

const X float32 = 3.14

const (
	A, B int64   = -3, 5
	Y    float32 = 2.718
)

如果一个常量描述中包含多个类型确定常量,则这些常量的类型必然是一样的, 比如上例中的A和B。

我们也可以使用显式类型转换来声明类型确定常量。 下面的例子和上面的例子是完全等价的。

const X = float32(3.14)

const (
	A, B = int64(-3), int64(5)
	Y    = float32(2.718)
)

3、常量声明中的自动补全

在一个包含多个常量描述的常量声明中,除了第一个常量描述,其它后续的常量描述都可以只有标识符部分。 Go编译器将通过照抄前面最紧挨的一个完整的常量描述来自动补全不完整的常量描述。 比如,在编译阶段,编译器会将下面的代码

const (
	X float32 = 3.14
	Y                // 这里必须只有一个标识符
	Z                // 这里必须只有一个标识符

	A, B = "Go", "language"
	C, _
	// 上一行中的空标识符是必需的(如果
	// 上一行是一个不完整的常量描述)。
)

自动补全为

const (
	X float32 = 3.14
	Y float32 = 3.14
	Z float32 = 3.14

	A, B = "Go", "language"
	C, _ = "Go", "language"
)

4、在常量声明中使用iota

iota是Go中预声明(内置)的一个特殊的有名常量。 iota被预声明为0,但是它的值在编译阶段并非恒定。 当此预声明的iota出现在一个常量声明中的时候,它的值在第n个常量描述中的值为n(从0开始)。 所以iota只对含有多个常量描述的常量声明有意义。

iota和常量描述自动补全相结合有的时候能够给Go编程带来很大便利。 比如,下面是一个使用了这两个特性的例子。

package main

func main() {
	const (
		k = 3 // 在此处,iota == 0

		m float32 = iota + .5 // m float32 = 1 + .5
		n                     // n float32 = 2 + .5

		p = 9             // 在此处,iota == 3
		q = iota * 2      // q = 4 * 2
		_                 // _ = 5 * 2
		r                 // r = 6 * 2
		s, t = iota, iota // s, t = 7, 7
		u, v              // u, v = 8, 8
		_, w              // _, w = 9, 9
	)

	const x = iota // x = 0 (iota == 0)
	const (
		y = iota // y = 0 (iota == 0)
		z        // z = 1
	)

	println(m)             // +1.500000e+000
	println(n)             // +2.500000e+000
	println(q, r)          // 8 12
	println(s, t, u, v, w) // 7 7 8 8 9
	println(x, y, z)       // 0 0 1
}

上面的例子只是展示了一下如何使用iota。 在实际编程中,我们应该用有意义的方式使用之。比如:

const (
	Failed = iota - 1 // == -1
	Unknown           // == 0
	Succeeded         // == 1
)

const (
	Readable = 1 << iota // == 1
	Writable             // == 2
	Executable           // == 4
)

四、变量声明和赋值操作语句

变量可以被看作是在运行时刻存储在内存中并且可以被更改的有名字的值。所有的变量值都是类型确定值。当声明一个变量的时候,我们必须在代码中给编译器提供足够的信息来让编译器推断出此变量的确切类型。在一个函数体内声明的变量称为局部变量。 在任何函数体内声明的变量称为包级或者全局变量。 一个局部变量被声明之后至少要被有效使用一次,否则编译器将报错。 包级变量无此限制。 如果一个变量总是被当作赋值语句中的目标值,那么我们认为这个变量没有被有效使用过。 Go语言有两种变量声明形式。一种称为标准形式,另一种称为短声明形式。 短声明形式只能用来声明局部变量。

1、标准变量声明形式

每条标准变量声明形式语句起始于一个var关键字。 每个var关键字跟随着一个变量名。 每个变量名必须为一个标识符。和常量声明一样,多个同类型的变量可以在一条语句中被声明。 下面是几条完整形式的标准变量声明语句。 这些声明确地指定了被声明的变量的类型和初始值。

var lang, website string = "Go", "https://golang.org"
var announceYear int = 2009

除了标准变量声明形式外,有两种简略的声明方式

  • 省略了变量类型(但仍指定了变量的初始值),这时编译器将根据初始值的字面量形式来推断出变量的类型。

  • 省略了初始值(但仍指定了变量类型),这时编译器将使用变量类型的零值做为变量的初始值。 如果一个初始值是一个类型确定值,则对应声明的变量的类型将被推断为此初始值的类型; 如果一个初始值是一个类型不确定值,则对应声明的变量的类型将被推断为此初始值的默认类型。注意在这种变种中,同时声明的多个变量的类型可以不一样。

    // 变量lang和dynamic的类型将被推断为内置类型string和bool。 var lang, dynamic = "Go", false

    // 变量website的类型将被推断为内置类型string。 var website = "https://golang.org"

下例展示了几个省略了初始值的标准变量声明。每个声明的变量的初始值为它们各自的类型的零值。

var lang, website string      // 两者都被初始化为空字符串。
var n int                     // 被初始化为0。

和常量声明一样,多个变量可以用一对小括号组团在一起被声明。

var (
	lang, bornYear, compiled     = "Go", 2007, true
	announceAt, releaseAt    int = 2009, 2012
	createdBy, website       string
)

2、短变量声明形式

我们也可以用短变量声明形式来声明一些局部变量,出现在一个短声明左侧的项必须都为纯标识符。

package main

func main() {
	// 变量lang和year都为新声明的变量。
	lang, year := "Go language", 2007

	// 这里,只有变量createdBy是新声明的变量。
	// 变量year已经在上面声明过了,所以这里仅仅
	// 改变了它的值,或者说它被重新声明了。
	year, createdBy := 2009, "Google Research"

	// 这是一个纯赋值语句。
	lang, year = "Go", 2012

	print(lang, "由", createdBy, "发明")
	print("并发布于", year, "年。")
	println()
}

每个短声明语句中必须至少有一个新声明的变量。 短变量声明形式和标准变量声明形式有几个显著的区别:

  • 短声明形式不包含var关键字,并且不能指定变量的类型。
  • 短变量声明中的赋值符号必须为:=。
  • 在一个短声明语句的左侧,已经声明过的变量和新声明的变量可以共存。 但在一个标准声明语句中,所有左侧出现在的变量必须都为新声明的变量。

3、赋值语句

一旦一个变量被声明之后,它的值可以被通过赋值语句来修改。多个变量可以同时在一条赋值语句中被修改。一个赋值语句等号左边的表达式必须是一个可寻址的值、一个映射元素或者一个空标识符。 常量是不可改变的(不可寻址的),所以常量不能做为目标值出现在纯赋值语句的左边,而只能出现在右边用做源值。 变量既可以出现在纯赋值语句的左边用做目标值,也可以出现在右边用做源值。空标识符也可以出现在纯赋值语句的左边,表示不关心对应的目标值。 空标识符不可被用做源值。 一个包含了很多(合法或者不合法的)纯赋值语句的例子:

const N = 123
var x int
var y, z float32

N = 789 // error: N是一个不可变量
y = N   // ok: N被隐式转换为类型float32
x = y   // error: 类型不匹配
x = N   // ok: N被隐式转换为类型int
y = x   // error: 类型不匹配
z = y   // ok
_ = y   // ok

z, y = y, z               // ok
_, y = y, z               // ok
z, _ = y, z               // ok
_, _ = y, z               // ok
x, y = 69, 1.23           // ok
x, y = y, x               // error: 类型不匹配,未显式声明类型转换
x, y = int(y), float32(x) // ok

Go不支持某些其它语言中的连等语法。下面的赋值语句在Go中是不合法的。

var a, b int
a = b = 123 // 语法错误

4、显式类型转换规则

在Go中,两个类型不一样的基本类型值是不能相互赋值的。我们必须使用显式类型转换将一个值转换为另一个值的类型之后才能进行赋值。整数(不论常量还是非常量)都可以被显式转换为字符串类型。

  • 一个非常量浮点数和整数可以显式转换到其它任何一个浮点数和整数类型。
  • 一个非常量复数可以显式转换到其它任何一个复数类型。 常量数字值的类型转换不能溢出。此规则不适用于非常量数字值的类型转换。 非常量数字值的类型转换中,溢出是允许的。 另外当将一个浮点数非常量值(比如一个变量)转换为一个整数类型的时候,舍入(或者精度丢失)也是允许的。 具体规则如下:
  • 当从一个比特位数多的整数类型的非常量整数值向一个比特位数少的整数类型转换的时候,高位的比特将被舍弃,低位的比特将被保留。 我们称这种处理方式为截断(truncated)或者回绕(wrapped around)。
  • 当从一个非常量的浮点数向一个整数类型转换的时候,浮点数的小数部分将被舍弃(向零靠拢)。
  • 当从一个非常量整数或者浮点数向一个浮点数类型转换的时候,精度丢失是可以发生的。
  • 当从一个非常量复数向另一个复数类型转换的时候,精度丢失也是可以发生的。
  • 当一个显式转换涉及到非常量浮点数或者复数数字值时,如果源值溢出了目标类型的表示范围,则转换结果取决于具体编译器实现(即行为未定义)。 在下面的例子中,第7行和第15行的隐式转换是不允许的,第5行和第14行的显式转换也是不允许的。 const a = -1.23 // 变量b的类型被推断为内置类型float64。 var b = a // error: 常量1.23不能被截断舍入到一个整数。 var x = int32(a) // error: float64类型值不能被隐式转换到int32。 var y int32 = b // ok: z == -1,变量z的类型被推断为int32。 // z的小数部分将被舍弃。 var z = int32(b)

const k int16 = 255 var n = k // 变量n的类型将被推断为int16。 var f = uint8(k + 1) // error: 常量256溢出了uint8。 var g uint8 = n + 1 // error: int16值不能隐式转换为uint8。 var h = uint8(n + 1) // ok: h == 0,变量h的类型为uint8。

                 // (n+1)溢出uint8,所以只有低8位
                 // bits(都为0)被保留。

五、变量和常量的作用域和生命周期

作用域是指一个标识符的可见范围。变量(常量)的生命周期指的是在程序运行期间变量有效存在的时间。在Go中,我们可以使用一对大括号来显式形成一个(局部)代码块。一个代码块可以内嵌另一个代码块。最外层的代码块称为包级代码块。一个声明在一个内层代码块中的常量或者变量将遮挡另一个外层代码块中声明的同名变量或者常量。变量的生命周期与变量的作用域有着不可分割的联系。根据变量(常量、类型或函数)定义位置的不同,可以分为以下三个类型:

  • 代码块内定义的变量称为局部变量:生命周期则是动态的,从创建这个变量的声明语句开始,到这个变量不再被引用为止
  • 代码块外定义的变量称为全局变量:生命周期和整个程序的运行周期是一致的,直到程序结束
  • 函数定义中的形式参数和函数返回值:只在函数调用时才会生效,函数调用结束后就会被销毁,在函数未被调用时,函数的形参并不占用实际的存储单元

© 2026 我的博客

🌱 Powered by Hugo with theme Dream.

关于这个博客

关于博客

记录软件开发过程的一些知识和技巧,提升自我

关于博主

除了才华一无所有~~ 薪尽自然凉~~ 强迫症患者~~ 热爱古风~~