The Way to Go（三）

发表于 | 分类于 |

数组与切片

  • 数组

数组是具有相同 唯一类型 的一组已编号且长度固定的数据项序列（这是一种同构的数据结构）；这种类型可以是任意的原始类型例如整型、字符串或者自定义类型。数组长度必须是一个常量表达式，并且必须是一个非负整数。数组长度也是数组类型的一部分，所以[5]int和[10]int是属于不同类型的。

1
var identifier [len]type
  • 切片
    声明切片的格式是： 
1
var identifier []type   //不需要说明长度

注意不要用指针指向 slice。切片本身已经是一个引用类型，所以它本身就是一个指针。

new() 和 make() 的区别

看起来二者没有什么区别，都在堆上分配内存，但是它们的行为不同，适用于不同的类型。

  • new(T) 为每个新的类型T分配一片内存，初始化为 0 并且返回类型为*T的内存地址：这种方法 返回一个指向类型为 T，值为 0 的地址的指针，它适用于值类型如数组和结构体；它相当于 &T{}。

  • make(T) 返回一个类型为 T 的初始值，它只适用于3种内建的引用类型：切片、map 和 channel

换言之，new 函数分配内存，make 函数初始化。

字符串、数组和切片的应用

  • 从字符串生成字节切片
  • 假设 s 是一个字符串（本质上是一个字节数组），那么就可以直接通过 c := []byte(s) 来获取一个字节的切片 c。另外，还可以通过 copy 函数来达到相同的目的：copy(dst []byte, src string)。

同样的，还可以使用 for-range 来获得每个元素。

  • 修改字符串中的某个字符

Go 语言中的字符串是不可变的，也就是说 str[index] 这样的表达式是不可以被放在等号左侧的。如果尝试运行 str[i] = 'D'会得到错误：cannot assign to str[i]。

因此，必须先将字符串转换成字节数组，然后再通过修改数组中的元素值来达到修改字符串的目的，最后将字节数组转换回字符串格式。

例如，将字符串 "hello" 转换为 "cello"：

1
2
3
4
s := "hello"
c := []byte(s)
c[0] = 'c'
s2 := string(c) // s2 == "cello"

所以，可以通过操作切片来完成对字符串的操作。

  • 搜索及排序切片和数组

标准库提供了 sort 包来实现常见的搜索和排序操作。您可以使用 sort 包中的函数 func Ints(a []int) 来实现对 int 类型的切片排序。例如 sort.Ints(arri)，其中变量 arri 就是需要被升序排序的数组或切片。为了检查某个数组是否已经被排序，可以通过函数 IntsAreSorted(a []int) bool来检查，如果返回 true 则表示已经被排序。

类似的，可以使用函数 func Float64s(a []float64) 来排序 float64 的元素，或使用函数 func Strings(a []string) 排序字符串元素。

想要在数组或切片中搜索一个元素，该数组或切片必须先被排序（因为标准库的搜索算法使用的是二分法）。然后，您就可以使用函数func SearchInts(a []int, n int) int 进行搜索，并返回对应结果的索引值。

append 函数常见操作

  1. 将切片 b 的元素追加到切片 a 之后：a = append(a, b...)

  2. 复制切片 a 的元素到新的切片 b 上：

    1
    2
    b = make([]T, len(a))
    copy(b, a)

  3. 删除位于索引 i 的元素：a = append(a[:i], a[i+1:]...)

  4. 切除切片 a 中从索引 i 至 j 位置的元素：a = append(a[:i], a[j:]...)
  5. 为切片 a 扩展 j 个元素长度：a = append(a, make([]T, j)...)
  6. 在索引 i 的位置插入元素 x：a = append(a[:i], append([]T{x}, a[i:]...)...)
  7. 在索引 i 的位置插入长度为 j 的新切片：a = append(a[:i], append(make([]T, j), a[i:]...)...)
  8. 在索引 i 的位置插入切片 b 的所有元素：a = append(a[:i], append(b, a[i:]...)...)
  9. 取出位于切片 a 最末尾的元素 x：x, a = a[len(a)-1], a[:len(a)-1]
  10. 将元素 x 追加到切片 a：a = append(a, x)

因此，您可以使用切片和 append 操作来表示任意可变长度的序列。

map

