Go的代码规范指南-新人必看

export GOPATH=~/go的安装目录
source ~/.bashrc 激活配置文件，然后可以通过go env或者echo $GOPATH命令看到变量输出改变了。

如果不想上面那么搞，则可以直接设置多个GOPATH目录。
假设现在本地硬盘上有3个Go代码工程，分别为~/work/go-proj1、~/work2/goproj2和 ~/work3/work4/go-proj3，那么GOPATH可以设置为如下内容:
export GOPATH=~/work/go-proj1:~/work2/goproj2:~/work3/work4/go-proj3
经过这样的设置后，你可以在任意位置对以上的3个工程进行构建。

1. 命名 
命名规则涉及变量、常量、全局函数、结构、接口、方法等的命名。Go语言从语法层面进 行了以下限定:
任何需要对外暴露的名字必须以大写字母开头，不需要对外暴露的则应该以小写 字母开头。 
Go推行驼峰命名法排斥下划线命名法
2、排列
Go的代码左花括号严格要求不能换行
3、代码摆放乱
go fmt xx.go格式化为标准go文件
4、go的远程包导入
import可以导入本地包，也可以导入GitHub上的远程包，比如如下示例
package main
import ( "fmt"
    "github.com/myteam/exp/crc32"
)
然后，在执行go build或者go install之前，只需要加这么一句: go get github.com/myteam/exp/crc32

版权说明注释、包说明注释、函数说明注释和最后添 加的遗留问题说明，举个例子

$ go doc foo本地输出文档化
  godoc -http=:76 -path="." 浏览器访问http://localhost:76/pkg/foo/输出文档化

执行功能单元测试非常简单，直接执行go test命令
go test simplematch(上面目录结构图)
性能测试的，增加-test.bench参数
go test–test.bench add.go

关键字var，而类型信息放在变量名之后，示例如下:
var v1 int
var v2 string 
var v3 [10]int // 数组
var v4 []int  // 数组切片
var v5 struct {
   f int 
}
var v6 *int // 指针
var v7 map[string]int // map，key为string类型，value为int类型
var v8 func(a int) int
变量声明语句不需要使用分号作为结束符。
省略多个重复var的申明：
var (
  v1 int
  v2 string
)

var v1 int = 10 // 正确的使用方式1
var v2 = 10 // 正确的使用方式2，编译器可以自动推导出v2的类型 
v3 := 10 // 正确的使用方式3，编译器可以自动推导出v3的类型

在Go语法中，变量初始化和变量赋值是两个不同的概念
var v10 int 
v10 = 123

func GetName() (firstName, lastName, nickName string) { 
return "May", "Chan", "Chibi Maruko"
} 
若只想获得nickName，则函数调用语句可以用如下方式编写:
_, _, nickName := GetName()

const a, b, c = 3, 4, "foo" //a=3,b=4,c="foo", 无类型整型和字符串常量
const zero = 0.0 
const (
size int64 = 1024 
eof = -1
// 无类型浮点常量 // 无类型整型常量
)
const Pi float64 = 3.14159265358979323846
const u, v float32 = 0, 3

