Go语言基础4 - 数据（基本数据结构）

概述

我们将用几节来学习Go语言基础，本文结构如下：

数据
    new 分配
    构造函数与复合字面
    make 分配
    数组
    切片
    二维切片
    映射
    打印
    追加
 初始化
    常量
    变量
    init 函数

数据

本节包含了 Go 为变量分配内存的方式，和常用的数组，map两种数据结构。

Go提供了两种分配方式，即内建函数 new 和 make。

关键点：

• make 只适用于映射、切片和信道且不返回指针。
• 若要获得明确的指针， 请使用 new 分配内存。

new 分配

new 函数格式为： new(T) 特点：它返回一个指针， 该指针指向新分配的，类型为 T 的零值

内建函数 new 是个用来分配内存的内建函数， 但与其它语言中的同名函数不同，它不会初始化内存，只会将内存置零。

Go 的 new比于java的情形是，java可以通过 new 执行构造来初始化一个对象，而Go不能初始化（赋初值），它只能置为”零值“

也就是说，new(T) 会为类型为 T 的新项分配已置零的内存空间， 并返回它的地址，也就是一个类型为 *T 的值。用Go的术语来说，它返回一个指针， 该指针指向新分配的，类型为 T 的零值。

这样的设计，使得无需像Java那样面对不同对象的丰富多彩的构造函数和参数。

既然 new 返回的内存已置零，就不必进一步初始化了，使用者只需用 new 创建一个新的对象就能正常工作。

例如：

• bytes.Buffer 的文档中提到“零值的 Buffer 就是已准备就绪的缓冲区。"
• sync.Mutex 并没有显式的构造函数或 Init 方法， 而是零值的 sync.Mutex 就已经被定义为已解锁的互斥锁了。

p := new(SyncedBuffer) // type *SyncedBuffer var v SyncedBuffer // type SyncedBuffer

如上的两种方式，都会分配好内存空间，而类型是不同的。

构造函数与复合字面

有些场景下，仍然需要一个初始化构造函数，就像 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
}

上面的代码过于冗长。我们可通过复合字面来简化它：

func NewFile(fd int, name string) *File {
    if fd < 0 {
        return nil
    }
    f := File{fd, name, nil, 0}
    return &f
}

注意 File{fd, name, nil, 0} 这样的写法就是 复合字面的写法。该表达式在每次求值时都会创建新的实例。

复合字面的字段必须按顺序全部列出。但如果以 字段:值对的形式明确地标出元素，初始化字段时就可以按任何顺序出现，未给出的字段值将赋予零值。 因此，我们可以用如下形式：

return &File{fd: fd, name: name}

make 分配

内建函数 make 的格式为： make(T, args) 特点：它只用于创建切片、映射和信道，并返回类型为 T（而非 *T）的一个已初始化 （而非置零）的值。

切片、映射和信道 本质上为引用数据类型，在使用前必须初始化。 例如，切片是一个具有三项内容的描述符，包含一个指向（数组内部）数据的指针、长度以及容量， 在这三项被初始化之前，该切片为 nil。

对于切片、映射和信道，make 用于初始化其内部的数据结构并准备好将要使用的值。

例如： make([]int, 10, 100) 分配一个具有100个 int 的数组空间，接着创建一个长度为10， 容量为100并指向该数组中前10个元素的切片结构 new([]int) 会返回一个指向新分配的，已置零的切片结构， 即一个指向 nil 切片值的指针。

下面的例子阐明了 new 和 make 之间的区别：

var p *[]int = new([]int)       // 分配切片结构；*p == nil；基本没用
var v  []int = make([]int, 100) // 切片 v 现在引用了一个具有 100 个 int 元素的新数组

// 没必要的复杂：
var p *[]int = new([]int)
*p = make([]int, 100, 100)

// 习惯用法：
v := make([]int, 100)

再次说明关键点：

• make 只适用于映射、切片和信道且不返回指针。
• 若要获得明确的指针， 请使用 new 分配内存。

数组

在规划内存布局时，数组是非常有用的，有时还能避免过多的内存分配， 在Go中，数组主要用作切片的构件，在构建切片时使用。

数组在Go和C中的主要区别。在Go中：

• 数组是值。将一个数组赋予另一个数组会复制其所有元素。
• 若将某个数组传入某个函数，它将接收到该数组的一份副本而非指针。
• 数组的大小是其类型的一部分。类型 [10]int 和 [20]int 是不同的。

数组为值的属性很有用，但代价高昂；若你想要C那样的行为和效率，你可以传递一个指向该数组的指针。

在 Go 中，更习惯的的用法是使用 切片。

切片

切片通过对数组进行封装，为有序列的数据提供了更通用、强大而方便的方式。

除了矩阵变换这类需要明确维度的情况外，Go中的大部分数组编程都是通过切片来完成的。

