变量、常量、类型:Go 为什么不做隐式转换

难度 ★☆☆☆☆ · 前置:第一个 Go 程序:从 go run 到屏幕上那行字 | 一句话结论:名字在声明那一刻就把类型定死了,往后每次落位都要过一遍检查,只有无类型常量能被就地适配。

上一篇那个 main.go 里只有一个 fmt.Println,从头到尾一个变量都没声明,所以类型这件事一个字都没提到。等到写第二个程序,手上有一个已经声明好的整数,想让一个小数变量接住它,随手写下一行 var f float64 = i,编译器甩回来一句报错,位置、变量名、两头的类型全点得清清楚楚。那一刻我才反应过来,Go 对类型这件事的态度和别的语言不太一样,它不打算在背后替我改什么,也不打算猜我的意思。

这篇把整件事从头跑一遍,从两条声明路径开始,到字符串和数字之间那两条窄路结束。

两条声明路径,落点一样

老规矩,新建一个目录,go mod init types,里面就放一个 main.go。两条声明路径摆在一起看最清楚,一条带类型,一条不带。

左边一行写了类型,右边一行没写,值那边也一样,一个空着,一个给了 42。差别全在这两处,别的地方一个字都不差。

1
2
3
4
5
6
7
8
9
10
package main

import "fmt"

func main() {
var x int
y := 42
fmt.Printf("%T %v\n", x, x)
fmt.Printf("%T %v\n", y, y)
}

%T 打类型,%v 打值,想知道一个名字到底是什么东西,看这两样就够。go run . 打出两行,两个 int,一个 0 一个 42。

1
2
3
$ go run .
int 0
int 42

那个 0 不是我写的,是编译器自己填进去的零值,这一点后面单独拿一节讲。

y 拿到 42,还顺带把类型也推了出来,两个 int 一个手写一个推出,长得一样,来源完全不同。

这里有个细节值得停一下。var x int 那个 0 是类型本身带的,谁也没给;y := 42 那个 42 是我给的,类型才是它捎回来的。推断这件事在 Go 里只发生在声明那一刻,名字一旦成立,类型就钉住了,后面再也改不回去,想把 y 改成一个字符串,编译器立刻翻脸。这跟那种名字可以随时换类型的语言是两套世界观,那边的名字是个标签,这边的名字是个容器,做出来的时候是什么形状,以后就只能装什么。

那 := 推的到底是谁的类型?右边那个值的。同一个 := 把右边换成 4.2,推出来是 float64,换成 "hi" 就是 string,换成 'a' 是 int32,因为字符字面量本身就是个 rune。我并没有决定类型,我只是给了个东西,它看是什么就定什么。想通这一层,:= 后面那些规矩就不难懂了:它不是省字的 var,它是一条靠右值倒推的语句,能推的前提是右边有东西可看,能落的地方也受这条语句本身的身份限制。反过来说,var 那条也不是更笨的写法,它是唯一能站在包级作用域上的写法,也是唯一能只写类型不给值的写法。两条路通向同一个终点,可它们能走的区间不一样,一个是声明,一个是语句,这个区别后面会反复冒出来。

三条规矩,挨个验。

:= 从来不是 var 的简写

第一条,:= 只能写在函数体里。包级作用域写一句 y := 42,它给的不是类型错误,是语法错误,而且报错里连冒号等号都没提。

1
2
3
4
5
6
7
8
9
package main

import "fmt"

y := 42

func main() {
fmt.Println(y)
}
1
2
3
$ go run .
# demo
.\main.go:5:1: syntax error: non-declaration statement outside function body

这句话的意思不是不让你在函数外面声明变量,而是这条语句放在外面根本不成立。:= 在语法里算一条语句,包级作用域只收声明,两种东西进不了同一个门。所以包级变量只能写 var,可以省掉类型,不能省掉 var,省掉就是这句报错,跟写错类型一点关系都没有。

