Go 的类型声明的设计

Go 的类型声明的设计。

本篇文章为官方文档 Go's Declaration Syntax 的翻译。

引言

刚刚入门 Go 语言的菜鸟们常常会很疑惑，为什么类型声明的语法会与 C 语言家族建立的传统不同。这篇文档将会比较这两种声明的方式，并解释为什么 Go 语言的声明语法要如此设计。

C 的语法

首先我们看看 C 的语法。C 采用了一种不同寻常，但是很聪明的声明语法。我们只需在带有目标变量名的表达式里指明该表达式本身的类型即可，而不需要特定的声明语法。因此

int x;

声明了 x 变量，其类型为 int ：这个表达式 x 的类型为 int 。一般情况下，为了指明新变量的类型，我们要写出一个含有我们要声明的变量的表达式，并且这个表达式的值属于某种基本类型；我们把这个基本类型写到表达式的左边。

所以，声明

int *p;
int a[3];

指明了 p 是一个int类型的指针，因为表达式 *p的类型为 int；而 a 是一个 int 类型的数组，因为 a[3]的类型为 int（这里的索引值不用管，它只是表明数组的长度）。

那函数的类型声明呢？一开始在 C 的函数声明中，参数的类型是写在括号外的，像下面这样：

int main(argc, argv)
    int argc;
    char *argv[];
{ /* ... */ }

如前所述，我们可以看到 main 之所以是函数，是因为表达式 main(argc, argv) 返回 int。在现代记法中我们会写作：

int main(int argc, char *argv[]) { /* ... */ }

因为基本的结构是一样的。

这种聪明的语法在简单类型的声明上表现不错，但实际上很快就能让人犯迷糊。著名的例子就是声明函数指针。按照这套声明规则，我们要写成：

int (*fp)(int a, int b);

这里 fp 之所以是一个函数指针是因为 (*fp)(a, b) 这个表达式将会调用一个函数，并返回 int 类型的值。如果当 fp 的某个参数本身又是一个函数，情况会怎样呢？

int (*fp)(int (*ff)(int x, int y), int b)

这时候读起来就点难了。

当然，我们声明函数时是可以忽略参数名的，因此 main 函数可以声明为：

int main(int, char *[])

回想一下，之前 argv 是这样声明的：

char *argv[]

所以你其实是从声明的中间去掉变量名，从而构造出其变量类型。这样看起来非常不直观，你声明某个 char *[] 类型的变量的时候，竟然要把变量名放在了变量类型的中间。

如果我们忽略掉 fp 所有的参数名会怎样呢：

int (*fp)(int (*)(int, int), int)

你不仅不能直观地知道参数名原本应该放在哪里：

int (*)(int, int)

而且它不能很清楚地表达出，这是一个函数指针声明。我们接着看看，如果返回值也是个函数指针会怎么样？

int (*(*fp)(int (*)(int, int), int))(int, int)

这已经很难看出是关于 fp 的声明了。

你自己还可以构建出比这更复杂的例子，但上面的例子已经足以解释 C 的声明语法引入的复杂性了。

还有一点需要指出，由于类型语法和声明语法是一样的，要解析中间带有类型的表达式会有些难度。这也就是为什么，例如 C 在做类型转换的时候总是要把类型用括号括起来，像这样

(int)M_PI

Go 的语法

非 C 家族的语言通常在声明时使用一种不同的类型语法。虽然它们都有一个分割的符号，但通常还是变量名先出现，然后常常跟着一个冒号。按照这样来写，我们上面的所举的例子就会变成下面这样（一种虚构的，用于说明的语言）：

x: int
p: pointer to int
a: array[3] of int

这样的声明即便有些冗长，当至少是明确的 —— 你只需从左向右读就行。Go 语言所采用的方案就是以此为基础的，但为了追求简洁，Go 语言丢掉了冒号并去掉了部分关键词：

x int
p *int
a [3]int

在 [3]int 和表达式中 a 的用法没有直接的对应关系（我们在下一节会回过头来探讨指针的问题）。你付出了的语法不统一的代价，但获得更明确的语法。

下面我们来考虑函数的问题。虽然在 Go 语言里，main 函数实际上没有参数，但是我们直接改编一下之前的 main 函数的声明：

func main(argc int, argv []string) int

除了 char 类型的数组变成了 string 外，粗略看来和 C 没什么不同，不过自左向右读起来非常顺畅：

• main 函数接受一个 int 变量和 string 类型的 slice 变量，并返回一个int 。
• 如果此时把参数名去掉，它还是很明确 —— 因为参数名总在类型的前面，所以不会引起混淆。

func main(int, *[]byte) int1

这种自左向右的声明的一个好处在于，当类型变得更复杂时，它仍然表示得很明确。下面是一个函数变量的声明（相当于 C 里的函数指针）：

f func(func(int,int) int, int) int

或者当它返回一个函数时：

f func(func(int,int) int, int) func(int, int) int

上面的声明读起来还是很明确，自左向右，当前声明的是哪一个变量名 —— 因为变量名永远在首位。

类型语法和表达式语法带来的差别使得在 Go 语言里调用闭包也变得更简单：

sum := func(a, b int) int { return a+b } (3, 4)

指针

指针有些例外。注意在数组 (array)和切片 (slice) 中，Go 的类型语法把方括号放在了类型的左边，但是在表达式语法中却又把方括号放到了右边：

var a []int
x = a[1]

类似的，Go 的指针沿用了 C 的 * 记法，但是指针类型的写法就不是像上面一样反过来。指针要写成这样：

var p *int
x = *p

而不能写成下面这样：

var p *int
x = p*

因为后缀的 * 可能会和乘法运算混淆，也许我们可以改用 Pascal 的 ^ 标记，像这样

var p ^int
x = p^

我们也许还真的应该把 * 像上面这样改成 ^ （然后用另一个运算符代表 xor），因为在类型和表达式中的 * 前缀确实 许多事都搞得有点复杂。例如，虽然我们可以像下面这样写

[]int("hi")

但在转换时，如果类型是以 * 开头的，就得加上括号：

(*int)(nil)

如果有一天我们愿意放弃用 *作为指针语法的话，那么上面的括号就可以省略了。

因此 Go 的指针语法和 C 是相似的，但这种相似也意味着我们无法彻底避免在文法中使用括号来避免类型和表达式的歧义。

综上所述，我们相信 Go 的类型语法要比 C 的容易懂。特别是当类型比较复杂时。