map 是引用类型，可以使用如下声明：

1
2
var map1 map[keytype]valuetype
var map1 map[string]int

在声明的时候不需要知道 map 的长度，map 是可以动态增长的。

未初始化的 map 的值是nil。

key 可以是任意可以用 == 或者 != 操作符比较的类型，比如 string、int、float。所以数组、切片和结构体不能作为 key，但是指针和接口类型可以。

value 可以是任意类型的；通过使用空接口类型，我们可以存储任意值，但是使用这种类型作为值时需要先做一次类型断言。

map 是 引用类型 的： 内存用 make 方法来分配。

map 的初始化：var map1 = make(map[keytype]valuetype)。

或者简写为：map1 := make(map[keytype]valuetype)。

测试键值对是否存在及删除元素

使用 val1 = map1[key1] 的方法获取 key1 对应的值 val1。如果map 中不存在key1，val1 就是一个值类型的空值。

这就会给我们带来困惑了：现在我们没法区分到底是key1 不存在还是它对应的 value 就是空值。

为了解决这个问题，我们可以这么用：val1, isPresent = map1[key1]

如果你只是想判断某个 key 是否存在而不关心它对应的值到底是多少，你可以这么做：

1
_, ok := map1[key1] // 如果key1存在则ok == true，否则ok为false

或者和 if 混合使用：

1
2
3
if _, ok := map1[key1]; ok {
    // ...
}

从 map1 中删除 key1：

直接 delete(map1, key1)就可以。

如果key1 不存在，该操作不会产生错误。

map 类型的切片

假设我们想获取一个 map 类型的切片，我们必须使用两次 make() 函数，第一次分配切片，第二次分配 切片中每个 map 元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main
import "fmt"

func main() {
    // Version A:
    items := make([]map[int]int, 5)
    for i:= range items {
        items[i] = make(map[int]int, 1)
        items[i][1] = 2
    }
    fmt.Printf("Version A: Value of items: %v\n", items)

    // Version B: NOT GOOD!
    items2 := make([]map[int]int, 5)
    for _, item := range items2 {
        item = make(map[int]int, 1) // item is only a copy of the slice element.
        item[1] = 2 // This 'item' will be lost on the next iteration.
    }
    fmt.Printf("Version B: Value of items: %v\n", items2)
}

输出结果：

1
2
Version A: Value of items: [map[1:2] map[1:2] map[1:2] map[1:2] map[1:2]]
Version B: Value of items: [map[] map[] map[] map[] map[]]

需要注意的是，应当像 A 版本那样通过索引使用切片的 map 元素。在 B 版本中获得的项只是 map 值的一个拷贝而已，所以真正的 map 元素没有得到初始化。

将 map 的键值对调

这里对调是指调换 key 和 value。如果 map 的值类型可以作为 key 且所有的 value 是唯一的，那么通过下面的方法可以简单的做到键值对调。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main
import (
    "fmt"
)

var (
    barVal = map[string]int{"alpha": 34, "bravo": 56, "charlie": 23,
                            "delta": 87, "echo": 56, "foxtrot": 12,
                            "golf": 34, "hotel": 16, "indio": 87,
                            "juliet": 65, "kili": 43, "lima": 98}
)

func main() {
    invMap := make(map[int]string, len(barVal))
    for k, v := range barVal {
        invMap[v] = k
    }
    fmt.Println("inverted:")
    for k, v := range invMap {
        fmt.Printf("Key: %v, Value: %v / ", k, v)
    }
}

包