第二条是名字。x := 1 之后再来一次 x := 2,报的是 no new variables on left side of :=。这句措辞值得多看一眼,它没说你重复声明了,它说左边没有新变量,可见 := 的本职始终是声明,它得干成一件实事才立得住。顺手验一下,x := 1 之后写 x, z := 3, 4 是合法的,整条语句只要有一个新名字就成立,这也解释了为什么多变量赋值经常这么写。第三条更直接,:= 不许写类型,写成 x int := 1 报 syntax error: unexpected name int at end of statement,那个位置只放表达式。这条其实是第一条的必然结果,既然它是语句,它就没有声明里那个放类型的槽位。三条合起来看,:= 的边界不是从 var 上砍下来的,它们本来就是两种身份不同的东西,只是碰巧都能起名字。

1
2
3
4
5
6
7
8
9
package main

import "fmt"

func main() {
x := 1
x := 2
fmt.Println(x)
}
1
2
3
$ go run .
# demo
.\main.go:7:4: no new variables on left side of :=
1
2
3
4
5
6
7
8
package main

import "fmt"

func main() {
x int := 1
fmt.Println(x)
}
1
2
3
$ go run .
# demo
.\main.go:6:4: syntax error: unexpected name int at end of statement

这里的每一句报错,都是三条规矩中的一条在说话。

三条报错,三处位置,全是语法层面的拦法。

顺手把这三句放在一起看,会发现它们指的位置很有意思。第一句指第 5 行第 1 列,正好是包级那一行开头。第二句指第 7 行第 4 列,正好是第二个 x 后面那两个字符。第三句指第 6 行第 4 列,那是 int 开头的位置。编译器没有在读我的意图,它是在读语法树,报错位置就是它停下脚步的地方。以后看到报错里的行号列号,别急着往下翻代码,先想想那一列上站着的是哪个符号,多半一眼就能对上是哪条规矩被踩了。

声明几个,就给几个值

少给一个,报的是 assignment mismatch: 2 variables but 1 value,左边要几个、右边给了几个,数字都写给你看。反过来把右边写成 1, 2, 3,报的是 extra init expr 3,连多出来的是哪个值都点出来。

1
2
3
4
5
6
7
8
package main

import "fmt"

func main() {
var a, b int = 1
fmt.Println(a, b)
}
1
2
3
$ go run .
# demo
.\main.go:6:17: assignment mismatch: 2 variables but 1 value
1
2
3
4
5
6
7
8
9
10
package main

import "fmt"

func main() {
var a, b int = 1, 2
c, d := 3, "four"
fmt.Println(a, b, c, d)
fmt.Printf("%T %T %T %T\n", a, b, c, d)
}
1
2
3
$ go run .
1 2 3 four
int int int string

数对上了才轮到类型。c, d := 3, "four" 这种混着来的写法很常见,c 是 int,d 是 string,两个名字各拿各的,不用共享一个类型。倒是 var a, b int = 1, 2 里那个 int 得说清楚,它是两个名字共用的,一次声明里类型只能有一个,要么都写要么都不写,所以真要混类型,就别用 var。

这条规矩其实挺省事。

落位那一刻才拦人

声明只负责把类型定下来。

真正的关卡在值落位那一刻,而落位的位置不止一处:变量声明的右边、赋值语句的右边、函数参数、表达式里两边相遇的地方。这几处我都试了一遍,措辞各不相同,拦的动作一模一样。

最典型的是变量声明,左边写死 float64,右边给一个 int 变量,报错原文是这么一行。

1
2
3
4
5
6
7
8
9
package main

import "fmt"

func main() {
var i int = 1
var f float64 = i
fmt.Println(f)
}
1
2
3
$ go run .
# demo
.\main.go:7:18: cannot use i (variable of type int) as float64 value in variable declaration

改成 float64(i),位置一个字没动,就过了。

1
2
3
4
5
6
7
8
9
10
package main

import "fmt"

func main() {
var i int = 1
var f float64 = float64(i)
fmt.Println(f)
fmt.Printf("%T\n", f)
}
1
2
3
$ go run .
1
float64

