大多数现实世界的编程都取决于我们与现有库的接口能力，而不是从头开始编写一切。本章将介绍一些最常用的软件包。
首先要提醒的是：尽管这些库中有些是相当明显的（或者在前面的章节中已经解释过了），但Go中包含的许多库需要专门的领域知识（例如：密码学）。解释这些底层技术超出了本书的范围.
Strings
Go 在 strings 包中提供了大量的函数来操作字符串：
package main import ( "fmt" "strings" ) func main() { fmt.Println( // true strings.Contains("test", "es"), // 2 strings.Count("test", "t"), // true strings.HasPrefix("test", "te"), // true strings.HasSuffix("test", "st"), // 1 strings.Index("test", "e"), // "a-b" strings.Join([]string{"a", "b"}, "-"), // == "aaaaa" strings.Repeat("a", 5), // "bbaa" strings.Replace("aaaa", "a", "b", 2), // []string{"a","b","c","d","e"} strings.Split("a-b-c-d-e", "-"), // "test" strings.ToLower("TEST"), // "TEST" strings.ToUpper("test"), ) }
有时我们需要将字符串作为二进制数据来处理。要将一个字符串转换为一个字节片（反之亦然），请这样做:
arr := []byte("test") str := string([]byte{'t', 'e', 's', 't'})
Input/Output
在我们想要查看文件的时候，需要使用到 Go 的 io 包，io 包由一些函数构成，但主要是其他包中使用的接口，主要的接口是 Reader 和 Writer
Reader支持读操作，通过 Read方法
Writer 支持写操作，通过 Write 方法
Go 中的许多函数都把 Reader 或者 Writer作为参数。例如，io包就有一个 Copy 函数从一个 Reader 复制到 Writer :
func Copy(dst Writer, src Reader) (written int 64, err error)
为了读或者写一个字符 []byte 或者 string ,你可以使用bytes 包中的 Buffer结构体：
var buf bytes.Buffer buf.Write([]byte("test"))
一个 Buffer 不需要被初始化，而且同时支持 Reader 和 Writer 接口。你可以调用 buf.Bytes() 将字符串数据转换为一个 []byte.
如果你只需要从一个字符串中读取，你也可以使用 string.NewReader 函数，这比使用缓冲区更有效。
Files 和 Folder
要在 Go 中打开一个文件，请使用 os 包中的 Open 函数。下面是一个如何读取文件内容并在终端显示的例子:
package main import ( "fmt" "os" ) func main() { file, err := os.Open("test.txt") if err != nil { // handle the error here return } defer file.Close() // get the file size stat, err := file.Stat() if err != nil { return } // read the file bs := make([]byte, stat.Size()) _, err = file.Read(bs) if err != nil { return } str := string(bs) fmt.Println(str) }
我们在打开文件后立即使用 defer file.Close() 以确保在函数完成后立即关闭该文件。读取文件是很常见的，所以有一种更简洁的方法来做这件事:
package main import ( "fmt" "io/ioutil" ) func main() { bs, err := ioutil.ReadFile("test.txt") if err != nil { return } str := string(bs) fmt.Println(str) }
如下是我们如何创建一个文件:
package main import ( "os" ) func main() { file, err := os.Create("test.txt") if err != nil { // handle the error here return } defer file.Close() file.WriteString("test") }
要获得一个目录的内容，我们使用同样的 os.Open 函数，但给它一个目录路径而不是 一个文件名。然后我们调用 Readdir 方法:
package main import ( "fmt" "os" ) func main() { dir, err := os.Open(".") if err != nil { return } defer dir.Close() fileInfos, err := dir.Readdir(-1) if err != nil { return } for _, fi := range fileInfos { fmt.Println(fi.Name()) } }
通常我们想递归地行走一个文件夹（读取文件夹的内容、所有的子文件夹、所有的子文件夹的子文件夹......）。为了使之更容易，在 path/filepath 包中有一个Walk函数:
package main import ( "fmt" "os" "path/filepath" ) func main() { filepath.Walk(".", func(path string, info os.FileInfo, err error) error { fmt.Println(path) return nil }) }
你传递给Walk的函数会对根文件夹中的每个文件和文件夹进行调用。(本例中为 .)
Errors
Go 有一个内置的错误类型，我们已经看到了（错误类型）。我们可以通过以下方式创建我们自己的错误：使用 errors 包中的 New 函数
package main import "errors" func main() { err := error.New("error message") }
Containers & Sort
除了列表和映射之外，Go 在容器包下面还有几个可用的集合。我们将以容器/列表包为例来看看：
List
container/list 包下实现了一个双向链表，链表的数据结构有点类似：
列表的每个节点都包含一个值（本例中为1、2或3 ）和一个指向下一个节点的指针。由于这是一个 每个节点都有指向下一个节点的指针 前一个节点的指针。这个列表可以由这个程序创建：
package main import ( "container/list" "fmt" ) func main() { var x list.List x.PushBack(1) x.PushBack(2) x.PushBack(3) for e := x.Front(); e != nil; e = e.Next() { fmt.Println(e.Value.(int)) } }
List的零值是一个空列表（*List也可以用list.New创建）。值被添加到列表中。我们对列表中的每一个项目进行循环，首先获得第一个元素，然后跟踪所有的链接，直到我们到达 nil。
Sort
排序包包含对任意数据进行排序的函数。有几个预定义的排序函数（针对 ints 和 floats 的切片）。如何对你自己的数据进行排序：
package main import ( "fmt" "sort" ) type Person struct { Name string Age int } type ByName []Person func (this ByName) Len() int { return len(this) } func (this ByName) Less(i, j int) bool { return this[i].Name < this[j].Name } func (this ByName) Swap(i, j int) { this[i], this[j] = this[j], this[i] } func main() { kids := []Person{ {"Jill", 9}, {"Jack", 10}, } sort.Sort(ByName(kids)) fmt.Println(kids) }
sort中的Sort函数接收一个sort.Interface并对其进行排序。sort.Interface需要3个方法。Len, Less 和 Swap。为了定义我们自己的排序，我们创建了一个新的类型（ByName），并使其等同于我们要排序的内容的一个片断。然后我们定义这3个方法。
然后，对我们的人的名单进行排序，就像把名单投到我们的新类型中一样容易。我们还可以通过以下方式按年龄排序:
type ByAge []Person func (this ByAge) Len() int { return len(this) } func (this ByAge) Less(i, j int) bool { return this[i].Age < this[j].Age } func (this ByAge) Swap(i, j int) { this[i], this[j] = this[j], this[i] }
Hashes & Cryptography
散列函数将一组数据减少到一个较小的固定大小。散列函数在程序设计中经常被使用。在程序设计中经常使用，从查找数据到轻松检测变化。Go中的哈希函数被分成两类：加密的和非加密的。
非加密的哈希函数可以在哈希包下面找到，包括adler32。crc32，crc64和fnv。下面是一个使用crc32的例子：
package main import ( "fmt" "hash/crc32" ) func main() { h := crc32.NewIEEE() h.Write([]byte("test")) v := h.Sum32() fmt.Println(v) }
crc32 哈希对象实现了 Writer 接口，所以我们可以像其他 Writer 一样向它写字节。一旦我们写完了我们想要的东西，我们就调用 Sum32() 来返回一个 uint32。crc32 的一个常见用途是比较两个文件。如果两个文件的 Sum32 值相同，就很有可能（虽然不是100%确定）这两个文件是一样的。如果数值不同，那么这两个文件肯定是不一样的：
package main import ( "fmt" "hash/crc32" "io/ioutil" ) func getHash(filename string) (uint32, error) { bs, err := ioutil.ReadFile("test1.txt") if err != nil { return 0, err } h := crc32.NewIEEE() h.Write(bs) return h.Sum32(), nil } func main() { h1, err := getHash("test1.txt") if err != nil { return } h2, err := getHash("test2.txt") if err != nil { return } fmt.Println(h1, h2, h1 == h2) }
加密哈希函数与非加密对应函数类似，但它们有一个额外的特性，即难以逆转。鉴于一组数据的加密哈希值，要确定是什么产生的哈希值是非常困难的。这些哈希值经常被用于安全应用中
一个常见的密码学散列函数被称为 SHA-1。下面是它的使用方法:
package main import ( "fmt" "crypto/sha1" ) func main() { h := sha1.New() h.Write([]byte("test")) bs := h.Sum([]byte{}) fmt.Println(bs) }
这个例子与crc32的例子非常相似，因为crc32和sha1都实现了hash.Hash接口。主要区别在于，crc32计算的是32位的哈希值，而sha1计算的是160位的哈希值，没有本地类型来表示160位的数字。所以我们用一个20字节的片断来代替。