像 fmt、os 等这样具有常用功能的内置包在 Go 语言中有 150 个以上，它们被称为标准库，大部分(一些底层的除外)内置于 Go 本身。

  • unsafe: 包含了一些打破 Go 语言“类型安全”的命令，一般的程序中不会被使用，可用在 C/C++ 程序的调用中。

  • syscall-os-os/exec:

    • os: 提供给我们一个平台无关性的操作系统功能接口，采用类Unix设计，隐藏了不同操作系统间差异，让不同的文件系统和操作系统对象表现一致。
    • os/exec: 提供我们运行外部操作系统命令和程序的方式。
    • syscall: 底层的外部包，提供了操作系统底层调用的基本接口。

  • archive/tar 和 /zip-compress：压缩(解压缩)文件功能。

  • fmt-io-bufio-path/filepath-flag:
    • fmt: 提供了格式化输入输出功能。
    • io: 提供了基本输入输出功能，大多数是围绕系统功能的封装。
    • bufio: 缓冲输入输出功能的封装。
    • path/filepath: 用来操作在当前系统中的目标文件名路径。
    • flag: 对命令行参数的操作。　　
  • strings-strconv-unicode-regexp-bytes:
    • strings: 提供对字符串的操作。
    • strconv: 提供将字符串转换为基础类型的功能。
    • unicode: 为 unicode 型的字符串提供特殊的功能。
    • regexp: 正则表达式功能。
    • bytes: 提供对字符型分片的操作。
    • index/suffixarray: 子字符串快速查询。
  • math-math/cmath-math/big-math/rand-sort:
    • math: 基本的数学函数。
    • math/cmath: 对复数的操作。
    • math/rand: 伪随机数生成。
    • sort: 为数组排序和自定义集合。
    • math/big: 大数的实现和计算。 　　

  • container-/list-ring-heap: 实现对集合的操作。

    • list: 双链表。
    • ring: 环形链表。

  • time-log:

    • time: 日期和时间的基本操作。
    • log: 记录程序运行时产生的日志,我们将在后面的章节使用它。
  • encoding/json-encoding/xml-text/template:
    • encoding/json: 读取并解码和写入并编码 JSON 数据。
    • encoding/xml:简单的 XML1.0 解析器,有关 JSON 和 XML 的实例请查阅第 12.9/10 章节。
    • text/template:生成像 HTML 一样的数据与文本混合的数据驱动模板（参见第 15.7 节）。
  • net-net/http-html:（参见第 15 章）
    • net: 网络数据的基本操作。
    • http: 提供了一个可扩展的 HTTP 服务器和基础客户端，解析 HTTP 请求和回复。
    • html: HTML5 解析器。
  • runtime: Go 程序运行时的交互操作，例如垃圾回收和协程创建。
  • reflect: 实现通过程序运行时反射，让程序操作任意类型的变量。

exp 包中有许多将被编译为新包的实验性的包。它们将成为独立的包在下次稳定版本发布的时候。如果前一个版本已经存在了，它们将被作为过时的包被回收。然而 Go1.0 发布的时候并不包含过时或者实验性的包。

regexp 包

在下面的程序里，我们将在字符串中对正则表达式进行匹配。

如果是简单模式，使用 Match 方法便可：

1
ok, _ := regexp.Match(pat, []byte(searchIn))

变量 ok 将返回 true 或者 false,我们也可以使用 MatchString：

1
ok, _ := regexp.MatchString(pat, searchIn)

锁和 sync 包

在一些复杂的程序中，通常通过不同线程执行不同应用来实现程序的并发。当不同线程要使用同一个变量时，经常会出现一个问题：无法预知变量被不同线程修改的顺序！(这通常被称为资源竞争,指不同线程对同一变量使用的竞争)

经典的做法是一次只能让一个线程对共享变量进行操作。当变量被一个线程改变时(临界区)，我们为它上锁，直到这个线程执行完成并解锁后，其他线程才能访问它。

在 Go 语言中这种锁的机制是通过 sync 包中Mutex 来实现的。sync 来源于 “synchronized” 一词，这意味着线程将有序的对同一变量进行访问。

sync.Mutex 是一个互斥锁，它的作用是守护在临界区入口来确保同一时间只能有一个线程进入临界区。

假设 info 是一个需要上锁的放在共享内存中的变量。通过包含 Mutex来实现的一个典型例子如下：

1
2
3
4
5
6
import  "sync"

type Info struct {
    mu sync.Mutex
    // ... other fields, e.g.: Str string
}

如果一个函数想要改变这个变量可以这样写:

1
2
3
4
5
6
7
func Update(info *Info) {
    info.mu.Lock()
    // critical section:
    info.Str = // new value
    // end critical section
    info.mu.Unlock()
}

还有一个很有用的例子是通过 Mutex 来实现一个可以上锁的共享缓冲器:

1
2
3
4
type SyncedBuffer struct {
    lock    sync.Mutex
    buffer  bytes.Buffer
}
------ 本文结束 ------
0%