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

变量、常量、类型:Go 为什么不做隐式转换
隔壁老康难度 ★☆☆☆☆ · 前置:第一个 Go 程序:从
go run到屏幕上那行字 | 一句话结论:名字在声明那一刻就把类型定死了,往后每次落位都要过一遍检查,只有无类型常量能被就地适配。
上一篇那个 main.go 里只有一个 fmt.Println,从头到尾一个变量都没声明,所以类型这件事一个字都没提到。等到写第二个程序,手上有一个已经声明好的整数,想让一个小数变量接住它,随手写下一行 var f float64 = i,编译器甩回来一句报错,位置、变量名、两头的类型全点得清清楚楚。那一刻我才反应过来,Go 对类型这件事的态度和别的语言不太一样,它不打算在背后替我改什么,也不打算猜我的意思。
这篇把整件事从头跑一遍,从两条声明路径开始,到字符串和数字之间那两条窄路结束。
两条声明路径,落点一样
老规矩,新建一个目录,go mod init types,里面就放一个 main.go。两条声明路径摆在一起看最清楚,一条带类型,一条不带。
左边一行写了类型,右边一行没写,值那边也一样,一个空着,一个给了 42。差别全在这两处,别的地方一个字都不差。
1 | package main |
%T 打类型,%v 打值,想知道一个名字到底是什么东西,看这两样就够。go run . 打出两行,两个 int,一个 0 一个 42。
1 | $ go run . |
那个 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 | package main |
1 | $ go run . |
这句话的意思不是不让你在函数外面声明变量,而是这条语句放在外面根本不成立。:= 在语法里算一条语句,包级作用域只收声明,两种东西进不了同一个门。所以包级变量只能写 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 | package main |
1 | $ go run . |
1 | package main |
1 | $ go run . |
这里的每一句报错,都是三条规矩中的一条在说话。
三条报错,三处位置,全是语法层面的拦法。
顺手把这三句放在一起看,会发现它们指的位置很有意思。第一句指第 5 行第 1 列,正好是包级那一行开头。第二句指第 7 行第 4 列,正好是第二个 x 后面那两个字符。第三句指第 6 行第 4 列,那是 int 开头的位置。编译器没有在读我的意图,它是在读语法树,报错位置就是它停下脚步的地方。以后看到报错里的行号列号,别急着往下翻代码,先想想那一列上站着的是哪个符号,多半一眼就能对上是哪条规矩被踩了。
声明几个,就给几个值
少给一个,报的是 assignment mismatch: 2 variables but 1 value,左边要几个、右边给了几个,数字都写给你看。反过来把右边写成 1, 2, 3,报的是 extra init expr 3,连多出来的是哪个值都点出来。
1 | package main |
1 | $ go run . |
1 | package main |
1 | $ go run . |
数对上了才轮到类型。c, d := 3, "four" 这种混着来的写法很常见,c 是 int,d 是 string,两个名字各拿各的,不用共享一个类型。倒是 var a, b int = 1, 2 里那个 int 得说清楚,它是两个名字共用的,一次声明里类型只能有一个,要么都写要么都不写,所以真要混类型,就别用 var。
这条规矩其实挺省事。
落位那一刻才拦人
声明只负责把类型定下来。
真正的关卡在值落位那一刻,而落位的位置不止一处:变量声明的右边、赋值语句的右边、函数参数、表达式里两边相遇的地方。这几处我都试了一遍,措辞各不相同,拦的动作一模一样。
最典型的是变量声明,左边写死 float64,右边给一个 int 变量,报错原文是这么一行。
1 | package main |
1 | $ go run . |
改成 float64(i),位置一个字没动,就过了。
1 | package main |
1 | $ go run . |
这个对照值得记住:Go 不是不许 int 变成 float64,它是不许这件事在你不开口的情况下发生。为什么不猜?因为猜错不会有报错,只会有奇怪的结果。int 到 float64 看着无损,反过来要丢小数,一旦允许隐式转换,编译器就得替你决定是截断还是四舍五入,int 和 int64、byte 和 rune,全是同一个形状。让它替你决定,等于把一次本该在编译期停下的错误挪到运行期,变成一行看着正常的输出。同一套检查也管参数,把 i 传给一个要 float64 的函数,报错只把 variable declaration 换成 argument,其余一个字不差。
同一个值挪进表达式,说法又换一副面孔。
1 | package main |
1 | $ go run . |
换了个位置,换了句话,动作没变。
只有无类型常量能就地适配
上面全被拦了,可有些看着很像的写法偏偏能过。
最典型的是这一对,一个放行一个拦下。
1 | package main |
1 | $ go run . |
'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 | package main |
1 | $ go run . |
至于那个 var s string = 65,它撞的是同一条墙,只是常量换成了数字而已。
常量的类型是算出来的
const Pi = 3.14159 我没写类型,那 Pi 是什么?%T 打出来是 float64,这是 Go 给无类型浮点常量挑的默认类型。
1 | package main |
1 | $ go run . |
麻烦出在这个默认值上。Pi 要落进某个位置时,会先按那个位置需要的类型试一次,本来是为了让 Pi * f 这种写法自然成立,可它一碰上整数就露馅,var i int = 2 然后写 Pi * i,报的是 Pi (untyped float constant 3.14159) truncated to int。
1 | package main |
1 | $ go run . |
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 | package main |
1 | $ go run . |
零值:声明完就有值
1 | package main |
1 | $ go run . |
每种类型都有自己的底盘,声明时不给值就落到上面,int 是 0,string 是空串,bool 是 false,rune 和 byte 也都是 0。这张表值得背,因为它解释了一个很多人第一次遇到会以为程序坏了的现象:字符串声明完就是空串,len 是 0,可以直接拼可以直接打,不会崩。要紧的是这条保证本身,Go 里不存在一个没有值的位置,声明出来的东西一定有值、一定有类型,你不用操心读到一片内存里剩下的垃圾。代价是你也没法声明一个还没想好的值,一旦声明,它就已经是某个具体的东西了。
字符串和数字之间,老老实实调函数
这里有个坑,看着最不像坑,因为编译器一句话都不会说。
var n int = 65 然后写 string(n),这段能编过,输出是一个 A。它不报错,可它做的和你想的不是一回事,它把 65 当成码点转成字符。
1 | package main |
1 | $ go run . |
go vet ./... 专门为这件事警告你,说这种转换给出的是一串单字符,而不是一串数字。想要那两个字符,得走另一条路,用 strconv。Itoa 是 int 到 ASCII 字符串,只返回一个值。Atoi 是反方向,返回两个值,第二个是 error,因为 65 那串字符能解析成 65,65a 不能。
1 | package main |
1 | $ go run . |
成功时是数字和 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 里长得和你想的不太一样。