切片保存了对底层数组的引用，若你将某个切片赋予另一个切片，它们会引用同一个数组。 若某个函数将一个切片作为参数传入，则它对该切片元素的修改对调用者而言同样可见， 这可以理解为传递了底层数组的指针。

修改长度：只要切片不超出底层数组的限制，它的长度就是可变的，只需产生新的切片再次指向自身变量即可。

切片的长度：

len(切片)

切片的容量可通过内建函数 cap 获得，它将给出该切片可取得的最大长度。函数为：

  cap(切片)

若数据超出其容量，则会重新分配该切片。返回值即为所得的切片。

向切片追加东西的很常用，因此有专门的内建函数 append。

一般情况下，如果我们要写一个 append 方法的话，最终返回值必须返回切片。示例：

      func Append(slice, data[]byte) []byte {
        l := len(slice)
        if l + len(data) > cap(slice) {  // 重新分配
            // 为了后面的增长，需分配两份。
            newSlice := make([]byte, (l+len(data))*2)
            // copy 函数是预声明的，且可用于任何切片类型。
            copy(newSlice, slice)
            slice = newSlice
        }
        slice = slice[0:l+len(data)]
        for i, c := range data {
            slice[l+i] = c
        }
        return slice
    }

如上，输入参数是切片和插入的元素值，返回值是切片，注意切片的长度会发生变化。 因为尽管 Append 可修改 切片 的元素，但切片自身（其运行时数据结构包含指针、长度和容量）是通过值传递的。

二维切片

要创建等价的二维数组或切片，就必须定义一个数组的数组， 或切片的切片，示例：

type Transform [3][3]float64  // 一个 3x3 的数组，其实是包含多个数组的一个数组。
type LinesOfText [][]byte     // 包含多个字节切片的一个切片。

每行都有其自己的长度： 由于切片长度是可变的，因此其内部可能拥有多个不同长度的切片。

映射 (map)

映射 是Go中 数据结构中的 map结构实现，即 key: value的形式存储。

映射的值可以是各种类型。 映射的键可以是整数、浮点数、复数、字符串、指针、接口等。

映射的键（或者叫索引）可以是任何相等性操作符支持的类型， 如整数、浮点数、复数、字符串、指针、接口（只要其动态类型支持相等性判断）、结构以及数组。 切片不能用作映射键，因为它们的相等性还未定义。与切片一样，映射也是引用类型。

如果将映射作为参数传入函数中，并更改了该映射的内容，则此修改对调用者同样可见。

映射可使用一般的复合字面语法进行构建，其键-值对使用逗号分隔，有点像JSON:

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,
}

获取值：

offset := timeZone["EST"]

注意：若试图通过映射中不存在的键来取值，就会返回与该映射中项的类型对应的零值。例如，若某个映射包含整数，当查找一个不存在的键时会返回 0。

判断某个值是否存在：

seconds, ok = timeZone[tz]

上面是惯用的 "逗号 ok” 法：

• 若 tz 存在， seconds 就会被赋予适当的值，且 ok 会被置为 true； - 若不存在，seconds 则会被置为零，而 ok 会被置为 false。

若仅需判断映射中是否存在某项而不关心实际的值，可使用空白标识符 _ 来代替该值的一般变量。

_, present := timeZone[tz]

要删除映射中的某项，可使用内建函数 delete。即便对应的键不在该映射中，此操作也是安全的。

delete(timeZone, "PDT")  

打印

Go的格式化打印风格和C的 printf 类似，但却更加丰富而通用。 这些函数位于 fmt 包中，且函数名首字母均为大写：如 fmt.Printf、fmt.Fprintf，fmt.Sprintf 等。

看例子：

  // 以f 结尾的这几个，传入格式化字符串作为参数, 不换行
fmt.Printf("hello, %v \n","zhang3")
fmt.Fprintf(os.Stdout,"hello, %v \n","zhang3")
str := fmt.Sprintf("hello, %v \n","zhang3")

//下面这几个，会换行
fmt.Println(str)
// 注意下面这个，会自动在元素间插入空格
fmt.Fprintln(os.Stdout,"f1","f2","f3")

Sprintf 用于构造字符串： 字符串函数（Sprintf 等）会返回一个字符串，而不是写入到数据流中。

Fprint 用于写入到各种流中：fmt.Fprint 一类的格式化打印函数可接受任何实现了 io.Writer 接口的对象作为第一个实参；比如 os.Stdout 与 os.Stderr 。

下面对 Printf 支持的格式化的字符做一些说明： -- 格式： %d 像 %d 不接受表示符号或大小的标记， 会根据实际的类型来决定这些属性。

var x uint64 = 1<<64 - 1 // x 是无符号整数， 下面的 int64(x) 转换为有符合整数
fmt.Printf("%d %x; %d %x\n", x, x, int64(x), int64(x))

将打印

18446744073709551615 ffffffffffffffff; -1 -1

-- 格式： %v %v 可理解为 实际的 value。 它还能打印任意值，甚至包括数组、结构体和映射。

