Golang(二)高效编程
Golang做为一门新的编程语言，它借鉴了现有语言的思想但拥有着不一样寻常的特性，使得有效的Go程序在性质上不一样于其
亲属编写的程序。若是直接将C++或Java程序翻译成Go程序也不太可能产生使人满意的结果，由于从Go的角度来思考这个问题，能够产生一个成功但又彻底不一样的程序。要写得好，理解它的性质和习语及Golang中既定约定(如命名、格式化、程序构造等)对于提供编写清晰、惯用go代码的技巧颇有帮助，这样编写出的程序也便于其余Golang程序员理解。Golang素以简洁高效著称，我想这是对学习并掌握好语言的基础知识并加以灵活运用的效果。本文将从Golang编程语言的数据类型、语法规则、语言特性方面进行介绍html
基本语法
Formatting格式化问题是最有争议但最不一致的。人们能够适应不一样的格式样式，若是每一个人都坚持相同的样式，那么能够花费更少的时间在格式化主题上。在go语言中采起了一种不寻常的方法，让机器处理大多数格式化问题。gofmt程序(也可用做go fmt，在包级别而不是源文件级别运行)读取go程序，并以缩进和垂直对齐的标准样式发布源代码，保留并在必要时从新格式化注释git
示例
package main程序员
import "fmt"复制代码
func main() {
a:= 12//initial a
fmt.Printf("hello, world, a = %v\n", a)//print
}复制代码
## gofmt格式化: gofmt -s -w hello.go
package main复制代码
import "fmt"复制代码
func main() {
a := 12 //initial a
fmt.Printf("hello, world, a = %v\n", a) //print
}复制代码
标准包中的全部go代码都已用gofmt格式化。一些格式细节仍然保留，简要说明web
- Indentation 使用制表符缩进，默认状况下gofmt会发布制表符，只有在必要时才使用空格
- Line length go没有行长度限制，若是一行太长，用一个额外的标签把它包起来缩进
- Parentheses go须要的括号比C和Java少: 控制结构(if, for, switch)的语法中没有括号；一样，运算符的优先级层次越短越清晰，所以，
x<<8 + y<<16复制代码
注解 Go提供C风格的块注解/**/及C++风格的行注解//。行注释是规范；块注释主要做为包注释出现，但在表达式中颇有用，或用于禁用大片代码。godoc程序经过源文件来提取有关包内容的文档，在顶级声明以前出现的注释(没有中间的换行符)将与声明一块儿提取，做为解释文本。这些注释的性质和样式决定了godoc生成的文档的质量。每一个包都应该有一个包注释，即package子句前面的一个块注释。对于多文件包，包注释只须要出如今一个文件中，任何一个均可以。包注释应介绍包并提供相关信息给整个包。它将首先出如今godoc页面上，并应设置如下详细文档算法
/*
Package regexp implements a simple library for regular expressions.复制代码
The syntax of the regular expressions accepted is:复制代码
regexp:
concatenation { '|' concatenation }
concatenation:
{ closure }
closure:
term [ '*' | '+' | '?' ]
term:
'^'
'$'
'.'
character
'[' [ '^' ] character-ranges ']'
'(' regexp ')'
*/
package regexp复制代码
若是包很简单，包注释能够很简短express
// Package path implements utility routines for
// manipulating slash-separated filename paths.复制代码
评论不须要额外的格式，生成的输出甚至可能不会以固定宽度的字体显示，因此不要依赖于对齐的间距，gofmt会处理这个问题。注释是纯文本，所以html和其余注释将逐字复制，不该使用。godoc作的一个调整是以固定宽度的字体显示缩进的文本，适合程序片断编程
在包中，顶级声明前面的任何注释都将做为该声明的文档注释。程序中的每一个导出(首字母大写)名称都应该有一个doc注释。doc注释做为完整的句子最有效，它容许各类各样的自动化演示。第一句话应该是一句话的总结，以所声明的名称开头json
// Compile parses a regular expression and returns, if successful,
// a Regexp that can be used to match against text.
func Compile(str string) (*Regexp, error) {复制代码
命名 命名在Go语言和其余语言中同样重要，它们甚至具备语义效果: 包外名称的可见性取决于其第一个字符是否大写。所以，在go程序中花点时间讨论命名约定是值得的api
*包名* 当包被导入时，包名称将成为内容的访问器数组
import "bytes"复制代码
导入包后能够调用bytes.Buffer; 若是每一个使用包的人均可以使用相同的名称来引用它的内容，这将颇有帮助，这意味着包的名称应该具备：简短、简洁、使人印象深入的特色。按照惯例，包的名称是小写的、单字的；不须要下划线或混合大写；包名称是其源目录的基名称；src/encoding/base64中的包被导入为“encoding/base64”，但名称为base64，而不是base64中的编码，也不是encodingbase64
Getters go不为getter和setter提供自动支持。本身提供getter和setter并无错，这样作一般是合适的，但不是惯用的，也不是必须使用getter的名称。若是有一个名为owner的字段(小写，不可导出)，则getter方法应称为Owner(大写，可导出)，而不是GetOwner。在导出中使用大写名称提供一个钩子来区分字段和方法。若是须要，setter函数可能会被称为SetOwner
owner := obj.Owner()
if owner != user {
obj.SetOwner(user)
}复制代码
接口名称 按照惯例，接口由方法名加上er后缀或相似的修改来命名，例如: reader、writer、formatter、closenotifier等
MixedCaps go中的约定是使用MixedCaps或mixedCaps格式来编写多个单词的名称，而不是使用下划线链接
分号 与C同样，go的形式语法使用分号来终止语句，但与c不一样的是，这些分号不会出如今源代码中，lexer使用一个简单的规则在扫描时自动插入分号，所以输入的文本基本上没有分号。规则：若是换行符以前的最后一个标记是标识符(包括int和float64等词)、基本文本(如数字或字符串常量)或其中一个标记，则lexer始终在该标记以后插入分号。这能够归纳为：“若是换行符位于能够结束语句的标记以后，请插入分号”
break continue fallthrough return ++ -- ) }复制代码
在右大括号以前也能够省略分号; go程序习惯用法只有在for循环子句等位置才有分号，以分隔初始值设定项、条件和循环元素。它们也是在一行中分隔多个语句所必需的，您应该这样编写代码
go func() { for { dst <- <-src } }()复制代码
分号插入规则的一个结果是，不能将控件结构的左大括号（if、for、switch或select）放在下一行。若是这样作，将在大括号以前插入分号，这可能会形成没必要要的影响
// like this
if i < f() {
g()
}复制代码
// 而不是
if i < f() // wrong!
{ // wrong!
g()
}复制代码
控制结构 go的控制结构与C的控制结构有关，但存在诸多不一样。没有do或while循环，只有一个轻微泛化的for；switch更灵活；if和switch接受一个相似for的可选初始化语句；break和continue语句使用一个可选标签来标识要中断或继续的语句块；新的控制结构包括类型开关和多路通讯复用器--select。语法也略有不一样: 没有括号，正文必须始终用大括号分隔
If go中一个简单的if语句相似
if x > 0 {
return y
}复制代码
强制大括号鼓励在多行上编写简单的if语句。不管如何，这样作是一种好的风格，尤为是当主体包含这样一个返回或中断的控制语句时。if和switch接受初始化语句，因此一般会看到用于设置局部变量的语句
if err := file.Chmod(0664); err != nil {
log.Print(err)
return err
}复制代码
在go库中，您会发现当一个语句没有流入下一个语句(即，主体以break、continue、goto或return结尾)时，没必要要的else语句将被省略
f, err := os.Open(name)
if err != nil {
return err
}
codeUsing(f)复制代码
这是一个常见状况的例子，代码必须防止一系列错误条件。若是成功的控制流在页面上运行，代码读起来很好，从而消除了出现的错误状况。因为错误状况每每以返回语句结尾，所以生成的代码不须要其余语句
f, err := os.Open(name)
if err != nil {
return err
}
d, err := f.Stat()
if err != nil {
f.Close()
return err
}
codeUsing(f, d)复制代码
从新声明而且从新赋值 := 符号声明并赋值，参考以上一个示例
## 调用os.Open()，声明两个变量f和err
f, err := os.Open(name)复制代码
## 接下来调用f.Stat()，声明变量d和err
d, err := f.Stat()复制代码
err变量出如今两个语句中，这种重复是合法的: err在第一个语句中声明，在第二个语句中从新分配。这意味着对f.Stat()的调用使用了上面声明的现有err变量，并给它分配一个新的值
在 := 声明中，即便变量v已经声明，也可能再出现，前提是
- 此声明与v的现有声明在同一做用域以内；若是v已经在外部做用域声明，则此声明将建立一个新变量§
- 初始化中的相应值可分配给v，而且
- 声明中至少有一个变量是新的(第一次声明)
For go的for循环相似于但又不一样于C，它统一了for和while，没有do-while。如下三种表达形式，只有一种带有分号
// Like a C for
for init; condition; post { }复制代码
// Like a C while
for condition { }复制代码
// Like a C for(;;)
for { }复制代码
简短的语句使在循环中声明索引变量变得很容易
sum := 0
for i := 0; i < 10; i++ {
sum += i
}复制代码
若是在数组、切片、字符串或map上循环，或从channel读取，则使用range子句能够管理循环
for key, value := range oldMap {
newMap[key] = value
}复制代码
若是只须要range中的第一项(key或索引号)，能够丢弃第二项
for key := range m {
if key.expired() {
delete(m, key)
}
}复制代码
若是只须要range中的第二项(值)，使用空白标识符(下划线)放弃第一项
sum := 0
for _, value := range array {
sum += value
}复制代码
对于字符串，range经过解析UTF-8来分解各个Unicode编码，错误的编码消耗一个字节并产生替换的rune(宽字符) U+FFFD。rune，Go术语，表示单个Unicode编码(相关的内置类型)
for pos, char := range "日本\x80語" { // \x80 is an illegal UTF-8 encoding
fmt.Printf("character %#U starts at byte position %d\n", char, pos)
}
## 打印结果以下
character U+65E5 '日' starts at byte position 0
character U+672C '本' starts at byte position 3
character U+FFFD '�' starts at byte position 6
character U+8A9E '語' starts at byte position 7复制代码
go没有逗号运算符，++和--are语句不是表达式。所以，若是要在for中运行多个变量，则应使用并行赋值
// Reverse a
for i, j := 0, len(a)-1; i < j; i, j = i+1, j-1 {
a[i], a[j] = a[j], a[i]
}复制代码
Switch go的switch比C更通用，表达式没必要是常量甚至没必要是整数，在找到匹配项以前将至上而下评估case。若是switch没有表达式，switches on true。所以，将if-else-if-else链编写为switch是可能的也是惯用的方法
func unhex(c byte) byte {
switch {
case '0' <= c && c <= '9':
return c - '0'
case 'a' <= c && c <= 'f':
return c - 'a' + 10
case 'A' <= c && c <= 'F':
return c - 'A' + 10
}
return 0
}复制代码
不存在自动筛选，能够用逗号分隔case的列表
func shouldEscape(c byte) bool {
switch c {
case ' ', '?', '&', '=', '#', '+', '%':
return true
}
return false
}复制代码
break语句能够提早终止switch和循环语句，尽管它在Go中不似C语言中那么常见，不过有时有必要从一个环绕的循环中脱离出来，能够经过在循环上贴上标签并从标签上“断开”来跳出循环。这个例子展现了这两种用途
Loop:
for n := 0; n < len(src); n += size {
switch {
case src[n] < sizeOne:
if validateOnly {
break
}
size = 1
update(src[n])复制代码
case src[n] < sizeTwo:
if n+1 >= len(src) {
err = errShortInput
break Loop
}
if validateOnly {
break
}
size = 2
update(src[n] + src[n+1]<<shift)
}
}复制代码
continuous语句也接受一个可选的标签，但它只适用于循环
如下是使用两个switch语句的字节切片比较例程
// Compare returns an integer comparing the two byte slices,
// lexicographically.
// The result will be 0 if a == b, -1 if a < b, and +1 if a > b
func Compare(a, b []byte) int {
for i := 0; i < len(a) && i < len(b); i++ {
switch {
case a[i] > b[i]:
return 1
case a[i] < b[i]:
return -1
}
}
switch {
case len(a) > len(b):
return 1
case len(a) < len(b):
return -1
}
return 0
}复制代码
Type Switch switch还能够用来发现接口变量的动态类型，这样的type switch使用类型断言的语法，括号内有关键字type。若是switch在表达式中声明了一个变量，则该变量在每一个子句中将具备相应的类型；在这种状况下重用名称也是惯用的，其实是用相同的名称声明一个新变量，但在每种状况下都使用不一样的类型
var t interface{}
t = functionOfSomeType()
switch t := t.(type) {
default:
fmt.Printf("unexpected type %T\n", t) // %T prints whatever type t has
case bool:
fmt.Printf("boolean %t\n", t) // t has type bool
case int:
fmt.Printf("integer %d\n", t) // t has type int
case *bool:
fmt.Printf("pointer to boolean %t\n", *t) // t has type *bool
case *int:
fmt.Printf("pointer to integer %d\n", *t) // t has type *int
}复制代码
函数和方法
函数 多返回值 Go的一个不寻常的特性是函数和方法能够返回多个值，带内错误返回，例如-1表示EOF，修改按地址传递的参数。在Go语言中，Write函数能够返回一个计数(写入的字节数)和一个错误，os包中Write函数的签名以下
func (file *File) Write(b []byte) (n int, err error)复制代码
相似的方法消除了将指针传递到返回值以模拟引用参数的须要。这里有一个简单的函数从字节切片中的一个位置获取一个数字，返回数字和下一个位置
func nextInt(b []byte, i int) (int, int) {
for ; i < len(b) && !isDigit(b[i]); i++ {
}
x := 0
for ; i < len(b) && isDigit(b[i]); i++ {
x = x*10 + int(b[i]) - '0'
}
return x, i
}复制代码
也能够用它像这样扫描输入切片b中的数字
for i := 0; i < len(b); {
x, i = nextInt(b, i)
fmt.Println(x)
}复制代码
命名结果参数 go函数的返回或结果“参数”能够被命名并用做常规变量，就像传入的参数同样。当函数启动时，被命名的参数将被初始化为它们类型的零值；若是函数执行不带参数的返回语句，则结果参数的当前值将用做返回值。这些名称不是强制性的，但它们可使代码更短、更清晰；以下定义一个函数netxInt的两个int类型返回参数的名称为value和nextPos
func nextInt(b []byte, pos int) (value, nextPos int) {复制代码
命名结果是初始化的，而且绑定到未修饰的返回，因此它们既能够简化，也能够声明。以io.ReadFull的一个版本为例
func ReadFull(r Reader, buf []byte) (n int, err error) {
for len(buf) > 0 && err == nil {
var nr int
nr, err = r.Read(buf)
n += nr
buf = buf[nr:]
}
return
}复制代码
Defer Go的defer语句将函数调用(deferred函数)安排在执行defer返回的函数以前当即运行。这是一种不寻常但有效的方法来处理这样的状况，不管函数返回的路径如何，都必须释放资源。典型的例子是解锁互斥锁或关闭文件
// Contents 以字符串形式返回文件的内容.
func Contents(filename string) (string, error) {
f, err := os.Open(filename)
if err != nil {
return "", err
}
defer f.Close() // f.Close will run when we're finished.复制代码
var result []byte
buf := make([]byte, 100)
for {
n, err := f.Read(buf[0:])
result = append(result, buf[0:n]...) // append is discussed later.
if err != nil {
if err == io.EOF {
break
}
return "", err // f will be closed if we return here.
}
}
return string(result), nil // f will be closed if we return here.
}复制代码
推迟对close等函数的调用有两个优势：第一，它保证您永远不会忘记关闭文件，若是之后编辑函数以添加新的返回路径，则很容易犯这个错误；第二，这意味着Close位于Open附近，这比将其放在函数末尾要清楚得多
deferred函数的参数(若是函数是一种方法，则包括接收器)在defer执行时计算，而不是在调用时计算。除了避免担忧变量在函数执行时更改值以外，这意味着一个延迟调用站点能够延迟多个函数的执行
for i := 0; i < 5; i++ {
defer fmt.Printf("%d ", i)
}复制代码
defer函数以LIFO顺序执行，所以，上述代码返回时将会打印4 3 2 1 0 。一个更合理的例子，是经过简单的程序跟踪函数执行，咱们能够编写一些简单的跟踪例程，以下所示
func trace(s string) { fmt.Println("entering:", s) }
func untrace(s string) { fmt.Println("leaving:", s) }复制代码
// Use them like this:
func a() {
trace("a")
defer untrace("a")
// do something....
}复制代码
咱们能够更好地利用这样一个事实，即deferred函数的参数是在延迟执行时计算的。跟踪例程能够将参数设置为untracing例程。示例
func trace(s string) string {
fmt.Println("entering:", s)
return s
}复制代码
func un(s string) {
fmt.Println("leaving:", s)
}复制代码
func a() {
defer un(trace("a"))
fmt.Println("in a")
}复制代码
func b() {
defer un(trace("b"))
fmt.Println("in b")
a()
}复制代码
func main() {
b()
}复制代码
## 输出以下
entering: b
in b
entering: a
in a
leaving: a
leaving: b
复制代码
方法
*指针 vs. 值* 正如咱们在ByteSize中看到的，能够为任何命名类型(指针或接口除外)定义方法；接收器没必要是结构。在上面对切片的讨论中，咱们编写了一个Append函数，能够将其定义为切片上的方法。为此，首先声明一个能够绑定该方法的命名类型，而后将该方法的接收器设置为该类型的值
type ByteSlice []byte复制代码
func (slice ByteSlice) Append(data []byte) []byte {
// Body exactly the same as the Append function defined above.
}复制代码
这仍然须要方法返回更新后的切片，能够经过从新定义方法来消除这种冗余操做，将指向字节切片的指针做为其接收器，这样方法就能够覆盖调用方的切片
func (p *ByteSlice) Append(data []byte) {
slice := *p
// Body as above, without the return.
*p = slice
}复制代码
事实上，咱们能够作得更好，若是修改咱们的函数使其看起来像一个标准的write方法，就像这样
func (p *ByteSlice) Write(data []byte) (n int, err error) {
slice := *p
// Again as above.
*p = slice
return len(data), nil
}复制代码
而后，类型*ByteSize知足标准io.Writer接口，例如，咱们能够打印成一个
var b ByteSlice
fmt.Fprintf(&b, "This hour has %d days\n", 7)复制代码
此处，传递ByteSize类型的地址是由于只有*ByteSize知足io.Writer。关于指针和接收器值的规则是，值方法能够在指针和值上调用，但指针方法只能在指针上调用。这一规则的产生是由于指针方法能够修改接收器；对值调用它们将致使方法接收值的副本，所以任何修改都将被丢弃。所以，该语言不容许出现此错误。不过，有一个例外：当值是可寻址的时，语言经过自动插入address运算符来处理在值上调用指针方法的常见状况。在咱们的例子中，变量b是可寻址的，因此咱们能够用b.Write调用它的Write方法。编译器将会为咱们重写为(&b).Write。顺便提一下，在字节切片上使用Write的思想是bytes.Buffer实现的核心
数据及初始化
使用new分配 go有两个分配原语，分别是内置函数new和make，它们应用于不一样的类型作不一样的事情。对于new，它是一个分配内存的内置函数，而且只将其归零而不初始化内存。也就是说，new(T)为T类型的新对象分配零存储并返回它的地址，即类型*T的值。在go的术语中，它返回一个指向新分配的T类型零值指针
因为new返回的内存为零，所以在设计数据结构时，最好安排在不进行进一步初始化的状况下使用每种类型的零值。这意味着数据结构的用户可使用new建立一个数据结构，并得到工做权限。例如，bytes.buffer的文档声明“buffer的零值是一个空缓冲区，可使用。”一样，sync.mutex没有显式的构造函数或init方法。相反，sync.mutex的零值被定义为未加锁的mutex
zero-value-is-useful属性能够透明工做，开旅下面的类型声明
type SyncedBuffer struct {
lock sync.Mutex
buffer bytes.Buffer
}复制代码
SyncedBuffer类型的值也能够在分配或仅声明时当即使用。在如下代码片断中，p和v都将正常工做，无需进一步安排
p := new(SyncedBuffer) // type *SyncedBuffer
var v SyncedBuffer // type SyncedBuffer复制代码
构造器和文字复合 有时零值不够好，须要初始化构造函数，如本例中从包os派生的File
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}复制代码
做为一个限制条件，若是一个文本组合根本不包含字段，它将为类型建立一个零值。表达式new(File)和&File{}是等价的。还能够为数组、切片和映射建立复合文本，字段标签是索引或映射键(视状况而定)，在这些示例中，无论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)，它只用于建立slices、maps和channels而且返回一个已经初始化的(非零的)类型为T(不是*T)的值；其中，差异的缘由是这三种类型存在对底层数据结构的引用，这些数据结构必须在使用以前初始化。例如，切片数据结构包括：指向数据(数组内部)、长度和容量的指针，在初始化这些项以前，切片是nil。对于切片、maps和channels，make初始化其内部数据结构，并准备要使用的值。例如
make([]int, 10, 100)复制代码
分配一个100个整数的数组，而后建立一个长度为十、容量为100的切片结构，指向数组的前面第10个元素。相反，new([]int)返回一个指向新分配的零切片结构的指针，即指向nil切片值的指针。这些例子说明了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)复制代码
*Tips make只适用于maps、slices和channels，不返回指针；使用new获取显式指针分配或显示获取变量地址
数组 数组在规划内存的详细布局时颇有用，有时能够帮助避免分配，但它们主要是用于切片的构建块。数组在Go中工做方式与C有很大的不一样，主要表如今
- 数组是值，将一个数组分配给其余数组将复制全部元素
- 若是将数组传递给函数，它将收到数组的副本，而不是指向它的指针
- 数组的大小是其类型的一部分，类型[10]int和[20]int是不一样的
value属性可能颇有用，但也很昂贵；若是要相似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) // 注意运算符的显示地址，即便是这种方式也不是Go惯用的方法，slice才是复制代码
Slices 切片包装数组，为数据序列提供更通用、更强大、更方便的接口。除了具备显式维度的项(如转换矩阵)外，go中的大多数数组编程都是用切片而不是简单数组完成的。切片保存对底层数组的引用，若是将切片分配给另外一个切片，则两个切片都引用同一个数组。若是一个函数接受一个slice参数，它对slice元素所作的更改将对调用者可见，相似于将指针传递给底层数组。所以，Read函数能够接受slice参数，而不是指针和计数；slice中的长度设置了要读取多少数据的上限。下面是包os中文件类型的Read方法的函数签名
func (f *File) Read(buf []byte) (n int, err error)复制代码
该方法返回读取的字节数和错误值(若是有)，要读入较大缓冲区的前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.
n += nbytes
if nbytes == 0 || e != nil {
err = e
break
}
}复制代码
一个切片的长度能够改变，只要它仍然在底层数组的限制范围内；只需将它分配给自身的一个切片。切片的容量由内置函数cap访问，报告切片可能假定的最大长度。以下示例是一个Append函数，用于将数据追加到切片: 若是数据超出容量，则从新分配切片，返回结果切片
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)]
copy(slice[l:], data)
// 此处必须返回append以后ded切片，由于虽然append能够修改切片的元素，但切片自己(包含指针、长度和容量的运行时数据结构)是按值传递的
return slice
}复制代码
二维切片 go的数组和切片是一维的，要建立与二维数组或切片等效的数组或切片，须要定义array-of-arrays或slice-of-slices，以下所示
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."),
}复制代码
有时候须要申请一个二维切片，例如，scan在处理像素时可能出现这种状况。有两种方式实现：其一，独立地申请每个切片；另外一种是申请一个数组并将各个切片指向其中；具体使用哪一种方式取决于应用程序。若是切片可能会增加或收缩，则应单独分配它们，以免覆盖下一行；若是没有，则能够更有效地使用单个分配构造对象。如下是这两种方法的示意图，以供参考。首先，一次一行
// 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)
}复制代码
方法二：申请一个大的slice并划分为几行
// 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是一种方便而强大的内置数据结构，它将一种类型(键)的值与另外一种类型(元素或值)的值相关联。键能够是定义了相等运算符的任何类型，例如整数、浮点和复数、字符串、指针、接口(只要动态类型支持相等)、结构和数组；切片不能用做map的键，由于它们没有定义相等性。与切片同样，map保存对底层数据结构的引用: 若是将map传递给更改map内容的函数，则这些更改将在调用方中可见
可使用一般的复合文本语法和冒号分隔的键值对来构造，所以在初始化期间很容易构建它们
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中不存在的键获取map值时，将返回map中item类型的零值。例如，若是map包含整数，查找不存在的键将返回0; 集合能够实现为值类型为bool的映射，将map item设置为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”的条目？或者是0由于它根本不在map中，你能够用多重分配的形式来区分
var seconds int
var ok bool
seconds, ok = timeZone[tz]复制代码
这被称为"comma-ok"习语，在这个例子中，若是TZ存在seconds将被适当设置，ok将为true；不然，seconds被设置为零值，ok将为false。下面是一个函数，它将与一个error report放在一块儿
func offset(tz string) int {
if seconds, ok := timeZone[tz]; ok {
return seconds
}
log.Println("unknown time zone:", tz)
return 0
}
复制代码
在不关心实际值的状况下测试map中是否存在，可使用空白标识符代替值的经常使用变量
_, present := timeZone[tz]
复制代码
要删除map条目，请使用delete内置函数，该函数的参数是要删除的map和key。即便key已经不在map上，这样作也是安全的
delete(timeZone, "PDT") // Now on Standard Time复制代码
Printing go中的格式化打印使用了相似于C的printf系列的样式，但更加丰富和通用。这些函数位于fmt包中，并有大写的名称：fmt.Printf、fmt.Fpprintf、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和friends将实现io.Writer接口的任何对象做为第一个参数；变量os.Stdout和os.Stderr是常见的实例。更多细节此处不一一赘述
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，收集任意数量的参数
复制代码
Initialization 虽然看起来与C或C++中的初始化没有太大的区别，但Go中的初始化功能更强大。在初始化过程当中能够构建复杂的结构，而且正确地处理初始化对象之间的排序问题，甚至不一样包之间的排序问题
Constants Go中的常量就是常数，在编译时建立，即便在函数中定义为局部变量，也只能是数字、字符(rune)、字符串或布尔。因为编译时的限制，定义它们的表达式必须是常量表达式，由编译器计算，例如，1<<3是一个常量表达式，而math.sin(math.pi 4)不是，由于函数调用math.sin发生在运行时<="" p="">
在go中，使用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
)复制代码
将诸如string之类的方法附加到任何用户定义类型的能力使任意值可以自动格式化以供打印。尽管您将看到它最常应用于结构，但此技术对于标量类型(如ByteSize等浮点类型)也颇有用
func (b ByteSize) String() string {
switch {
case b >= YB:
return fmt.Sprintf("%.2fYB", b/YB)
case b >= ZB:
return fmt.Sprintf("%.2fZB", b/ZB)
case b >= EB:
return fmt.Sprintf("%.2fEB", b/EB)
case b >= PB:
return fmt.Sprintf("%.2fPB", b/PB)
case b >= TB:
return fmt.Sprintf("%.2fTB", b/TB)
case b >= GB:
return fmt.Sprintf("%.2fGB", b/GB)
case b >= MB:
return fmt.Sprintf("%.2fMB", b/MB)
case b >= KB:
return fmt.Sprintf("%.2fKB", b/KB)
}
return fmt.Sprintf("%.2fB", b)
}复制代码
Variables 变量能够像常量同样初始化，但初始化器能够是在运行时计算的通用表达式
var (
home = os.Getenv("HOME")
user = os.Getenv("USER")
gopath = os.Getenv("GOPATH")
)复制代码
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 may be overridden by --gopath flag on command line.
flag.StringVar(&gopath, "gopath", gopath, "override default GOPATH")
}
复制代码
接口及其余类型
接口 go中的接口提供了一种指定对象行为的方法。在go代码中，只有一个或两个方法的接口是常见的，一般会被赋予一个从该方法派生的名称，例如io.Writer用于实现Write的对象一个类型能够实现多个接口。例如，一个集合实现了sort.Interface(包含Len()、Less(i, j int) bool和Swap(i, j int))，那么它能够按包sort中的例程进行排序，而且它还能够有一个自定义格式化程序。在这个虚构的例子中，Sequence同时知足条件
type Sequence []int复制代码
// Methods required by sort.Interface.
func (s Sequence) Len() int {
return len(s)
}
func (s Sequence) Less(i, j int) bool {
return s[i] < s[j]
}
func (s Sequence) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
}复制代码
// Copy returns a copy of the Sequence.
func (s Sequence) Copy() Sequence {
copy := make(Sequence, 0, len(s))
return append(copy, s...)
}复制代码
// Method for printing - sorts the elements before printing.
func (s Sequence) String() string {
s = s.Copy() // Make a copy; don't overwrite argument.
sort.Sort(s)
str := "["
for i, elem := range s { // Loop is O(N²); will fix that in next example.
if i > 0 {
str += " "
}
str += fmt.Sprint(elem)
}
return str + "]"
}复制代码
Conversions Sequence的String方法正在从新建立Sprint已经为切片所作的工做(它具备O(N*N)时间复杂度，性能不好)。若是在调用Sprint以前将序列转换为[]int，咱们就能够共享工做(也能够加快工做速度)
func (s Sequence) String() string {
s = s.Copy()
sort.Sort(s)
return fmt.Sprint([]int(s))
}复制代码
此方法是转换技术的另外一个示例，用于从String方法安全地调用Sprintf。由于两个类型(Sequence和[]int）是相同的，若是咱们忽略类型名，那么在它们之间进行转换是合法的。转换不会建立新值，它只是临时地充当现有值具备新类型的角色。(还有其余合法的转换，例如从整数到浮点的转换，这里会建立新值)go程序中的一个习惯用法是将表达式的类型转换为访问一组不一样的方法。例如，咱们可使用现有的sort.Intslice类型将整个示例缩减为
type Sequence []int复制代码
// Method for printing - sorts the elements before printing
func (s Sequence) String() string {
s = s.Copy()
sort.IntSlice(s).Sort()
return fmt.Sprint([]int(s))
}复制代码
咱们再也不让Sequence实现多个接口(排序和打印)，而是使用将数据项转换为多个类型(Sequence、sort.Intslice和[]int)的能力，每一个类型都有效地完成部分工做
Interface conversions and type assertions Type switches是转换的一种形式：它们接受一个接口，对于switch中的每一种状况，在某种意义上都将其转换为该状况下的类型。下面是fmt.Printf下的代码：使用Type Switches将值转换为字符串的简化版本。若是它已是一个字符串，接口返回实际的字符串值；而若是它有一个字符串方法，调用该方法的结果
type Stringer interface {
String() string
}复制代码
var value interface{} // 调用方提供的值
switch str := value.(type) {
case string:
return str
case Stringer:
return str.String()
}复制代码
第一种状况找到一个具体的值；第二种状况将接口转换为另外一个接口
若是咱们只关心一种类型呢？若是咱们知道这个值包含一个字符串，咱们只想提取它？one-case的type switch能够实现，类型断言也能够。类型断言接受接口值，并从中提取指定显式类型的值
value.(typeName)复制代码
结果是一个typeName类型的新值，该类型必须是具体的接口类型，或者值能够转换为第二个接口类型。要提取值中的字符串，咱们能够编写
str := value.(string)复制代码
若是发现结果不包含字符串，会形成程序崩溃并出现运行时错误。这里使用"comma, ok"来安全地测试值是不是字符串
str, ok := value.(string)
if ok {
fmt.Printf("string value is: %q\n", str)
} else {
fmt.Printf("value is not a string\n")
}复制代码
若是类型断言失败，str将仍然存在并为string类型，只是它将具备零值，即空字符串
Generality 若是某类型的存在只为实现一个接口，而且不会在该接口以外存在导出方法，那么该类型自身也不须要被导出。仅导出接口能够清楚地代表，除了接口中描述的内容以外，它没有任何有趣的行为。在这种状况下，构造函数应该返回一个接口值，而不是实现类型。例如，在hash库中，crc32.NewIEEE和adler32.New都返回接口类型hash.Hash32。用CRC-32算法替换GO程序中的Adler-32只须要更改构造函数调用；其他代码不受算法更改的影响
相似的方法容许不一样密码包中的流密码算法与它们连接在一块儿的块密码分离。crypto/cipher包中的块接口指定块密码的行为，它提供对单个数据块的加密。而后，经过与bufio包的类比，实现这个接口的密码包能够用来构造流式密码，用流接口表示，而不须要知道块加密的细节。crypto/cipher形如
type Block interface {
BlockSize() int
Encrypt(dst, src []byte)
Decrypt(dst, src []byte)
}复制代码
type Stream interface {
XORKeyStream(dst, src []byte)
}复制代码
// 这里是counter mode（CTR）stream 的定义，它将分组密码转换为流密码；请注意，分组密码的详细实现被抽象出来了
// NewCTR不只适用于一个特定的加密算法和数据源，还适用于块接口和任何流的任何实现。由于它们返回接口值，因此用其余加密模式替换CTR加密是一种本地化的更改复制代码
// NewCTR returns a Stream that encrypts/decrypts using the given Block in
// counter mode. The length of iv must be the same as the Block's block size.
func NewCTR(block Block, iv []byte) Stream复制代码
Interfaces and methods 几乎任意类型均可以附加方法，几乎任何类型均可以实现接口。以http包为例，它定义了handler接口，任何实现handler的对象均可觉得http请求提供服务
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}复制代码
ResponseWriter自己就是一个接口，它提供将响应返回给客户端所需方法的访问。这些方法包括标准的Write方法，所以能够在可使用io.Writer的任何地方使用http.ResponseWriter。Request是一个结构，包含来自客户端的请求的解析表示
为了简洁起见，让咱们忽略POST并假设http请求老是GET方式；这种简化不会影响handler的设置方式。下面是一个简单但完整的处理程序实现，用于计算访问页面的次数
// Simple counter server.
type Counter struct {
n int
}复制代码
func (ctr *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
ctr.n++
fmt.Fprintf(w, "counter = %d\n", ctr.n)
}复制代码
// 做为参考,将Counter服务附加到url树上
import "net/http"
...
ctr := new(Counter)
http.Handle("/counter", ctr)
复制代码
为何要把计数器变成一个结构呢？只须要一个整数(接收器须要是指针，以便调用者能够看到增量)
// Simpler counter server.
type Counter int复制代码
func (ctr *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
*ctr++
fmt.Fprintf(w, "counter = %d\n", *ctr)
}复制代码
若是您的程序有一些内部状态，须要通知您访问了某个页面，该如何处理？经过将channel绑定到web页面来实现
// A channel that sends a notification on each visit.
// (Probably want the channel to be buffered.)
type Chan chan *http.Request复制代码
func (ch Chan) ServeHTTP(w http.ResponseWriter, req *http.Request) {
ch <- req
fmt.Fprint(w, "notification sent")
}复制代码
假设咱们想在args上显示调用服务二进制文件时使用的参数。能够很容易地编写一个函数来打印参数
func ArgServer() {
fmt.Println(os.Args)
}复制代码
// 如何将其转换为http服务器？咱们可让ArgServer成为某种类型的方法，忽略它的值，但有一种更简洁的方法
// 能够为除了指针和接口以外的任何类型定义方法，因此咱们能够为函数编写方法。http包中包含此代码复制代码
// The HandlerFunc type is an adapter to allow the use of
// ordinary functions as HTTP handlers. If f is a function
// with the appropriate signature, HandlerFunc(f) is a
// Handler object that calls f.
type HandlerFunc func(ResponseWriter, *Request)复制代码
// ServeHTTP calls f(w, req).
func (f HandlerFunc) ServeHTTP(w ResponseWriter, req *Request) {
f(w, req)
}复制代码
// HandlerFunc是一个带有ServeHTTP方法的类型，所以该类型的值能够服务于http请求
// 看看方法的实现：接收器是一个函数f，方法调用f。这可能看起来很奇怪，但与接收器是一个通道和在通道上发送的方法没有太大区别复制代码
// 要使ArgServer成为一个http服务，咱们首先修改其函数签名
// Argument server.
func ArgServer(w http.ResponseWriter, req *http.Request) {
fmt.Fprintln(w, os.Args)
}复制代码
// AargServer如今与HandlerFunc具备相同的函数签名，所以能够将其转换为该类型以访问其方法
http.Handle("/args", http.HandlerFunc(ArgServer))复制代码
// 当有人访问/args页面时，安装在该页面上的handler具备值ArgServer和类型HandlerFunc
// http服务将调用该类型的方法ServeHTTP，以ArgServer做为接收器，后者将依次调用ArgServer(经过HandlerFunc.ServeHTTP中的调用f(w，req))。而后显示参数
复制代码
在本节中，从一个结构、一个整数、一个channel和一个函数建立了一个http服务，这是由于接口只是一组方法，(几乎)能够为任何类型定义
嵌入 go不提供典型的、类型驱动的子类概念，但它确实可以经过在结构或接口中嵌入类型来“借用”已实现的片断。接口嵌入很是简单。咱们以前提到过io.Reader和io.Writer接口，下面是它们的定义
type Reader interface {
Read(p []byte) (n int, err error)
}复制代码
type Writer interface {
Write(p []byte) (n int, err error)
}复制代码
io包还导出其余几个接口，这些接口指定能够实现多个此类方法的对象。例如，有io.ReadWriter，一个同时包含读和写的接口。咱们能够经过显式地列出这两个方法来指定io.ReadWriter，可是嵌入这两个接口以造成新的接口更容易引发注意，以下所示
// ReadWriter is the interface that combines the Reader and Writer interfaces.
type ReadWriter interface {
Reader
Writer
}复制代码
ReadWriter能够作Reader和Writer作的事情；它是嵌入式接口(必须是不相交的方法集)的并集；接口中只能嵌入接口。一样的基本思想也适用于struct，bufio包有两种结构类型：bufio.Reader和bufio.Writer，固然每种类型都实现io包中相似的接口。bufio还实现了一个缓冲reader/writer，它经过使用嵌入将读写器组合到一个结构中来实现：它列出结构中的类型，但不给它们提供字段名
// ReadWriter stores pointers to a Reader and a Writer.
// It implements io.ReadWriter.
type ReadWriter struct {
*Reader // *bufio.Reader
*Writer // *bufio.Writer
}
复制代码
嵌入的元素是指向结构的指针，固然，在使用它们以前必须初始化为指向有效的结构。ReadWriter结构能够写成
type ReadWriter struct {
reader *Reader
writer *Writer
}复制代码
为了提高字段的方法并知足IO接口，咱们还须要提供转发方法，以下所示
func (rw *ReadWriter) Read(p []byte) (n int, err error) {
return rw.reader.Read(p)
}复制代码
嵌入类型的方法是默认提供的，这意味着bufio.ReadWriter不只具备bufio.Reader和bufio.Writer方法，并且还知足全部三个接口：io.Reader、io.Writer和io.ReadWriter
嵌入和子类有一个重要的区别 ：当咱们嵌入一个类型时，该类型的方法成为外部类型的方法，可是当调用它们时，方法的接收者是内部类型，而不是外部类型。在咱们的示例中，当调用bufio.ReadWriter的Read方法时，它的效果与上面写的转发方法彻底相同；接收方是ReadWriter的Reader字段，而不是ReadWriter自己
这个例子显示了一个嵌入的字段和一个常规的、命名的字段
type Job struct {
Command string
*log.Logger
}复制代码
Job类型如今具备Print、Printf、Println和*log.Logger的其余方法。固然也能够给Logger一个字段名，但没必要这样作。如今一旦初始化，咱们就能够为job记录日志
job.Println("starting now...")复制代码
Logger是Job结构的常规字段，所以咱们能够在Job的构造函数中以经常使用的方式初始化它，以下所示复制代码
func NewJob(command string, logger *log.Logger) *Job {
return &Job{command, logger}
}
// 或者，以符合文本方式初始化
job := &Job{command, log.New(os.Stderr, "Job: ", log.Ldate)}
复制代码
空白标识符
空白标识符可使用任何类型的值进行分配或声明，而且该值将被无害地丢弃(这有点像对Unix /dev/null文件的写入)。它表示一个只写的值，在须要变量但不关心实际值的地方使用一个占位符，具备很是好的用途
多重赋值中的空白标识符 在for-range循环中使用空白标识符是通常状况下的一种特殊场景:多重赋值。若是一个赋值要求在左边有多个值，但其中一个值不被程序使用，赋值左边的空白标识符能够避免建立一个伪变量，并清楚地代表该值将被丢弃。例如，当调用返回值和error的函数时，若是只有error是重要的，则使用空标识符丢弃不关心的值
if _, err := os.Stat(path); os.IsNotExist(err) {
fmt.Printf("%s does not exist\n", path)
}复制代码
有时您会看到为了忽略错误而丢弃错误值的代码；这是一种糟糕的作法
// Bad! This code will crash if path does not exist.
fi, _ := os.Stat(path)
if fi.IsDir() {
fmt.Printf("%s is a directory\n", path)
}复制代码
未使用的导入和变量 导入包或声明变量而不使用会发生编译错误。未使用的导入会使程序膨胀并致使编译缓慢，而一个已初始化但未使用的变量至少是一个浪费的计算，而且可能存在潜在bug。然而，当程序处于开发阶段时，常常会出现未使用的导入和变量，为了让编译继续运行而删除它们，但若是后续再次须要它们...就比较繁琐。空白标识符提供了一种解决方法
这个半成品程序有两个未使用的导入(fmt和io)和一个未使用的变量(fd)，看起来代码正确无误，实际上它是不可编译的
package main复制代码
import (
"fmt"
"io"
"log"
"os"
)复制代码
func main() {
fd, err := os.Open("test.go")
if err != nil {
log.Fatal(err)
}
// TODO: use fd.
}复制代码
若要消除有关未使用导入的报错，请使用空白标识符引用导入包中的符号。相似地，将未使用的变量fd分配给空白标识符将使未使用的变量错误消失。这个版本的程序是可编译的
package main复制代码
import (
"fmt"
"io"
"log"
"os"
)复制代码
var _ = fmt.Printf // For debugging; delete when done.
var _ io.Reader // For debugging; delete when done.复制代码
func main() {
fd, err := os.Open("test.go")
if err != nil {
log.Fatal(err)
}
// TODO: use fd.
_ = fd
}复制代码
按照惯例，导入错误的全局声明应该在导入后当即发布并进行注释，这样既便于查找，又能够提醒之后清理
导入的反作用 上一个例子中未使用的导入(如fmt或io)最终应该被使用或删除：空白赋值将代码标识为正在进行的工做。但有时导入一个包仅仅是为了它的反作用，而没有任何显式的使用是有用的。例如，在其init函数期间，为http handler提供调试信息而注册net/http/pprof包。它有一个导出的api，可是大多数客户机只须要注册handler并经过web页面访问数据。若导入包仅为获取其反作用，请将包重命名为空白标识符
import _ "net/http/pprof" // 这种形式的导入清楚地代表，导入包是由于它的反作用，由于包没有其余可能的用途：在这个文件中，它没有名称
复制代码
接口检查 正如咱们在上面的接口讨论中看到的，类型不须要显式声明它实现了接口。相反，类型只是经过实现接口的方法来实现接口。实际上，大多数接口转换都是静态的，所以在编译时进行检查。例如，将os.File传递给须要io的函数。除非os.File实现io.Reader接口，不然不会被编译
一些接口检查发生在运行时，例如，在encoding/json包中，它定义了一个Marshall接口。当JSON编码器接收到实现该接口的值时，编码器调用该值的处理方法将其转换为JSON，而不是执行标准转换。编码器在运行时使用以下断言类型检查此属性
m, ok := val.(json.Marshaler)复制代码
若是只须要询问类型是否实现了接口，而不实际使用接口自己(多是错误检查的一部分)，则使用空标识符忽略类型断言的值
if _, ok := val.(json.Marshaler); ok {
fmt.Printf("value %v of type %T implements json.Marshaler\n", val, val)
}复制代码
并发
共享通讯 并发编程是一个很大的主题，这里只涉及特定于Golang的亮点。许多环境中的并发编程因为实现对共享变量的正确访问所需的微妙之处而变得困难。go鼓励采用一种不一样的方法，在channel上传递共享值，事实上，历来没有被单独的执行线程主动共享过。在任何给定时间，只有一个goroutine能够访问该值。按照设计，不会发生数据竞争。为了鼓励这种思惟方式，咱们把它简化为一个口号
*不要经过共享内存进行通讯；而是经过通讯共享内存*
思考这个模型的一种方法是考虑在一个CPU上运行一个典型的单线程程序，它不须要同步原语。如今运行另外一个这样的实例；它也不须要同步。如今让这两个通讯；若是通讯是同步地，则仍然不须要其余同步。例如，unix管道很是适合这个模型。尽管go的并发性方法起源于Hoare's的通讯顺序进程(Communication Sequential Processes，CSP)，但它也能够看做是Unix管道的一种类型安全的泛化
Gorutines 它们之因此被称为Goroutines，是由于现有的术语(线程、协程、进程等)传递了不许确的含义。Goroutine有一个简单的模型：它是一个与同一地址空间中的其余Goroutine同时执行的函数。它是轻量级的，只需分配堆栈空间。并且堆栈开始很小，因此很便利，而且经过根据须要分配(和释放)堆存储来增加
goroutine被多路复用到多个OS线程上，所以若是其中一个线程被阻塞，例如在等待i/o时，其余线程将继续运行，它们的设计隐藏了线程建立和管理的许多复杂性。在函数或方法调用前面加上go关键字，建立新的goroutine运行调用。当调用完成时，goroutine将默默地退出(效果相似于Unix Shell在后台运行命令的符号&)
go list.Sort() // run list.Sort concurrently; don't wait for it.复制代码
在goroutine调用中，文本函数很是方便
func Announce(message string, delay time.Duration) {
go func() {
time.Sleep(delay)
fmt.Println(message)
}() // Note the parentheses - must call the function.
}复制代码
Channels 与映射相似，channel也使用make进行分配，结果值做为对底层数据结构的引用。若是提供了可选的整数参数，表示设置通道的缓冲区大小；对于未设置缓存区大小或同步通道，默认值为零
ci := make(chan int) // unbuffered channel of integers
cj := make(chan int, 0) // unbuffered channel of integers
cs := make(chan *os.File, 100) // buffered channel of pointers to Files复制代码
无缓冲channel将通讯(值的交换)与同步结合起来，保证两个计算(goroutine)处于Ready状态
使用channel有不少很好的习惯用法。在上一节中，咱们在后台启动了排序，channel能够容许启动goroutine等待排序完成
c := make(chan int) // Allocate a channel.
// Start the sort in a goroutine; when it completes, signal on the channel.
go func() {
list.Sort()
c <- 1 // Send a signal; value does not matter.
}()
doSomethingForAWhile()
<-c // Wait for sort to finish; discard sent value.复制代码
Receiver老是处于阻塞状态直到有数据要接收。若是不是缓冲channel，则发送方阻塞，直到接收器接收到该值。若是是带缓冲的channel，则发送方仅在值复制到缓冲区以前阻塞；若是缓冲区已满，则意味着要等待某个接收器检索到值
带缓冲的channels能够像信号量同样使用，例如限制吞吐量。在本例中，传入的请求被传递到handle，handle将值发送到channel，处理请求，而后从channel接收值，以便为下一个使用者准备信号量。channel缓冲区的容量限制了要处理的同时调用的数量
var sem = make(chan int, MaxOutstanding)复制代码
func handle(r *Request) {
sem <- 1 // Wait for active queue to drain.
process(r) // May take a long time.
<-sem // Done; enable next request to run.
}复制代码
func Serve(queue chan *Request) {
for {
req := <-queue
go handle(req) // Don't wait for handle to finish.
}
}复制代码
一旦handlers正在执行进程达到MaxOutstanding，将阻止尝试发送到channel的缓冲区，直到现有处理程序完成退出而后从缓冲区接收下一个信号。不过，这种设计有一个问题：Server为每一个传入的请求建立一个新的goroutine，即便MaxUnstanding能够在任什么时候候运行。若是请求太快，程序能够消耗无限的资源。咱们能够经过将Server更改成goroutines的建立gate来解决这个缺陷。这是一个显而易见的解决方案，但请注意它有一个咱们稍后将修复的错误
func Serve(queue chan *Request) {
for req := range queue {
sem <- 1
go func() {
process(req) // Buggy; see explanation below.
<-sem
}()
}
}
复制代码
bug在于，在go的for循环中，循环变量在每次迭代中都被重用，所以req变量在全部goroutine中共享...这不是咱们想要的。咱们须要确保每一个goroutine的req是惟一的。有一种方法能够作到这一点，将req的值做为参数传递给goroutine中的闭包
func Serve(queue chan *Request) {
for req := range queue {
sem <- 1
go func(req *Request) {
process(req)
<-sem
}(req)
}
}复制代码
与前一版本进行比较，以查看如何声明和运行闭包；另外一个解决方案是建立一个同名的新变量，如本例所示
func Serve(queue chan *Request) {
for req := range queue {
req := req // Create new instance of req for the goroutine.
sem <- 1
go func() {
process(req)
<-sem
}()
}
}复制代码
// req := req 看起来很奇怪，这是合法的也是处理这种问题的惯用方法：得到同名变量的新版本，故意在本地隐藏循环变量，但对每一个goroutine都是惟一的复制代码
回到编写服务器的通常问题，管理好资源的另外一种方法是启动固定数量的handle goroutines，从请求channels读取全部内容。goroutines的数量限制了同时调用进程的次数。这个服务函数还接受一个channel，在这个channel上，它将被告知退出；在启动goroutines以后，它将阻止从该channel接收
func handle(queue chan *Request) {
for r := range queue {
process(r)
}
}复制代码
func Serve(clientRequests chan *Request, quit chan bool) {
// Start handlers
for i := 0; i < MaxOutstanding; i++ {
go handle(clientRequests)
}
<-quit // Wait to be told to exit.
}复制代码
Channels of channels go最重要的特性之一是channel是first-class值，能够像其余任何channel同样分配和传递。此属性的一个常见用途是实现安全的并行解复用。在上一节的示例中，handle是请求的理想处理程序，但咱们没有定义它正在处理的类型。若是该类型包含Response channel，则每一个客户端均可觉得Response提供本身的路径。下面是请求类型的示意定义
type Request struct {
args []int
f func([]int) int
resultChan chan int
}复制代码
客户端提供一个函数及其参数，以及请求对象内部的channel，用于接受Response
func sum(a []int) (s int) {
for _, v := range a {
s += v
}
return
}复制代码
request := &Request{[]int{3, 4, 5}, sum, make(chan int)}
// Send request
clientRequests <- request
// Wait for response.
fmt.Printf("answer: %d\n", <-request.resultChan)复制代码
在服务器端，仅需改变handler函数便可。显然还要作不少事情才能实现它，但这段代码是一个用于速率受限、并行、非阻塞的RPC系统的框架，并且看不到互斥锁
func handle(queue chan *Request) {
for req := range queue {
req.resultChan <- req.f(req.args)
}
}复制代码
Parallelization 这些思想的另外一个应用是跨多个CPU核并行计算。若是能够将计算分解成能够独立执行的单独部分，则能够将其并行化，并在每一个部分完成时提供一个信号通道
假设咱们有一个昂贵的操做来执行向量上的项目，而且每一个项的操做值都是独立的，这是个理想化的例子
type Vector []float64复制代码
// Apply the operation to v[i], v[i+1] ... up to v[n-1].
func (v Vector) DoSome(i, n int, u Vector, c chan int) {
for ; i < n; i++ {
v[i] += u.Op(v[i])
}
c <- 1 // signal that this piece is done
}复制代码
在循环中独立地启动这些部件，每一个核一个。它们能够按任何顺序完成，但这可有可无；咱们只需在启动全部goroutine以后经过draining通道来计算完成信号
const numCPU = 4 // number of CPU cores复制代码
func (v Vector) DoAll(u Vector) {
c := make(chan int, numCPU) // Buffering optional but sensible.
for i := 0; i < numCPU; i++ {
go v.DoSome(i*len(v)/numCPU, (i+1)*len(v)/numCPU, u, c)
}
// Drain the channel.
for i := 0; i < numCPU; i++ {
<-c // wait for one task to complete
}
// All done.
}
复制代码
运行时核数的设置，能够没必要硬编码，经过runtime.NumCPU来设置机器中硬件实际的CPU数量
var numCPU = runtime.NumCPU()复制代码
还有一个函数runtime.GOMAXPROCS，它报告(或设置)go程序能够同时运行用户指定核数。它默认为runtime.NumCPU值，但能够经过设置名称相似的Shell环境变量或经过使用正数调用函数来覆盖默认值，用零调用它只是查询值。所以，若是咱们想知足用户的资源请求，咱们应该写
var numCPU = runtime.GOMAXPROCS(0)复制代码
缓冲 并发编程的工具也可使非并发性的想法更容易表达。下面是一个从RPC包中抽象出来的示例。客户端goroutine循环从某个源(多是网络)接收数据。为了不分配和释放缓冲区，它保留一个空闲list，并使用一个缓冲通道来表示它。若是通道为空，则分配新的缓冲区。一旦消息缓冲区准备好，它就经过serverChan发送到服务器上
var freeList = make(chan *Buffer, 100)
var serverChan = make(chan *Buffer)复制代码
func client() {
for {
var b *Buffer
// Grab a buffer if available; allocate if not.
select {
case b = <-freeList:
// Got one; nothing more to do.
default:
// None free, so allocate a new one.
b = new(Buffer)
}
load(b) // Read next message from the net.
serverChan <- b // Send to server.
}
}复制代码
服务端循环从客户端接收每条消息，对其进行处理，并将返回缓冲区空闲列表
func server() {
for {
b := <-serverChan // Wait for work.
process(b)
// Reuse buffer if there's room.
select {
case freeList <- b:
// Buffer on free list; nothing more to do.
default:
// Free list full, just carry on.
}
}
}复制代码
Errors
库例程必须常常向调用方返回某种错误指示。如前所述，go的多值返回使得在返回正常值的同时返回详细的错误描述变得很容易。使用此功能提供详细的错误信息是一种很好的方式。例如，正如咱们将看到的，os.Open不只在失败时返回一个nil指针，它还返回一个错误值来描述发送什么错误
错误有一个类型error，一个简单的内置接口
type error interface {
Error() string
}复制代码
库编写者能够自由地使用更丰富的模型来实现这个接口，这样不只能够看到错误，还能够提供一些上下文。如前所述，除了一般的*os.File返回值外，os.Open还返回一个错误值。若是文件成功打开，则错误为nil，但出现问题时，它将返回一个os.PathError
// PathError records an error and the operation and
// file path that caused it.
type PathError struct {
Op string // "open", "unlink", etc.
Path string // The associated file.
Err error // Returned by the system call.
}复制代码
func (e *PathError) Error() string {
return e.Op + " " + e.Path + ": " + e.Err.Error()
}
复制代码
- 1. Golang(二)高效编程
- 2. cuda编程系列-高效编程（二）
- 3. Golang之并发编程二
- 4. 高效PHP编程
- 5. MySQL高效编程
- 6. Python高效编程
- 7. 如何高效的编程！
- 8. Java高效编程2
- 9. Python高效编程技巧
- 10. 高效编程之原则
- 更多相关文章...
- • Rust 并发编程 - RUST 教程
- • SVG 模糊效果 - SVG 教程
- • RxJava操作符（二）Transforming Observables
- • Java 8 Stream 教程
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Golang(二)高效编程
- 2. cuda编程系列-高效编程（二）
- 3. Golang之并发编程二
- 4. 高效PHP编程
- 5. MySQL高效编程
- 6. Python高效编程
- 7. 如何高效的编程！
- 8. Java高效编程2
- 9. Python高效编程技巧
- 10. 高效编程之原则