这个对照值得记住:Go 不是不许 int 变成 float64,它是不许这件事在你不开口的情况下发生。为什么不猜?因为猜错不会有报错,只会有奇怪的结果。int 到 float64 看着无损,反过来要丢小数,一旦允许隐式转换,编译器就得替你决定是截断还是四舍五入,int 和 int64、byte 和 rune,全是同一个形状。让它替你决定,等于把一次本该在编译期停下的错误挪到运行期,变成一行看着正常的输出。同一套检查也管参数,把 i 传给一个要 float64 的函数,报错只把 variable declaration 换成 argument,其余一个字不差。

同一个值挪进表达式,说法又换一副面孔。

1
2
3
4
5
6
7
8
9
package main

import "fmt"

func main() {
var i int = 1
var f float64 = 2
fmt.Println(i + f)
}
1
2
3
$ go run .
# demo
.\main.go:8:14: invalid operation: i + f (mismatched types int and float64)

换了个位置,换了句话,动作没变。

两条声明路径都只负责定类型,真正的关卡在值落位的那一刻

只有无类型常量能就地适配

上面全被拦了,可有些看着很像的写法偏偏能过。

最典型的是这一对,一个放行一个拦下。

1
2
3
4
5
6
7
8
9
10
11
package main

import "fmt"

func main() {
var n int = 'a'
fmt.Printf("%T %v\n", n, n)

var b byte = 'a'
fmt.Printf("%T %v\n", b, b)
}
1
2
3
$ go run .
int 97
uint8 97

'a' 在 Go 里不是字符串,是字符字面量,值就是码点 97。它没有类型,是个常量,落到 int 上按 int 记 97,落到 byte 上按 uint8 记 97,两边都对。

区别在这儿:无类型常量能适配的是同一大类里的类型。

数值常量可以在各个数值类型之间挑一个落下去,可它变不成字符串。数值和字符串在 Go 里是两个不互通的域,中间只留两条窄路,一条叫转换,一条叫解析。适配的范围也不是无限的,const N = 42 落到 int、float64、byte 上都行,可写 var s string = N 照样过不去,报错还会写得更细,连常量的值都念出来:cannot use N (untyped int constant 42) as string value in variable declaration。类型得配得上,值还得装得下,两个条件同时满足它才肯动。

1
2
3
4
5
6
7
8
9
10
11
12
13
package main

import "fmt"

const N = 42

func main() {
var i int = N
var f float64 = N
var b byte = N
fmt.Println(i, f, b)
fmt.Printf("%T %T %T\n", i, f, b)
}
1
2
3
$ go run .
42 42 42
int float64 uint8

至于那个 var s string = 65,它撞的是同一条墙,只是常量换成了数字而已。

常量的类型是算出来的

const Pi = 3.14159 我没写类型,那 Pi 是什么?%T 打出来是 float64,这是 Go 给无类型浮点常量挑的默认类型。

1
2
3
4
5
6
7
8
9
10
11
package main

import "fmt"

const Pi = 3.14159

func main() {
var i int = 2
fmt.Printf("%T %v\n", Pi, Pi)
fmt.Println(Pi * float64(i))
}
1
2
3
$ go run .
float64 3.14159
6.28318

麻烦出在这个默认值上。Pi 要落进某个位置时,会先按那个位置需要的类型试一次,本来是为了让 Pi * f 这种写法自然成立,可它一碰上整数就露馅,var i int = 2 然后写 Pi * i,报的是 Pi (untyped float constant 3.14159) truncated to int。

1
2
3
4
5
6
7
8
9
10
package main

import "fmt"

const Pi = 3.14159

func main() {
var i int = 2
fmt.Println(Pi * i)
}
1
2
3
$ go run .
# demo
.\main.go:9:14: Pi (untyped float constant 3.14159) truncated to int

truncated 这个词是在提醒你,乘出来是 6.28318,要塞进 int 就得砍掉小数,砍小数不是我说的,它不干。写成 Pi * float64(i) 立刻就好。

