Go 之旅三: 复杂类型

原文链接 http://ironxu.com/709

本文是学习 A Tour of Go (中文参考 Go 之旅中文 ) 整理的笔记，介绍Go 语言的指针，结构体，数组，切片，映射和闭包的基本概念和使用。

1. 指针

$GOPATH/src/go_note/gotour/advancetype/pointer/pointer.go 源码如下:

/** * go 语言指针 */

package main

import (
    "fmt"
)

func main() {
    i,j := 42,36

    p := &i
    fmt.Println(*p) // 42
    *p = 21
    fmt.Println(i) // 21

    p = &j
    *p = *p / 4
    fmt.Println(j) // 9
}

Go 具有指针。 指针保存了变量的内存地址。类型 *T 是指向 T 类型值的指针，其零值为 nil 。

var p *int

& 操作符会生成一个指向其操作数的指针。

i := 42
p = &i

* 操作符表示指针指向的底层值。

fmt.Println(*p) // 通过指针 p 读取 i
*p = 21         // 通过指针 p 设置 i

2. 结构体

$GOPATH/src/go_note/gotour/advancetype/struct/struct.go 源码如下:

package main

import (
    "fmt"
)

type Point struct {
    X int
    Y int
}

var (
    p1  = Point{1, 2}
    p2  = Point{X: 1}
    p3  = Point{}
    pt1 = &Point{1, 2}
)

func main() {
    fmt.Println(Point{1, 2})

    p := Point{3, 4}
    p.X = 4 // 结构体字段使用点号来访问
    fmt.Println(p,p.Y)

    pt := &p
    pt.X = 5 // 使用隐式间接引用，直接写 `pt.X`
    (*pt).Y = 6 // 通过 `(*pt).Y` 来访问其字段 `Y`
    fmt.Println(p)
}

一个结构体（ struct ）就是一个字段的集合，结构体字段使用点号来访问。

2.1 结构体指针

结构体字段可以通过结构体指针来访问。

pt := &p
pt.X = 5
(*pt).Y = 6

如果我们有一个指向结构体的指针 pt ，那么可以通过 (*pt).X 来访问其字段 X，也可以使用隐式间接引用，直接写 pt.X。

2.2 结构体语法

结构体文法通过直接列出字段的值来新分配一个结构体。

使用 Name: 语法可以仅列出部分字段。（字段名的顺序无关。）

特殊的前缀 & 返回一个指向结构体的指针。

var ( p1 = Point{1,2} p2 = Point{X: 1} p3 = Point{} pt1 = &Point{1,2} )

3. 数组

$GOPATH/src/go_note/gotour/advancetype/array/array.go 源码如下:

/** * go 语言数组 */

package main

import (
    "fmt"
)

func main() {
    var a [2]string
    a[0] = "hello"
    a[1] = "world"
    fmt.Println(a,a[0])

    list := [10]int{1,2,3,4}
    fmt.Println(list)
}

类型 [n]T 表示拥有 n 个 T 类型的值的数组。

表达式

var a [10]int // 变量 a 声明为拥有 10 个整数的数组

数组的长度是其类型的一部分，因此数组不能改变大小

4. 切片

$GOPATH/src/go_note/gotour/advancetype/slice/slice.go 源码如下:

/** * go 语言 slice */
package main

import (
    "fmt"
    "strings"
)