fmt.Printf("%v\n", timeZone)  // 或只用 fmt.Println(timeZone)

这会输出

map[CST:-21600 PST:-28800 EST:-18000 UTC:0 MST:-25200]

%+v 和 %#v 当打印结构体时，格式 %+v 会带上每个字段的字段名，而格式 %#v 会带上类型。

  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)

将打印

&{7 -2.35 abc   def} // 请注意其中的&符号
&{a:7 b:-2.35 c:abc     def} // 有了字段名
&main.T{a:7, b:-2.35, c:"abc\tdef"} //有了类型

-- 格式：%q 当遇到 string 或 []byte 值时， 可使用 %q 产生带引号的字符串；而格式 %#q 会尽可能使用反引号。

--格式：%x %x 还可用于字符串、字节数组以及整数，并生成一个很长的十六进制字符串， 而带空格的格式（% x）还会在字节之间插入空格。

--格式： %T 它会打印某个值的类型.

fmt.Printf("%T\n", timeZone)

会打印

map[string] int

-- 为结构图自定义输出 类似 java 中的 toString()，对结构图自定义类型的默认格式，只需为该类型定义一个具有 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"

-- 任意数量的 Printf 的签名为其最后的实参使用了 ...interface{} 类型，这样格式的后面就能出现任意数量，任意类型的形参了。

func Printf(format string, v ...interface{}) (n int, err error) {

在 Printf 函数的实现中，v 看起来更像是 []interface{} 类型的变量，但如果将它传递到另一个变参函数中，它就像是常规实参列表了。实际上，它直接将其实参传递给 fmt.Sprintln 进行实际的格式化。

// Println 通过 fmt.Println 的方式将日志打印到标准记录器。
func Println(v ...interface{}) {
    std.Output(2, fmt.Sprintln(v...))  // Output 接受形参 (int, string)
}

注意上面的 ...interface{} 和 v... 的写法。

追加 （ append 函数 说明 ）

append 函数的签名就像这样：

func append(slice []T, 元素 ...T) []T

其中的 T 为任意给定类型的占位符。实际上，你无法编写一个类型 T 由调用者决定的函数。这也就是为何 append 为内建函数的原因：它需要编译器的支持。 append 会在切片末尾追加元素并返回结果。我们必须返回结果， 原因是，底层数组可能会被改变（注意数组的长度是类型的一部分）。

以下简单的例子

x := []int{1,2,3}
x = append(x, 4, 5, 6)
fmt.Println(x)

将打印

[1 2 3 4 5 6]

将一个切片追加到另一个切片很简单：在调用的地方使用 ...

x := []int{1,2,3}
y := []int{4,5,6}
x = append(x, y...)
fmt.Println(x)

如果没有 ...，它就会由于类型错误而无法编译，因为 y 不是 int 类型的。三个点符号 “ ... ” 的作用有点像“ 展开 ” 的作用，即将 y这个切片的元素放到了这里。

初始化

GO 的huaGo的初始化很强大，在初始化过程中，不仅可以构建复杂的结构，还能正确处理不同包对象间的初始化顺序。

常量

常量在编译时被创建，即便函数中定义的局部变量也一样。 常量只能是数字、字符（符文）、字符串或布尔值。

由于编译时的限制， 定义它们的表达式必须是可被编译器求值的常量表达式。例如 1<<3 就是一个常量表达式。

枚举常量 枚举常量使用枚举器 iota 创建。由于 iota 可为表达式的一部分，而表达式可以被隐式地重复，这样也就更容易构建复杂的值的集合了。

  type ByteSize float64

  const (
      // 通过赋予空白标识符来忽略第一个值
      _           = iota // ignore first value by assigning to blank identifier
      KB ByteSize = 1 << (10 * iota)
      MB
      GB
      TB
      PB
      EB
      ZB
      YB
  )

变量

变量的初始化与常量类似，但其初始值也可以是在运行时才被计算的一般表达式。

var (
    home   = os.Getenv("HOME")
    user   = os.Getenv("USER")
    gopath = os.Getenv("GOPATH")
)

init 函数

每个源文件都可以通过定义自己的无参数 init 函数来设置一些必要的状态。格式为:

func init() { 
    ...
 }

而 init 方法执行结束，就意味着初始化结束了：只有该包中的所有变量声明都通过它们的初始化器求值后 init 才会被调用， 而那些 init 只有在所有已导入的包都被初始化后才会被求值。

init 函数还常被用在程序真正开始执行前，检验或校正程序的状态。示例：

  func init() {
    if user == "" {
        log.Fatal("$USER not set")
    }
    if home == "" {
        home = "/home/" + user
    }
    if gopath == "" {
        gopath = home + "/go"
    }
    // gopath 可通过命令行中的 --gopath 标记覆盖掉。
    flag.StringVar(&gopath, "gopath", gopath, "override default GOPATH")
  }