常量还有个别人没有的本事。

const tenth = 0.1 + 0.2 打出来是 0.3,tenth == 0.3 是 true,同样两个数换成 float64 变量再加,结果是 0.30000000000000004,等不等于是 false。常量做算术用精确值,只在落位那一刻才变浮点。

iota 是另一套东西。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import "fmt"

const (
_ = iota
KB = 1 << (10 * iota)
MB
GB
)

func main() {
fmt.Println(KB, MB, GB)
}
1
2
$ go run .
1024 1048576 1073741824

零值:声明完就有值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main

import "fmt"

func main() {
var i int
var s string
var b bool
var f float64
var r rune
var by byte

fmt.Printf("%T %v\n", i, i)
fmt.Printf("%T %q\n", s, s)
fmt.Printf("%T %v\n", b, b)
fmt.Printf("%T %v\n", f, f)
fmt.Printf("%T %v\n", r, r)
fmt.Printf("%T %v\n", by, by)
fmt.Println(len(s))
}
1
2
3
4
5
6
7
8
$ go run .
int 0
string ""
bool false
float64 0
int32 0
uint8 0
0

每种类型都有自己的底盘,声明时不给值就落到上面,int 是 0,string 是空串,bool 是 false,rune 和 byte 也都是 0。这张表值得背,因为它解释了一个很多人第一次遇到会以为程序坏了的现象:字符串声明完就是空串,len 是 0,可以直接拼可以直接打,不会崩。要紧的是这条保证本身,Go 里不存在一个没有值的位置,声明出来的东西一定有值、一定有类型,你不用操心读到一片内存里剩下的垃圾。代价是你也没法声明一个还没想好的值,一旦声明,它就已经是某个具体的东西了。

字符串和数字之间,老老实实调函数

这里有个坑,看着最不像坑,因为编译器一句话都不会说。

var n int = 65 然后写 string(n),这段能编过,输出是一个 A。它不报错,可它做的和你想的不是一回事,它把 65 当成码点转成字符。

1
2
3
4
5
6
7
8
package main

import "fmt"

func main() {
var n int = 65
fmt.Println(string(n))
}
1
2
$ go run .
A

go vet ./... 专门为这件事警告你,说这种转换给出的是一串单字符,而不是一串数字。想要那两个字符,得走另一条路,用 strconv。Itoa 是 int 到 ASCII 字符串,只返回一个值。Atoi 是反方向,返回两个值,第二个是 error,因为 65 那串字符能解析成 65,65a 不能。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main

import (
"fmt"
"strconv"
)

func main() {
s := strconv.Itoa(65)
fmt.Printf("%T %q\n", s, s)

n, err := strconv.Atoi("65")
fmt.Printf("%T %v %v\n", n, n, err)

bad, err2 := strconv.Atoi("65a")
fmt.Println(bad, err2)
fmt.Printf("%T\n", err2)
}
1
2
3
4
5
$ go run .
string "65"
int 65 <nil>
0 strconv.Atoi: parsing "65a": invalid syntax
*strconv.NumError

成功时是数字和 nil,失败时是 0 和一个说得清原因的 error,那个 0 是占位,别当结果用,先看第二个值是不是 nil。转换和解析是两件事:转换改的是这个值在内存里的解释方式,把一个 float64 的 3.9 转成 int 就是 3,小数部分直接没了,把一个 int 的 300 转成 byte 就是 44,装不下就回绕,这两件都不报错,也不告诉你丢了东西。编译器只拦它当场看得出有损的那种,常量版本直接就在编译期报 cannot convert 3.9 (untyped float constant) to type int,变量版本它拦不住,只能自己盯着。解析读的是一串字符,读不懂就还一个 error 给你,这就是 Atoi 为什么长着两个返回值,它面对的是外部世界,那边什么都可能有。

下一篇离开单行代码,去看分支和循环,那两种语法在 Go 里长得和你想的不太一样。