const (
        Sunday = iota
        Monday
        Tuesday
        Wednesday
        Thursday
        Friday
        Saturday
        numberOfDays// 这个常量没有导出，因为大写字母外包可见，小写字母属于私有
        ）

创建一个初始元素个数为5的数组切片，元素初始值为0:
mySlice1 := make([]int, 5)
创建一个初始元素个数为5的数组切片，元素初始值为0，并预留10个元素的存储空间:
mySlice2 := make([]int, 5, 10)
直接创建并初始化包含5个元素的数组切片:
mySlice3 := []int{1, 2, 3, 4, 5}

传统的元素遍历方法如下:
for i := 0; i <len(mySlice); i++ { fmt.Println("mySlice[", i, "] =", mySlice[i])
}
使用range关键字可以让遍历代码显得更整洁。range表达式有两个返回值，第一个是索引，
第二个是元素的值:
for i, v := range mySlice { fmt.Println("mySlice[", i, "] =", v)
}

slice1 := []int{1, 2, 3, 4, 5} 
slice2 := []int{5, 4, 3}
copy(slice2, slice1) // 只会复制slice1的前3个元素到slice2中 copy(slice1, slice2) 
// 只会复制slice2的3个元素到slice1的前3个位置

申明：var myMap map[string] PersonInfo
创建：myMap = make(map[string] PersonInfo)
性能优化-指定分配存储空间：myMap = make(map[string] PersonInfo, 100)
元素的赋值：
myMap["1234"] = PersonInfo{"1", "Jack", "Room 101,..."}
元素的删除：
delete(myMap, "1234")
元素的查找：
value, ok := myMap["1234"] 
if ok {// 找到了
// 处理找到的value 
}

if a < 5 { 
  return 0
} else { 
  return 1
}
 条件语句不需要使用括号将条件包含起来();
 无论语句体内有几条语句，花括号{}都是必须存在的;
 左花括号{必须与if或者else处于同一行;
 在if之后，条件语句之前，可以添加变量初始化语句，使用;间隔;
 在有返回值的函数中，不允许将“最终的”return语句包含在if...else...结构中，
否则会编译失败:
switch i { 
  case 0:
    fmt.Printf("0") 
  case 1:
    fmt.Printf("1") 
  case 2:
    fallthrough 
  case 3:
    fmt.Printf("3") 
  case 4, 5, 6:
    fmt.Printf("4, 5, 6") 
  default:
    fmt.Printf("Default")
}
在使用switch结构时，我们需要注意以下几点:
 左花括号{必须与switch处于同一行;
 条件表达式不限制为常量或者整数;
 单个case中，可以出现多个结果选项;
 与C语言等规则相反，Go语言不需要用break来明确退出一个case;
 只有在case中明确添加fallthrough关键字，才会继续执行紧跟的下一个case; 
可以不设定switch之后的条件表达式，在此种情况下，整个switch结构与多个
if...else...的逻辑作用等同
sum := 0
for i := 0; i < 10; i++ {
 sum += i 
}
在条件表达式中也支持多重赋值，如下所示:
a := []int{1, 2, 3, 4, 5, 6}
for i, j := 0, len(a) – 1; i < j; i, j = i + 1, j – 1 {
    a[i], a[j] = a[j], a[i]
}
使用循环语句时，需要注意的有以下几点。
 左花括号{必须与for处于同一行。
 Go语言中的for循环与C语言一样，都允许在循环条件中定义和初始化变量，唯一的区别
是，Go语言不支持以逗号为间隔的多个赋值语句，必须使用平行赋值的方式来初始化多
个变量。
 Go语言的for循环同样支持continue和break来控制循环，但是它提供了一个更高级的
 break，可以选择中断哪一个循环
goto语句的语义非常简单，就是跳转到本函数内的某个标签，如:
func myfunc() { 
    i := 0
    HERE:
    fmt.Println(i)
    i++
    if i < 10 {
      goto HERE 
     }
}

1. 不定参数类型
不定参数是指函数传入的参数个数为不定数量。为了做到这点，首先需要将函数定义为接受 不定参数类型:
  func myfunc(args ...int) {
for _, arg := range args {
        fmt.Println(arg)
    }
}
如下方式调用:
    myfunc(2, 3, 4)
    myfunc(1, 3, 7, 13)
2. 不定参数的传递
假设有另一个变参函数叫做myfunc3(args ...int)，下面的例子演示了如何向其传递变参:
func myfunc(args ...int) { // 按原样传递
        myfunc3(args...)
// 传递片段，实际上任意的int slice都可以传进去
        myfunc3(args[1:]...)
    }
3. 任意类型的不定参数
之前的例子中将不定参数类型约束为int，如果你希望传任意类型，可以指定类型为 interface{}。下面是Go语言标准库中fmt.Printf()的函数原型:
func Printf(format string, args ...interface{}) { // ...
}

一般channel的声明形式为:
var chanName chan ElementType
与一般的变量声明不同的地方仅仅是在类型之前加了chan关键字。ElementType指定这个 channel所能传递的元素类型。举个例子，我们声明一个传递类型为int的channel:
 var ch chan int
 或者，我们声明一个map，元素是bool型的channel:
var m map[string] chan bool
定义一个channel也很简单，直接使用内置的函数make()即可: ch := make(chan int)
在channel的用法中，最常见的包括写入和读出。将一个数据写入(发送)至channel的语法
很直观，如下:
ch <- value
 向channel写入数据通常会导致程序阻塞，直到有其他goroutine从这个channel中读取数据。
 从 channel中读取数据的语法是
value := <-ch
 如果channel之前没有写入数据，那么从channel中读取数据也会导致程序阻塞，直到channel 中被写入数据为止。
 我们之后还会提到如何控制channel只接受写或者只允许读取，即单向 channel。

Go语言直接在语言级别支持select关键字，用于处理异步IO 问题。
select的用法与switch语言非常类似，由select开始一个新的选择块，每个选择条件由 case语句来描述。
与switch语句可以选择任何可使用相等比较的条件相比，select有比较多的 限制，
其中最大的一条限制就是每个case语句里必须是一个IO操作，大致的结构如下
select {
case <-chan1:
// 如果chan1成功读到数据，则进行该case处理语句 
case chan2 <- 1:
// 如果成功向chan2写入数据，则进行该case处理语句 d
efault:
// 如果上面都没有成功，则进入default处理流程 
}
比如如下的死循环例子：
ch := make(chan int, 1) for {
select {
case ch <- 0:
case ch <- 1: }
i := <-ch
        fmt.Println("Value received:", i)
    }

 c := make(chan int, 1024) 
在调用make()时将缓冲区大小作为第二个参数传入即可 
for i := range c { fmt.Println("Received:", i)
}
利用超时机制，防止死锁问题
// 首先，我们实现并执行一个匿名的超时等待函数 
timeout := make(chan bool, 1)
go func() {
time.Sleep(1e9) // 等待1秒钟
timeout <- true }()
// 然后我们把timeout这个channel利用起来 select {
case <-ch:
// 从ch中读取到数据
case <-timeout:
// 一直没有从ch中读取到数据，但从timeout中读取到了数据
   }

单向channel变量的声明非常简单，如下:
var ch1 chan int // ch1是一个正常的channel，不是单向的 
var ch2 chan<- float64// ch2是单向channel，只用于写float64数据
var ch3 <-chan int // ch3是单向channel，只用于读取int数据
ch4 := make(chan int)
ch5 := <-chan int(ch4) // ch5就是一个单向的读取
ch6 := chan<- int(ch4) // ch6 是一个单向的写入channel

关闭channel非常简单，直接使用Go语言内置的close()函数即可:
 close(ch)
 判断是否关闭
 x, ok := <-ch

type Vector []float64
// 分配给每个CPU的计算任务
func (v Vector) DoSome(i, n int, u Vector, c chan int) {
 for ; i < n; i++ {
v[i] += u.Op(v[i])
}
c <- 1
// 发信号告诉任务管理者我已经计算完成了
}
const NCPU = 16
func (v Vector) DoAll(u Vector) {
c := make(chan int, NCPU) // 用于接收每个CPU的任务完成信号
for i := 0; i < NCPU; i++ {
go v.DoSome(i*len(v)/NCPU, (i+1)*len(v)/NCPU, u, c)
}
// 等待所有CPU的任务完成
for i := 0; i < NCPU; i++ {
<-c // 获取到一个数据，表示一个CPU计算完成了 }
// 到这里表示所有计算已经结束 }

Go语言如果不支持多核默认的话，可以手动设置
代码中启动goroutine之前先调用以下这个语句以设置使用16个CPU 核心:
runtime.GOMAXPROCS(16)

对于从全局的角度只需要运行一次的代码，比如全局初始化操作，Go语言提供了一个Once
类型来保证全局的唯一性操作，具体代码如下:
var a string
var once sync.Once
func setup() {
a = "hello, world"
}
func doprint() { once.Do(setup)
print(a) }
func twoprint() { go doprint() go doprint()
}

socket编程：
(1) 建立Socket:使用socket()函数。
(2) 绑定Socket:使用bind()函数。
(3) 监听:使用listen()函数。或者连接:使用connect()函数。
(4) 接受连接:使用accept()函数。
(5) 接收:使用receive()函数。或者发送:使用send()函数
Go的网络编程：
Go语言标准库对此过程进行了抽象和封装。无论我们期望使用什么协议建立什么形式的连
接，都只需要调用net.Dial()即可
TCP链接:
    conn, err := net.Dial("tcp", "192.168.0.10:2100")
UDP链接:
conn, err := net.Dial("udp", "192.168.0.12:975")
ICMP链接(使用协议名称):
conn, err := net.Dial("ip4:icmp", "www.baidu.com")
ICMP链接(使用协议编号):
conn, err := net.Dial("ip4:1", "10.0.0.3")
目前，Dial()函数支持如下几种网络协议:"tcp"、"tcp4"(仅限IPv4)、"tcp6"(仅限 IPv6)、"udp"、"udp4"(仅限IPv4)、"udp6"(仅限IPv6)、"ip"、"ip4"(仅限IPv4)和"ip6"
(仅限IPv6)


HTTP编程
HTTP(HyperText Transfer Protocol，超文本传输协议)是互联网上应用最为广泛的一种网络 协议，
定义了客户端和服务端之间请求与响应的传输标准
基本方法
net/http包的Client类型提供了如下几个方法，让我们可以用最简洁的方式实现 HTTP 请求:
func (c *Client) Get(url string) (r *Response, err error)
func (c *Client) Post(url string, bodyType string, body io.Reader) (r *Response, err
error)
func (c *Client) PostForm(url string, data url.Values) (r *Response, err error) func (c *Client) Head(url string) (r *Response, err error)
func (c *Client) Do(req *Request) (resp *Response, err error)


RPC编程
RPC 采用客户端—服务器(Client/Server)的工作模式。请求程序就是一个客户端(Client)， 
而服务提供程序就是一个服务器(Server)。当执行一个远程过程调用时，客户端程序首先发送一 
个带有参数的调用信息到服务端，然后等待服务端响应。在服务端，服务进程保持睡眠状态直到 
客户端的调用信息到达为止。当一个调用信息到达时，服务端获得进程参数，计算出结果，
并向 客户端发送应答信息，然后等待下一个调用。最后，客户端接收来自服务端的应答信息，
获得进 程结果，然后调用执行并继续进行
一个对象中只有满足如下这些条件的方法，才能被 RPC 服务端设置为可供远程访问:
 必须是在对象外部可公开调用的方法(首字母大写);
 必须有两个参数，且参数的类型都必须是包外部可以访问的类型或者是Go内建支持的类
型;
 第二个参数必须是一个指针;
 方法必须返回一个error类型的值。
以上4个条件，可以简单地用如下一行代码表示:
func (t *T) MethodName(argType T1, replyType *T2) error

JSON处理
使用json.Marshal()函数可以对一组数据进行JSON格式的编码。json.Marshal()函数 的声明如下:
func Marshal(v interface{}) ([]byte, error)
假如有如下一个Book类型的结构体:
type Book struct { 
Title string
Authors []string 
Publisher string 
IsPublished bool 
Price float
}
并且有如下一个 Book 类型的实例对象:
gobook := Book{ "Go语言编程",
["XuShiwei", "HughLv", "Pandaman", "GuaguaSong", "HanTuo", "BertYuan", "XuDaoli"],
"ituring.com.cn", true,
9.99
}
然后，我们可以使用 json.Marshal() 函数将gobook实例生成一段JSON格式的文本:
    b, err := json.Marshal(gobook)
如果编码成功，err 将赋于零值 nil，变量b 将会是一个进行JSON格式化之后的[]byte 类型:
b == []byte(`{
"Title": "Go语言编程",
"Authors": ["XuShiwei", "HughLv", "Pandaman", "GuaguaSong", "HanTuo", "BertYuan",
             "XuDaoli"],
         "Publisher": "ituring.com.cn",
         "IsPublished": true,
         "Price": 9.99
}`)

在Go中，JSON转化前后的数据类型映射如下。
 布尔值转化为JSON后还是布尔类型。
 浮点数和整型会被转化为JSON里边的常规数字。
 字符串将以UTF-8编码转化输出为Unicode字符集的字符串，特殊字符比如<将会被转义为
 \u003c。
 数组和切片会转化为JSON里边的数组，但[]byte类型的值将会被转化为 Base64 编码后
的字符串，slice类型的零值会被转化为 null。
 结构体会转化为JSON对象，并且只有结构体里边以大写字母开头的可被导出的字段才会
被转化输出，而这些可导出的字段会作为JSON对象的字符串索引。 3 转化一个map类型的数据结构时，该数据的类型必须是 map[string]T(T可以是
encoding/json 包支持的任意数据类型)。

可以使用json.Unmarshal()函数将JSON格式的文本解码为Go里边预期的数据结构。 json.Unmarshal()函数的原型如下:
   func Unmarshal(data []byte, v interface{}) error
   
在解码JSON 数据的过程中，JSON数据里边的元素类型将做如下转换:
 JSON中的布尔值将会转换为Go中的bool类型;  数值会被转换为Go中的float64类型;
 字符串转换后还是string类型;
 JSON数组会转换为[]interface{}类型;
 JSON对象会转换为map[string]interface{}类型;  null值会转换为nil。
在Go的标准库encoding/json包中，允许使用map[string]interface{}和[]interface{} 类型的值来分别存放未知结构的JSON对象或数组

常见的单密钥加密算法有DES、AES、 RC4等。
私钥和公钥都可以被用作加密或者解密，但是用私 钥加密的明文，必须要用对应的公钥解密，用公钥加密的明文，必须用对应的私钥解密。
常见的 双密钥加密算法有RSA等。
常见的哈希算法包括MD5、SHA-1等。

证书加密HTTPS
(1) 在浏览器中输入HTTPS协议的网址。
(2) 服务器向浏览器返回证书，浏览器检查该证书的合法性
(3) 验证合法性
(4) 浏览器使用证书中的公钥加密一个随机对称密钥，并将加密后的密钥和使用密钥加密后 的请求URL一起发送到服务器
(5) 服务器用私钥解密随机对称密钥，并用获取的密钥解密加密的请求URL
(6) 服务器把用户请求的网页用密钥加密，并返回给用户
(7) 用户浏览器用密钥解密服务器发来的网页数据，并将其显示出来
SSL协议由两层组成，上层协议包括SSL握手协议、更改密码规格协议、警报协议，下层协 议包括SSL记录协议。
SSL握手协议建立在SSL记录协议之上，在实际的数据传输开始前，用于在客户与服务器之 间进行“握手”。“握手”是一个协商过程。这个协议使得客户和服务器能够互相鉴别身份，协商 加密算法。在任何数据传输之前，必须先进行“握手”。
在“握手”完成之后，才能进行SSL记录协议，它的主要功能是为高层协议提供数据封装、 压缩、添加MAC、加密等支持

//1、将错误返回给调用者
resp, err := http.Get(url) 
if err != nil{
return nill, err 
}
//2、将构造新的信息返回给调用者
doc, err := html.Parse(resp.Body) 
resp.Body.Close()
if err != nil {
return nil, fmt.Errorf("parsing %s as HTML: %v", url,err)
 }
 //3、如果错误发生后，程序无法继续运行，我们就可以采用第三种策略:输出错误信息并结束程序。
 //需 要注意的是，这种策略只应在main中执行。对库函数而言，应仅向上传播错误，除非该错误意味着 
 //程序内部包含不一致性，即遇到了bug，才能在库函数中结束程序。
if err := WaitForServer(url); err != nil { 
 fmt.Fprintf(os.Stderr, "Site is down: %v\n", err) 
 os.Exit(1)
}
//4、第四种策略:有时，我们只需要输出错误信息就足够了，不需要中断程序的运行。我们可以通过 log包提供函数
if err := Ping(); err != nil {
log.Printf("ping failed: %v; networking disabled",err)
}
//或者标准错误流输出错误信息。
if err := Ping(); err != nil {
fmt.Fprintf(os.Stderr, "ping failed: %v; networking disabled\n", err)
}
//5、第五种，也是最后一种策略:我们可以直接忽略掉错误。
dir, err := ioutil.TempDir("", "scratch") if err != nil {
return fmt.Errorf("failed to create temp dir: %v",err) 
}
// ...use temp dir...
os.RemoveAll(dir)
//尽管os.RemoveAll会失败，但上面的例子并没有做错误处理。
//这是因为操作系统会定期的清理临时 目录。正因如此，虽然程序没有处理错误，
//但程序的逻辑不会因此受到影响。我们应该在每次函数 调用后，都养成考虑错误处理的习惯，
//当你决定忽略某个错误时，你应该在清晰的记录下你的意 图。 

import "database/sql"
func listTracks(db sql.DB, artist string, minYear, maxYear int) { 
result, err := db.Exec(
"SELECT * FROM tracks WHERE artist = ? AND ? <= year AND year <= ?",
artist, minYear, maxYear)
// ...
}
Exec方法使用SQL字面量替换在查询字符串中的每个'?';SQL字面量表示相应参数的值，
它有可能 是一个布尔值，一个数字，一个字符串，或者nil空值。用这种方式构造查询可以帮助避免SQL注入 攻击;

如果希望通过类型开关来控制入参可以使用如下方式：
func sqlQuote(x interface{}) string { 
switch x := x.(type) {
case nil:
  return "NULL" 
case int, uint:
  return fmt.Sprintf("%d", x) // x has type interface{} here. case bool:
  if x {
  return "TRUE"
  }
  return "FALSE" 
case string:
  return sqlQuoteString(x) // (not shown) default:
panic(fmt.Sprintf("unexpected type %T: %v", x, x)) }
}

在 *_test.go 文件中，有三种类型的函数:测试函数、基准测试(benchmark)函数、示例函数。
一 个测试函数是以Test为函数名前缀的函数，用于测试程序的一些逻辑行为是否正确;
go test命令会 调用这些测试函数并报告测试结果是PASS或FAIL。
基准测试函数是以Benchmark为函数名前缀的 函数，它们用于衡量一些函数的性能;
go test命令会多次运行基准函数以计算一个平均的执行时 间。
示例函数是以Example为函数名前缀的函数，提供一个由编译器保证正确性的示例文档。

go test命令会遍历所有的*_test.go文件中符合上述命名规则的函数，生成一个临时的main包用于 
调用相应的测试函数，接着构建并运行、报告测试结果，最后清理测试中生成的临时文件。

func TestName(t *testing.T) { // ...
}
测试函数的名字必须以Test开头，可选的后缀名必须以大写字母开头:
func TestLog(t *testing.T) { /* ... */ }
其中t参数用于报告测试失败和附加的日志信息。
比如如下例子：
// Package word provides utilities for word games.
package word
// IsPalindrome reports whether s reads the same forward and backward. // (Our first attempt.)
func IsPalindrome(s string) bool {
for i := range s {
if s[i] != s[len(s)‐1‐i] {
return false }
}
return true }

在相同的目录下，创建word_test.go测试文件
package word
import "testing"
func TestPalindrome(t *testing.T) { 
if !IsPalindrome("detartrated") {
t.Error(`IsPalindrome("detartrated") = false`) }
if !IsPalindrome("kayak") { 
t.Error(`IsPalindrome("kayak") = false`)
} }
func TestNonPalindrome(t *testing.T) { 
if IsPalindrome("palindrome") {
t.Error(`IsPalindrome("palindrome") = true`) }
}
参数 ‐v 可用于打印每个测试函数的名字和运行时间:
go test ‐v
=== RUN TestPalindrome
‐‐‐ PASS: TestPalindrome (0.00s)
=== RUN TestNonPalindrome
‐‐‐ PASS: TestNonPalindrome (0.00s) === RUN TestFrenchPalindrome
‐‐‐ FAIL: TestFrenchPalindrome (0.00s)
word_test.go:28: IsPalindrome("été") = false === RUN TestCanalPalindrome
‐‐‐ FAIL: TestCanalPalindrome (0.00s)
word_test.go:35: IsPalindrome("A man, a plan, a canal: Panama") = false FAIL
exit status 1
FAIL gopl.io/ch11/word1 0.017s

参数‐run对应一个正则表达式，只有测试函数名被它正确匹配的测试函数才会被go test测试命令 运行:
 go test ‐v ‐run="French|Canal"
=== RUN TestFrenchPalindrome
‐‐‐ FAIL: TestFrenchPalindrome (0.00s)
word_test.go:28: IsPalindrome("été") = false === RUN TestCanalPalindrome
‐‐‐ FAIL: TestCanalPalindrome (0.00s)
word_test.go:35: IsPalindrome("A man, a plan, a canal: Panama") = false FAIL
exit status 1
FAIL gopl.io/ch11/word1 0.014s

$ go tool cover
Usage of 'go tool cover':
Given a coverage profile produced by 'go test':
go test ‐coverprofile=c.out
Open a web browser displaying annotated source code: go tool cover ‐html=c.out
...

基准测试是测量一个程序在固定工作负载下的性能。在Go语言中，基准测试函数和普通测试函数 写法类似，
但是以Benchmark为前缀名，并且带有一个 *testing.B 类型的参数; 
*testing.B 参数除 了提供和 *testing.T 类似的方法，还有额外一些和性能测量相关的方法。
它还提供了一个整数N， 用于指定操作执行的循环次数。
下面是IsPalindrome函数的基准测试，其中循环将执行N次。

import "testing"
func BenchmarkIsPalindrome(b *testing.B) { 
for i := 0; i < b.N; i++ {
IsPalindrome("A man, a plan, a canal: Panama") }
}
$ go test ‐cpuprofile=cpu.out
$ go test ‐blockprofile=block.out 
$ go test ‐memprofile=mem.out


go test ‐run=NONE ‐bench=ClientServerParallelTLS64 \ ‐cpuprofile=cpu.log net/http
PASS
BenchmarkClientServerParallelTLS64‐8 1000
3141325 ns/op 143010 B/op 1747 allocs/op ok net/http 3.395s
$ go tool pprof ‐text ‐nodecount=10 ./http.test cpu.log 2570ms of 3590ms total (71.59%)
Dropped 129 nodes (cum <= 17.95ms)
Showing top 10 nodes out of 166 (cum >= 60ms)

第三种被go test特别对待的函数是示例函数，以Example为函数名开头。示例函数没有函数参数
和返回值。
func ExampleIsPalindrome() {
fmt.Println(IsPalindrome("A man, a plan, a canal: Panama")) fmt.Println(IsPalindrome("palindrome"))
// Output:
// true
// false
}
示例函数有三个用处。
最主要的一个是作为文档:
一个包的例子可以更简洁直观的方式来演示函数 的用法，比文字描述更直接易懂，特别是作为一个提醒或快速参考时。
一个示例函数也可以方便展 示属于同一个接口的几种类型或函数之间的关系，所有的文档都必须关联到一个地方，就像一个类 
型或函数声明都统一到包一样。同时，示例函数和注释并不一样，示例函数是真实的Go代码，需 要接受编译器的编译时检查，
这样可以保证源代码更新时，示例代码不会脱节。
示例文档的第二个用处是，在 执行测试的时候也会运行示例函数测试。如果示例函数内含 有类似上面例子中的 格式的注释，
那么测试工具会执行这个示例函数，然后检查示例函 数的标准输出与注释是否匹配。
示例函数的第三个目的提供一个真实的演练场。 http://golang.org 就是由godoc提供的文档服务