数据 · Effective Go中文版

[TOC] ## 使用`new`进行分配 Go有两个分配原语，内建函数`new`和`make`。它们所做的事情有所不同，并且用于不同的类型。这会有些令人混淆，但规则其实很简单。我们先讲下`new`。这是一个用来分配内存的内建函数，但是不像在其它语言中，它并不*初始化*内存，只是将其*置零*。也就是说，`new(T)`会为`T`类型的新项目，分配被置零的存储，并且返回它的地址，一个类型为`*T`的值。在Go的术语中，其返回一个指向新分配的类型为`T`，值为零的指针。由于`new`返回的内存是被置零的，这会有助于你将数据结构设计成，每个类型的零值都可以使用，而不需要进一步初始化。这意味着，数据结构的用户可以使用`new`来创建数据，并正确使用。例如，`bytes.Buffer`的文档说道，"`Buffer`的零值是一个可以使用的空缓冲"。类似的，`sync.Mutex`没有显式的构造器和`Init`方法。相反的，`sync.Mutex`的零值被定义为一个未加锁的互斥。 “零值可用”的属性是可以传递的。考虑这个类型声明。 ~~~ type SyncedBuffer struct { lock sync.Mutex buffer bytes.Buffer } ~~~ `SyncedBuffer`类型的值也可以在分配或者声明之后直接使用。在下一个片段中，`p`和`v`都不需要进一步的处理便可以正确地工作。 ~~~ p := new(SyncedBuffer) // type *SyncedBuffer var v SyncedBuffer // type SyncedBuffer ~~~ ## 构造器和复合文字有时候零值并不够好，需要一个初始化构造器（constructor），正如这个源自程序包`os`的例子。 ~~~ func NewFile(fd int, name string) *File { if fd < 0 { return nil } f := new(File) f.fd = fd f.name = name f.dirinfo = nil f.nepipe = 0 return f } ~~~ 有许多这样的模版。我们可以使用*复合文字（composite literal）*进行简化，其为一个表达式，在每次求值的时候会创建一个新实例。 ~~~ func NewFile(fd int, name string) *File { if fd < 0 { return nil } f := File{fd, name, nil, 0} return &f } ~~~ 注意，不像C，返回一个局部变量的地址是绝对没有问题的；变量关联的存储在函数返回之后依然存在。实际上，使用复合文字的地址也会在每次求值时分配一个新的实例，所以，我们可以将最后两行合并起来。 ~~~ return &File{fd, name, nil, 0} ~~~ 复合文字的域按顺序排列，并且必须都存在。然而，通过*field*`:`*value*显式地为元素添加标号，则初始化可以按任何顺序出现，没有出现的则对应为零值。因此，我们可以写成 ~~~ return &File{fd: fd, name: name} ~~~ 作为一种极端情况，如果复合文字根本不包含域，则会为该类型创建一个零值。表达式`new(File)`和`&File{}`是等价的。复合文字还可用于arrays，slices和maps，域标号使用适当的索引或者map key。下面的例子中，不管`Enone`，`Eio`和`Einval`的值是什么，只要它们不同，初始化就可以工作。 ~~~ a := [...]string {Enone: "no error", Eio: "Eio", Einval: "invalid argument"} s := []string {Enone: "no error", Eio: "Eio", Einval: "invalid argument"} m := map[int]string{Enone: "no error", Eio: "Eio", Einval: "invalid argument"} ~~~ ## 使用`make`进行分配回到分配的话题。内建函数`make(T, `*args*`)`与`new(T)`的用途不一样。它只用来创建slice，map和channel，并且返回一个*初始化的*(而不是*置零*)，类型为`T`的值（而不是`*T`）。之所以有所不同，是因为这三个类型的背后是象征着，对使用前必须初始化的数据结构的引用。例如，slice是一个三项描述符，包含一个指向数据（在数组中）的指针，长度，以及容量，在这些项被初始化之前，slice都是`nil`的。对于slice，map和channel，`make`初始化内部数据结构，并准备好可用的值。例如， ~~~ make([]int, 10, 100) ~~~ 分配一个有100个int的数组，然后创建一个长度为10，容量为100的slice结构，并指向数组前10个元素上。（当创建slice时，容量可以省略掉，更多信息参见slice章节。）对应的，`new([]int)`返回一个指向新分配的，被置零的slice结构体的指针，即指向`nil`slice值的指针。这些例子阐释了`new`和`make`之间的差别。 ~~~ var p *[]int = new([]int) // allocates slice structure; *p == nil; rarely useful var v []int = make([]int, 100) // the slice v now refers to a new array of 100 ints // Unnecessarily complex: var p *[]int = new([]int) *p = make([]int, 100, 100) // Idiomatic: v := make([]int, 100) ~~~ 记住`make`只用于map，slice和channel，并且不返回指针。要获得一个显式的指针，使用`new`进行分配，或者显式地使用一个变量的地址。 ## 数组数组可以用于规划内存的精细布局，有时利于避免分配，不过从根本上讲，它们是切片的基本构件，这是下一章节的话题。作为铺垫，这里介绍一下数组。在Go和C中，数组的工作方式有几个重要的差别。在Go中， * 数组是值。将一个数组赋值给另一个，会拷贝所有的元素。 * 特别是，如果你给函数传递一个数组，其将收到一个数组的*拷贝*，而不是它的指针。 * 数组的大小是其类型的一部分。类型`[10]int`和`[20]int`是不同的。数组为值这样的属性，可以很有用处，不过也会有代价；如果你希望类C的行为和效率，可以传递一个数组的指针。 ~~~ func Sum(a *[3]float64) (sum float64) { for _, v := range *a { sum += v } return } array := [...]float64{7.0, 8.5, 9.1} x := Sum(&array) // Note the explicit address-of operator ~~~ 不过，这种风格并不符合Go的语言习惯。相反的，应该使用切片。 ## 切片切片（slice）对数组进行封装，提供了一个针对串行数据，更加通用，强大和方便的接口。除了像转换矩阵这样具有显式维度的项，Go中大多数的数组编程都是通过切片完成，而不是简单数组。切片持有对底层数组的引用，如果你将一个切片赋值给另一个，二者都将引用同一个数组。如果函数接受一个切片参数，那么其对切片的元素所做的改动，对于调用者是可见的，好比是传递了一个底层数组的指针。因此，`Read`函数可以接受一个切片参数，而不是一个指针和一个计数；切片中的长度已经设定了要读取的数据的上限。这是程序包`os`中，`File`类型的`Read`方法的签名： ~~~ func (file *File) Read(buf []byte) (n int, err error) ~~~ 该方法返回读取的字节数和一个错误值，如果存在的话。要读取一个大缓冲`b`中的前32个字节，可以将缓冲进行*切片*（这里是动词）。 ~~~ n, err := f.Read(buf[0:32]) ~~~ 这种切片很常见，而且有效。实际上，如果先不考虑效率，下面的片段也可以读取缓冲的前32个字节。 ~~~ var n int var err error for i := 0; i < 32; i++ { nbytes, e := f.Read(buf[i:i+1]) // Read one byte. if nbytes == 0 || e != nil { err = e break } n += nbytes } ~~~ 只要还符合底层数组的限制，切片的长度就可以进行改变；直接将其赋值给它自己的切片。切片的*容量*，可以通过内建函数`cap`访问，告知切片可以获得的最大长度。这里有一个函数可以为切片增加数据。如果数据超出了容量，则切片会被重新分配，然后返回新产生的切片。该函数利用了一个事实，即当用于`nil`切片时，`len`和`cap`是合法的，并且返回0. ~~~ func Append(slice, data[]byte) []byte { l := len(slice) if l + len(data) > cap(slice) { // reallocate // Allocate double what's needed, for future growth. newSlice := make([]byte, (l+len(data))*2) // The copy function is predeclared and works for any slice type. copy(newSlice, slice) slice = newSlice } slice = slice[0:l+len(data)] for i, c := range data { slice[l+i] = c } return slice } ~~~ 我们必须在后面返回切片，尽管`Append`可以修改`slice`的元素，切片本身（持有指针，长度和容量的运行时数据结构）是按照值传递的。为切片增加元素的想法非常有用，以至于实现了一个内建的`append`函数。不过，要理解该函数的设计，我们还需要一些更多的信息，所以我们放到后面再说。 ## 二维切片 Go的数组和切片都是一维的。要创建等价的二维数组或者切片，需要定义一个数组的数组或者切片的切片，类似这样： ~~~ type Transform [3][3]float64 // A 3x3 array, really an array of arrays. type LinesOfText [][]byte // A slice of byte slices. ~~~ 因为切片是可变长度的，所以可以将每个内部的切片具有不同的长度。这种情况很常见，正如我们的`LinesOfText`例子中：每一行都有一个独立的长度。 ~~~ text := LinesOfText{ []byte("Now is the time"), []byte("for all good gophers"), []byte("to bring some fun to the party."), } ~~~ 有时候是需要分配一个二维切片的，例如这种情况可见于当扫描像素行的时候。有两种方式可以实现。一种是独立的分配每一个切片；另一种是分配单个数组，为其指定单独的切片们。使用哪一种方式取决于你的应用。如果切片们可能会增大或者缩小，则它们应该被单独的分配以避免覆写了下一行；如果不会，则构建单个分配会更加有效。作为参考，这里有两种方式的框架。首先是一次一行： ~~~ // Allocate the top-level slice. picture := make([][]uint8, YSize) // One row per unit of y. // Loop over the rows, allocating the slice for each row. for i := range picture { picture[i] = make([]uint8, XSize) } ~~~ 然后是分配一次，被切片成多行： ~~~ // Allocate the top-level slice, the same as before. picture := make([][]uint8, YSize) // One row per unit of y. // Allocate one large slice to hold all the pixels. pixels := make([]uint8, XSize*YSize) // Has type []uint8 even though picture is [][]uint8. // Loop over the rows, slicing each row from the front of the remaining pixels slice. for i := range picture { picture[i], pixels = pixels[:XSize], pixels[XSize:] } ~~~ ## Maps Map是一种方便，强大的内建数据结构，其将一个类型的值（*key*）与另一个类型的值（*element*或*value*）关联一起。key可以为任何定义了等于操作符的类型，例如整数，浮点和复数，字符串，指针，接口（只要其动态类型支持等于操作），结构体和数组。切片不能作为map的key，因为它们没有定义等于操作。和切片类似，map持有对底层数据结构的引用。如果将map传递给函数，其对map的内容做了改变，则这些改变对于调用者是可见的。 Map可以使用通常的复合文字语法来构建，使用分号分隔key和value，这样很容易在初始化的时候构建它们。 ~~~ var timeZone = map[string]int{ "UTC": 0*60*60, "EST": -5*60*60, "CST": -6*60*60, "MST": -7*60*60, "PST": -8*60*60, } ~~~ 赋值和获取map的值，在语法上看起来跟数组和切片类似，只不过索引不需要为一个整数。 ~~~ offset := timeZone["EST"] ~~~ 尝试使用一个不在map中的key来获取map值，将会返回map中元素相应类型的零值。例如，如果map包含的是整数，则查找一个不存在的key将会返回`0`。可以通过值类型为`bool`的map来实现一个集合。将map项设置为`true`，来将值放在集合中，然后通过简单的索引来进行测试。 ~~~ attended := map[string]bool{ "Ann": true, "Joe": true, ... } if attended[person] { // will be false if person is not in the map fmt.Println(person, "was at the meeting") } ~~~ 有时你需要区分开没有的项和值为零的项。是否有一个项为`"UTC"`，或者由于其根本不在map中，所以为空字符串？你可以通过多赋值的形式来进行辨别。 ~~~ var seconds int var ok bool seconds, ok = timeZone[tz] ~~~ 这被形象的称作为“comma ok”用法。在这个例子中，如果`tz`存在，`seconds`将被设置为适当的值，`ok`将为真；如果不存在，`seconds`将被设置为零，`ok`将为假。这有个例子，并增加了一个友好的错误报告： ~~~ func offset(tz string) int { if seconds, ok := timeZone[tz]; ok { return seconds } log.Println("unknown time zone:", tz) return 0 } ~~~ 如果只测试是否在map中存在，而不关心实际的值，你可以将通常使用变量的地方换成[空白标识符](http://www.hellogcc.org/effective_go.html#blank)（`_`） ~~~ _, present := timeZone[tz] ~~~ 要删除一个map项，使用`delete`内建函数，其参数为map和要删除的key。即使key已经不在map中，这样做也是安全的。 ~~~ delete(timeZone, "PDT") // Now on Standard Time ~~~ ## 打印输出 Go中的格式化打印使用了与C中`printf`家族类似的风格，不过更加丰富和通用。这些函数位于`fmt`程序包中，并具有大写的名字：`fmt.Printf`，`fmt.Fprintf`，`fmt.Sprintf`等等。字符串函数（`Sprintf`等）返回一个字符串，而不是填充到提供的缓冲里。你不需要提供一个格式串。对每个`Printf`，`Fprintf`和`Sprintf`，都有另外一对相应的函数，例如`Print`和`Println`。这些函数不接受格式串，而是为每个参数生成一个缺省的格式。`Println`版本还会在参数之间插入一个空格，并添加一个换行，而`Print`版本只有当两边的操作数都不是字符串的时候才增加一个空格。在这个例子中，每一行都会产生相同的输出。 ~~~ fmt.Printf("Hello %d\n", 23) fmt.Fprint(os.Stdout, "Hello ", 23, "\n") fmt.Println("Hello", 23) fmt.Println(fmt.Sprint("Hello ", 23)) ~~~ 格式化打印函数`fmt.Fprint`等，接受的第一个参数为任何一个实现了`io.Writer`接口的对象；变量`os.Stdout`和`os.Stderr`是常见的实例。接下来这些就和C不同了。首先，数字格式，像`%d`，并不接受正负号和大小的标记；相反的，打印程序使用参数的类型来决定这些属性。 ~~~ var x uint64 = 1<<64 - 1 fmt.Printf("%d %x; %d %x\n", x, x, int64(x), int64(x)) ~~~ 会打印出 ~~~ 18446744073709551615 ffffffffffffffff; -1 -1 ~~~ 如果只是想要缺省的转换，像十进制整数，你可以使用通用格式`%v`（代表“value”）；这正是`Print`和`Println`所产生的结果。而且，这个格式可以打印*任意的*的值，甚至是数组，切片，结构体和map。这是一个针对前面章节中定义的时区map的打印语句 ~~~ fmt.Printf("%v\n", timeZone) // or just fmt.Println(timeZone) ~~~ 其会输出 ~~~ map[CST:-21600 PST:-28800 EST:-18000 UTC:0 MST:-25200] ~~~ 当然，map的key可能会按照任意顺序被输出。当打印一个结构体时，带修饰的格式`%+v`会将结构体的域使用它们的名字进行注解，对于任意的值，格式`%#v`会按照完整的Go语法打印出该值。 ~~~ type T struct { a int b float64 c string } t := &T{ 7, -2.35, "abc\tdef" } fmt.Printf("%v\n", t) fmt.Printf("%+v\n", t) fmt.Printf("%#v\n", t) fmt.Printf("%#v\n", timeZone) ~~~ 会打印出 ~~~ &{7 -2.35 abc def} &{a:7 b:-2.35 c:abc def} &main.T{a:7, b:-2.35, c:"abc\tdef"} map[string] int{"CST":-21600, "PST":-28800, "EST":-18000, "UTC":0, "MST":-25200} ~~~ （注意符号&）还可以通过`%q`来实现带引号的字符串格式，用于类型为`string`或`[]byte`的值。格式`%#q`将尽可能的使用反引号。（格式`%q`还用于整数和符文，产生一个带单引号的符文常量。）还有，`%x`用于字符串，字节数组和字节切片，以及整数，生成一个长的十六进制字符串，并且如果在格式中有一个空格（`% x`），其将会在字节中插入空格。另一个方便的格式是`%T`，其可以打印出值的*类型*。 ~~~ fmt.Printf("%T\n", timeZone) ~~~ 会打印出 ~~~ map[string] int ~~~ 如果你想控制自定义类型的缺省格式，只需要对该类型定义一个签名为`String() string`的方法。对于我们的简单类型`T`，看起来可能是这样的。 ~~~ func (t *T) String() string { return fmt.Sprintf("%d/%g/%q", t.a, t.b, t.c) } fmt.Printf("%v\n", t) ~~~ 会按照如下格式打印 ~~~ 7/-2.35/"abc\tdef" ~~~ （如果你需要打印类型为`T`的*值*，同时需要指向`T`的指针，那么`String`的接收者必须为值类型的；这个例子使用了指针，是因为这对于结构体类型更加有效和符合语言习惯。更多信息参见下面的章节[pointers vs. value receivers](http://www.hellogcc.org/effective_go.html#pointers_vs_values)）我们的`String`方法可以调用`Sprintf`，是因为打印程序是完全可重入的，并且可以按这种方式进行包装。然而，对于这种方式，有一个重要的细节需要明白：不要将调用`Sprintf`的`String`方法构造成无穷递归。如果`Sprintf`调用尝试将接收者直接作为字符串进行打印，就会导致再次调用该方法，发生这样的情况。这是一个很常见的错误，正如这个例子所示。 ~~~ type MyString string func (m MyString) String() string { return fmt.Sprintf("MyString=%s", m) // Error: will recur forever. } ~~~ 这也容易修改：将参数转换为没有方法函数的，基本的字符串类型。 ~~~ type MyString string func (m MyString) String() string { return fmt.Sprintf("MyString=%s", string(m)) // OK: note conversion. } ~~~ 在[初始化章节](http://www.hellogcc.org/effective_go.html#initialization)，我们将会看到另一种避免该递归的技术。另一种打印技术，是将一个打印程序的参数直接传递给另一个这样的程序。`Printf`的签名使用了类型`...interface{}`作为最后一个参数，来指定在格式之后可以出现任意数目的（任意类型的）参数。 ~~~ func Printf(format string, v ...interface{}) (n int, err error) { ~~~ 在函数`Printf`内部，`v`就像是一个类型为`[]interface{}`的变量，但是如果其被传递给另一个可变参数的函数，其就像是一个正常的参数列表。这里有一个对我们上面用到的函数`log.Println`的实现。其将参数直接传递给`fmt.Sprintln`来做实际的格式化。 ~~~ // Println prints to the standard logger in the manner of fmt.Println. func Println(v ...interface{}) { std.Output(2, fmt.Sprintln(v...)) // Output takes parameters (int, string) } ~~~ 我们在嵌套调用`Sprintln`中`v`的后面使用了`...`来告诉编译器将`v`作为一个参数列表；否则，其会只将`v`作为单个切片参数进行传递。除了我们这里讲到的之外，还有很多有关打印的技术。详情参见`godoc`文档中对`fmt`的介绍。顺便说下，`...`参数可以为一个特定的类型，例如`...int`，可以用于最小值函数，来选择整数列表中的最小值： ~~~ func Min(a ...int) int { min := int(^uint(0) >> 1) // largest int for _, i := range a { if i < min { min = i } } return min } ~~~ ## append内建函数现在，我们需要解释下`append`内建函数的设计了。`append`的签名与我们上面定制的`Append`函数不同。简略地讲，类似于这样： ~~~ func append(slice []T, elements ...T) []T ~~~ 其中*T*为任意给定类型的占位符。你在Go中是无法写出一个类型`T`由调用者来确定的函数。这就是为什么`append`是内建的：它需要编译器的支持。 `append`所做的事情是将元素添加到切片的结尾，并返回结果。需要返回结果，是因为和我们手写的`Append`一样，底层的数组可能会改变。这个简单的例子 ~~~ x := []int{1,2,3} x = append(x, 4, 5, 6) fmt.Println(x) ~~~ 会打印出`[1 2 3 4 5 6]`。所以`append`的工作方式有点像`Printf`，搜集任意数目的参数。但是，如果我们想按照我们的`Append`那样做，给切片增加一个切片，那么该怎么办？简单：在调用点使用`...`，就像我们在上面调用`Output`时一样。这个片段会产生和上面相同的输出。 ~~~ x := []int{1,2,3} y := []int{4,5,6} x = append(x, y...) fmt.Println(x) ~~~ 如果没有`...`，则会因为类型错误而无法编译；`y`不是`int`型的。