func main() {
    primes := [6]int{1, 2, 3, 4, 5, 6}
    var s []int = primes[1:4]
    fmt.Println(s) // [2 3 4]

    names := [4]string{"john","paul","george","ringo"}
    fmt.Println(names) // [john paul george ringo]

    a := names[0:2]
    b := names[1:3]
    fmt.Println(a,b) // [john paul] [paul george]

    b[0] = "xxx"             // 更改切片的元素会修改其底层数组中对应的元素，并且与它共享底层数组的切片都会观测到这些修改
    fmt.Println(a,b,names) // [john xxx] [xxx george] [john xxx george ringo]

    // 默认分片上下界
    i := []int{1, 4}
    fmt.Println(i[0:4]) // [1 2 3 4]
    fmt.Println(i[:4])  // [1 2 3 4]
    fmt.Println(i[0:])  // [1 2 3 4]
    fmt.Println(i[:])   // [1 2 3 4]

    // 长度与容量
    fmt.Printf("len=%d,cap=%d,%vn",len(i[:4]),cap(i[:4]),i[:4])    // len=4,cap=4,[1 2 3 4]
    fmt.Printf("len=%d,len(i[2:4]),cap(i[2:4]),i[2:4]) // len=2,cap=2,[3 4]

    // nil 切片
    var j []int
    fmt.Printf("len=%d,len(j),cap(j),j) // len=0,cap=0,[]

    // make 创建切片
    a_m := make([]int, 5)
    b_m := make([]int, 0, 5)
    fmt.Printf("len=%d,len(a_m),cap(a_m),a_m) // len=5,cap=5,[0 0 0 0 0]
    fmt.Printf("len=%d,len(b_m),cap(b_m),b_m) // len=0,[]

    // 包含切片的切片
    board := [][]string{
        []string{"_","_","_"},[]string{"_",}
    for i := 0; i < len(board); i++ {
        fmt.Printf("%sn",strings.Join(board[i]," "))
    }

    // 向切片追加元素
    var s_p []int
    fmt.Printf("len=%d,len(s_p),cap(s_p),s_p) // len=0,[]

    s_p = append(s_p, 1)
    s_p = append(s_p, 2)
    fmt.Printf("len=%d,[]
}

每个数组的大小都是固定的，而切片则提供动态数组，类型 []T 表示一个元素类型为 T 的切片。切片类似不限定长度的数组。

4.1 切片是数组的引用

切片并不存储任何数据，它只是描述了底层数组中的一段。更改切片的元素会修改其底层数组中对应的元素，并且与它共享底层数组的切片都会观测到这些修改。

如下创建一个切片时，会先创建数组，然后构建一个引用了它的切片

[]bool{true,true,false}

4.2 切片的默认行为

在进行切片时，切片有默认上下界。切片下界的默认值为 0 ，上界则是该切片的长度。

对于数组

var a [10]int

来说，以下切片是等价的：

a[0:10]
a[:10]
a[0:]
a[:]

4.3 切片的长度与容量

切片拥有 长度 和 容量

• 长度就是它所包含的元素个数。
• 容量是从它的第一个元素开始数，到其底层数组元素末尾的个数。

切片 s 的长度和容量可通过表达式 len(s) 和 cap(s) 来获取。

切片的零值是 nil,nil 切片的长度和容量为 0 且没有底层数组。

4.4 make 创建切片

切片可以用内建函数 make 来创建，这也是你创建动态数组的方式。make 函数会分配一个元素为零值的数组并返回一个引用了它的切片：

a := make([]int, 5)  // len(a)=5

要指定它的容量，需向 make 传入第三个参数：

b := make([]int, 5) // len(b)=0,cap(b)=5

4.5 切片的切片

切片可包含任何类型，甚至包括其它的切片

board := [][]string{
    []string{"_",[]string{"_",}

4.6 append 向切片追加元素

为切片追加新的元素是种常用的操作，为此 Go 提供了内建的 append 函数

func append(s []T,vs ...T) []T

append 的第一个参数 s 是一个元素类型为 T 的切片， 其余类型为 T 的值将会追加到该切片的末尾。append 的结果是一个包含原切片所有元素加上新添加元素的切片。当 s 的底层数组太小，不足以容纳所有给定的值时，它就会分配一个更大的数组。 返回的切片会指向这个新分配的数组。

5. range

$GOPATH/src/go_note/gotour/advancetype/range/range.go 源码如下:

/** * go 语言 range用法 */
package main
import "fmt"

var pow = []int{1,4,8,16,32}

func main() {
    for i,v := range pow {
        fmt.Printf("2**%d = %dn",i,v)
    }
    // 2**0 = 1
    // 2**1 = 2
    // 2**2 = 4
    // 2**3 = 8
    // 2**4 = 16
    // 2**5 = 32

    s := make([]int,5)
    for i := range s {
        s[i] = 1 << uint(i) // == 2**i
    }
    for _,v := range s {
        fmt.Printf("%dn",v)
    }
}

for 循环的 range 形式可遍历切片或映射。

当使用 for 循环遍历切片时，每次迭代都会返回两个值。 第一个值为当前元素的下标，第二个值为该下标所对应元素的一份副本。

可以将下标或值赋予 _ 来忽略它,若你只需要索引，去掉 ,value 的部分即可。

6. 映射

$GOPATH/src/go_note/gotour/advancetype/map/map.go 源码如下:

/** * go 语言映射 */
package main
import (
    "fmt"
)

type Vertex struct {
    Lit,Log float64
}

var m map[string]Vertex

var m1 = map[string]Vertex{ // 定义并初始化一个映射
    "Bell Labs": Vertex{
        40.123, -74.123,},"Google": Vertex{
        37.123, -122.123,}

var m2 = map[string]Vertex{ // 当顶级域名只是一个类型名时，可以在定义语句中省略它
    "Bell Labs": {40.123, -74.123},"Google": {37.123,}

func main() {
    m = make(map[string]Vertex) // make 返回给定类型的映射，并将其初始化备用
    m["Bell Labs"] = Vertex{40.123, -74.123}
    fmt.Println(m["Bell Labs"],m2)

    user := make(map[string]int)
    user["Age"] = 42
    fmt.Println(user["Age"])

    delete(user,"Age")
    fmt.Println(user["Age"])

    v,ok := user["Age"]
    fmt.Println("The Age:",v,"Presen?",ok)
}

映射将键映射到值,映射的零值为 nil,nil 映射既没有键，也不能添加键。make 函数会返回给定类型的映射，并将其初始化备用。

6.1 修改映射

在映射 m 中插入或修改元素：

m[key] = elem

获取元素：

elem = m[key]

删除元素：

delete(m,key)

通过双赋值检测某个键是否存在：

elem,ok = m[key]

若 key 在 m 中， ok 为 true ；否则， ok 为 false

若 key 不在映射中，那么 elem 是该映射元素类型的零值。同样的，当从映射中读取某个不存在的键时，结果是映射的元素类型的零值。

7. 闭包

$GOPATH/src/go_note/gotour/advancetype/closure/closure.go 源码如下:

/** * go 语言闭包 */
package main

import (
    "fmt"
    "math"
)

func compute(fn func(float64,float64) float64) float64{
    return fn(3, 4)
}

// adder 返回一个闭包,每个闭包都被绑定在其各自的 sum 变量上。
func adder() func (int) int {
    sum := 0
    return func (x int) int {
        sum += x
        return sum
    }
}

func main() {
    hypot := func (x,y float64) float64 {
        return math.Sqrt(x*x + y*y)
    }

    fmt.Println(hypot(5, 12)) // 13
    fmt.Println(compute(hypot)) // 5
    fmt.Println(compute(math.Pow)) // 81

    pos,neg := adder(),adder()
    fmt.Printf("%vn",pos)

    for i := 0; i < 10; i++ {
        fmt.Println(i,pos(i), -2*i,neg(-2*i))
    }
}

函数也是值，它们可以像其它值一样传递，函数值可以用作函数的参数或返回值。

Go 函数可以是一个闭包。闭包是一个函数值，它引用了其函数体之外的变量。该函数可以访问并赋值其引用的变量的值，也即该函数被“绑定”在了这些变量上。

参考

• Go 之旅中文
• A Tour of Go

@刚刚小码农

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!