golang常用标准库

输入与输出-fmt包
时间与日期-time包
命令行参数解析-flag包
日志-log包
IO操作-os包
IO操作-bufio包与ioutil包
strconv包
模板-template包
http包
context
json/xml
reflect反射
官方标准库

输入与输出-fmt包

输入与输出

常用输出函数

Print、Printf、Println：直接输出内容

Sprint、Sprintf、Sprintln：生成内容并返回字符串

Fprint：将内容输出到一个io.Writer接口类型的变量，经常用于写入文件

Errorf：根据format参数生成格式化字符串并返回一个包含该字符串的错误

```go
fmt.Println("打开文件出错，err:", err)//输出带换行
s2 := fmt.Sprintf("name:%s,age:%d", name, age)//带格式生成并返回
fmt.Fprintf(fileObj, "往文件中写如信息：%s", name)//带格式写入文件
err := fmt.Errorf("这是一个错误")
```

常用占位符

占位符	说明
%v	值的默认格式表示
%+v	类似%v，但输出结构体时会添加字段名
%#v	值的golang语法表示
%T	打印值的类型
%%	百分号
%d	表示10进制数
%b	表示2进制数
%f	浮点数，有小数
%9.2f	宽度9，精度2
%e	科学计数法
%s	直接输出字符串或[]byte
%q	该值对应的双引号括起来的go语法字符串字面值，必要时会采用安全的转义表示
%p	指针，表示未16进制，并加上前缀0x

常用输入函数

Scan、Scanf、Scanln：可以在程序运行过程中从标准输入获取用户的输入。

Scanln比较常用：在终端扫描标准输入，以空格分隔，直到换行结束扫描

```go
fmt.Scanln(&name, &age, &married)
fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)
```

bufio.NewReader：获取完整输入内容

FScan、Fscanf、Fscanln：从文件中获取输入

Sscan、Sscanf、Sscanln：从字符串获取输入

时间与日期-time包

时间与日期转换

func timeDemo() {
    now := time.Now() //获取当前时间
    fmt.Printf("current time:%v\n", now)

    year := now.Year()     //年
    month := now.Month()   //月
    day := now.Day()       //日
    hour := now.Hour()     //小时
    minute := now.Minute() //分钟
    second := now.Second() //秒
    fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)

    timestamp1 := now.Unix()     //时间戳
    timestamp2 := now.UnixNano() //纳秒时间戳
    fmt.Printf("current timestamp1:%v\n", timestamp1)
    fmt.Printf("current timestamp2:%v\n", timestamp2)   
    
    timeObj := time.Unix(timestamp1, 0)//时间戳转换成时间对象，再通过类似以上当前时间转换成时间格式

}

时间间隔(单位)

time包中时间间隔的定义：

const (
    Nanosecond  Duration = 1
    Microsecond          = 1000 * Nanosecond
    Millisecond          = 1000 * Microsecond
    Second               = 1000 * Millisecond
    Minute               = 60 * Second
    Hour                 = 60 * Minute
)

var _time = 10 * time.Second //10秒

例如：time.Duration表示1纳秒，time.Second表示1秒。

时间格式化

golang的常用时间格式化模板并不是常见的：Y-m-d H:i:s，而是2006-01-02 15:04 ，这是24小时制，2006-01-02 03:04 PM，则是12小时制
```
fmt.Println(now.Format("2006-01-02 15:04:05.000 Mon Jan"))
// 12小时制
fmt.Println(now.Format("2006-01-02 03:04:05.000 PM Mon Jan"))
fmt.Println(now.Format("2006/01/02 15:04"))
fmt.Println(now.Format("15:04 2006/01/02"))
fmt.Println(now.Format("2006/01/02"))
```
golang大佬，何必呢，增加跨语言语法记忆难度，虽然只是一点点，但如果其他地方也这样有'意思'，累计下难度就不小了。

时间操作

golang中的时间，并不是简单的数字加减，time包提供了实践操作的方法：
- Add：时刻+时间段
```
func main() {
    now := time.Now()
    later := now.Add(time.Hour) // 当前时间加1小时后的时间
    beforer := now.Add(-time.Hour) // 当前时间减1小时后的时间
    fmt.Println(later)
}
```
- Sub：时刻1 - 时刻2，求两个时间的差值，注意这里并不是（时刻-时间段）的实现，（时刻-时间段）仍然可以用Add(-时间段)来实现
- Equal：判断时间是否相等，会考虑时区
- Before：判断是否在某个时刻之前
- After：判断是否在某个时刻之后

定时器

定时器，本质上是一个channel，golang中使用time.Ticker(duration)来设置定时器

一次性定时器（延时）

package main

import (
    "fmt"
    "time"
)

func main() {
    /*
        用sleep实现定时器
    */
    fmt.Println(time.Now())
    time.Sleep(time.Second)
    fmt.Println(time.Now())
    /*
        用timer实现定时器
    */
    timer := time.NewTimer(time.Second)
    fmt.Println(<-timer.C)
    /*
        用after实现定时器
    */
    fmt.Println(<-time.After(time.Second))

}

周期性定时器

func tickDemo() {
    ticker := time.Tick(time.Second) //定义一个1秒间隔的定时器
    //ticker := time.NewTicker(time.Second)
    for i := range ticker {
        fmt.Println(i)//每秒都会执行的任务
    }
}

命令行参数解析-flag包

flag包是的golang开发命令行工具更为简单。

看一个完整示例，我们就更清楚flag的用途了：

执行命令时要求输入4个参数，并指定了参数的类型与默认值

func main() {
    //定义命令行参数方式1
    var name string
    var age int
    var married bool
    var delay time.Duration
    flag.StringVar(&name, "name", "张三", "姓名")
    flag.IntVar(&age, "age", 18, "年龄")
    flag.BoolVar(&married, "married", false, "婚否")
    flag.DurationVar(&delay, "d", 0, "延迟的时间间隔")

    //解析命令行参数
    flag.Parse()
    fmt.Println(name, age, married, delay)
    //返回命令行参数后的其他参数
    fmt.Println(flag.Args())
    //返回命令行参数后的其他参数个数
    fmt.Println(flag.NArg())
    //返回使用的命令行参数个数
    fmt.Println(flag.NFlag())
}

首先flag提供了命令行help功能，执行命令行会给出相应提示：

    $ ./flag_demo -help
    Usage of ./flag_demo:
      -age int
            年龄 (default 18)
      -d duration
            时间间隔
      -married
            婚否
      -name string
            姓名 (default "张三")

其次flag提供命令行参数parse解析能力：

注意：Args()\NArg()\NFlag()的含义

$ ./flag_demo -name pprof --age 28 -married=false -d=1h30m
pprof 28 false 1h30m0s
[]
0
4

当然如果我们仅仅只是需要简单命令行输入的参数，我们也可以简单的考虑os.Args来获取命令行参数。

os.Args是一个存储命令行参数的字符串切片，它的第一个元素是执行文件的名称，这和大部分语言命令行模式是类似的（python、php等）

日志-log包

官方标准简单log包，功能有限，更多可以实现流水账的日志记录，如果我们需要更多比如不同级别的日志记录，可以选择第三方日志库：logrus、zap等

//使用标准日志log，设置日志输出到xx.log文件，设置flags支持文件名、行号、日志前缀、时间格式
func main() {
    logFile, err := os.OpenFile("./xx.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
    if err != nil {
        fmt.Println("open log file failed, err:", err)
        return
    }
    log.SetOutput(logFile)
    log.SetFlags(log.Llongfile | log.Lmicroseconds | log.Ldate)    
    log.SetPrefix("[JM]")
    log.Println("这里记录一条日志。")
}

[JM]2020/01/14 15:32:45.431506 .../log_demo/main.go:13: 这里记录一条日志。

IO操作-os包

os包提供了Create、NewFile、Open、OpenFile、Remove方法

返回的文件对象，提供了读写方法，比如Write、WriteAt、WriteString、Read、ReadAt方法

文件打开与关闭
```
package main

import (
    "fmt"
    "os"
)

func main() {
    // 只读方式打开当前目录下的main.go文件
    file, err := os.Open("./main.go")
    if err != nil {
        fmt.Println("open file failed!, err:", err)
        return
    }
    // 关闭文件
    file.Close()
}
```
golang可以考虑再简化下文件的打开及异常的处理和关闭，python的with open简化了try异常和close的处理，让代码更简洁，编写者不用去关心异常处理和文件关闭处理代码，这本不属于业务逻辑代码，趋势应该是让语言或机器自动实现了

写文件

```go
file.WriteString("ab\n")
file.Write([]byte("cd\n"))
```

我们会更新一篇关于byte与string区别的文章

读文件

golang文件读取可以用file.Read()和file.ReadAt()，读到文件末尾会返回io.EOF的错误，EOF这是大部分语言读取结尾的标识符了

golang的os包的读写还需要偏上层封装，不要让开发者去了解这么多读写的原理，比如读取一行、整个文件，这些是开发者更乐意用到的，不用关心读写的原理，至于性能开发者会认为是语言要解决的问题，当然当我们有足够经验以后，就可以使用更底层些的方法来实现，提高性能。如果硬件的发展更快，我们更希望大家都可以不关心底层实现的去使用更上层的方法
```
package main

import (
    "fmt"
    "io"
    "os"
)

func main() {
    // 打开文件
    file, err := os.Open("./xxx.txt")
    if err != nil {
        fmt.Println("open file err :", err)
        return
    }
    defer file.Close()
    // 定义接收文件读取的字节数组
    var buf [128]byte
    var content []byte
    for {
        n, err := file.Read(buf[:])
        if err == io.EOF {
            // 读取结束
            break
        }
        if err != nil {
            fmt.Println("read file err ", err)
            return
        }
        content = append(content, buf[:n]...)
    }
    fmt.Println(string(content))
}
```

IO操作-bufio包与ioutil包

bufio包实现了带缓冲区的读写，是对文件读写的封装

前面说到开发者更喜欢使用更上层的读写方法，golang的bufio包除了实现带缓冲区的读写提高效率和稳定性外，还提供按行读方法，ioutil包提供了读取整个文件、写文件方法

bufio、ioutil包更多文件、目录读写详见官方标准库

strconv包

Atoi

string类型转换成int类型
Itoa

int转换成string

ParaseType系列

将string转换成指定Type类型

b, err := strconv.ParseBool("true")
f, err := strconv.ParseFloat("3.1415", 64)
i, err := strconv.ParseInt("-2", 10, 64)
u, err := strconv.ParseUint("2", 10, 64)

FormatType系列

将给定类型数据格式化为string类型数据的功能

s1 := strconv.FormatBool(true)
s2 := strconv.FormatFloat(3.1415, 'E', -1, 64)
s3 := strconv.FormatInt(-2, 16)
s4 := strconv.FormatUint(2, 16)

strconv包中还有Append系列、Quote系列等函数。详细见官方标准库

模板-template包

html/template包实现了数据驱动的模板，用于生成可对抗代码注入的安全HTML输出。

模板语法

{{.}}

模板语法都包含在{{和}}中间，其中{{.}}中的点表示当前对象。

当我们传入一个结构体对象时，我们可以根据.来访问结构体的对应字段。例如：

type UserInfo struct {
Name   string
Gender string
Age    int
}

func sayHello(w http.ResponseWriter, r *http.Request) {
    // 解析指定文件生成模板对象
    tmpl, err := template.ParseFiles("./hello.html")
    if err != nil {
        fmt.Println("create template failed, err:", err)
        return
    }
    user := UserInfo{
        Name:   "枯藤",
        Gender: "男",
        Age:    18,
    }
    // 利用给定数据渲染模板，并将结果写入w
    tmpl.Execute(w, user)
}

.表示当前对象/结构体user（w只是服务端的一个变量，也保存了user这个结构体而已）


Hello {{.Name}}
性别：{{.Gender}}
年龄：{{.Name}}

模板注释

{{/* a comment */}}
注释，执行时会忽略。可以多行。注释不能嵌套，并且必须紧贴分界符始止。

管道pipeline

Go的模板语法中支持使用管道符号|链接多个命令，用法和unix下的管道类似：|前面的命令会将运算结果(或返回值)传递给后一个命令的最后一个位置。

Actions

以下这些动作基本包含golang模板中常用的动作与含义说明

{{/* a comment */}}
注释，执行时会忽略。可以多行。注释不能嵌套，并且必须紧贴分界符始止，就像这里表示的一样。
{{pipeline}}
    pipeline的值的默认文本表示会被拷贝到输出里。
{{if pipeline}} T1 {{end}}
    如果pipeline的值为empty，不产生输出，否则输出T1执行结果。不改变dot的值。
    Empty值包括false、0、任意nil指针或者nil接口，任意长度为0的数组、切片、字典。
{{if pipeline}} T1 {{else}} T0 {{end}}
    如果pipeline的值为empty，输出T0执行结果，否则输出T1执行结果。不改变dot的值。
{{if pipeline}} T1 {{else if pipeline}} T0 {{end}}
    用于简化if-else链条，else action可以直接包含另一个if；等价于：
        {{if pipeline}} T1 {{else}}{{if pipeline}} T0 {{end}}{{end}}
{{range pipeline}} T1 {{end}}
    pipeline的值必须是数组、切片、字典或者通道。
    如果pipeline的值其长度为0，不会有任何输出；
    否则dot依次设为数组、切片、字典或者通道的每一个成员元素并执行T1；
    如果pipeline的值为字典，且键可排序的基本类型，元素也会按键的顺序排序。
{{range pipeline}} T1 {{else}} T0 {{end}}
    pipeline的值必须是数组、切片、字典或者通道。
    如果pipeline的值其长度为0，不改变dot的值并执行T0；否则会修改dot并执行T1。
{{template "name"}}
    执行名为name的模板，提供给模板的参数为nil，如模板不存在输出为""
{{template "name" pipeline}}
    执行名为name的模板，提供给模板的参数为pipeline的值。
{{with pipeline}} T1 {{end}}
    如果pipeline为empty不产生输出，否则将dot设为pipeline的值并执行T1。不修改外面的dot。
{{with pipeline}} T1 {{else}} T0 {{end}}
    如果pipeline为empty，不改变dot并执行T0，否则dot设为pipeline的值并执行T1。

比较

eq      如果arg1 == arg2则返回真
ne      如果arg1 != arg2则返回真
lt      如果arg1 < arg2则返回真
le      如果arg1 <= arg2则返回真
gt      如果arg1 > arg2则返回真
ge      如果arg1 >= arg2则返回真

 {{eq arg1 arg2 arg3}}

嵌套模板




    
    
    
    tmpl test



    测试嵌套template语法
    
    {{template "ul.html"}}
    
    {{template "ol.html"}}



{{ define "ol.html"}}
这是ol.html

    AA
    BB
    CC

{{end}}

ul.html模板不在当前html文档内，需要通过服务端template.ParseFiles指定加载的模板页，才能使用（有点耦合，要是都由前端模板文件去include包含模板可能会更自然些）

func tmplDemo(w http.ResponseWriter, r *http.Request) {
tmpl, err := template.ParseFiles("./t.html", "./ul.html")
if err != nil {
    fmt.Println("create template failed, err:", err)
    return
}
user := UserInfo{
    Name:   "枯藤",
    Gender: "男",
    Age:    18,
}
tmpl.Execute(w, user)

}
```

http包

Go语言内置的net/http包十分的优秀，提供了HTTP客户端和服务端的实现

客户端

resp, err := http.Get("http://www.baidu.com/")

resp, err := http.Post("http://www.9ong.com/post", "image/jpeg", &buf)

resp, err := http.PostForm("http://www.9ong.com/form",
    url.Values{"key": {"Value"}, "id": {"123"}})

if err != nil {
    // handle error
}
//使用完response后必须关闭回复的主体
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)

使用完response后必须关闭回复的主体，总是会有不完美的地方存在哈，还需要自己关闭Body，从编码的角度看。

带参数的请求

带参数get请求

apiUrl := "http://127.0.0.1:9090/get"
// URL param
data := url.Values{}
data.Set("name", "枯藤")
data.Set("age", "18")
u, err := url.ParseRequestURI(apiUrl)
if err != nil {
    fmt.Printf("parse url requestUrl failed,err:%v\n", err)
}
u.RawQuery = data.Encode() // URL encode
fmt.Println(u.String())
resp, err := http.Get(u.String())
if err != nil {
    fmt.Println("post failed, err:%v\n", err)
    return
}

带参数post请求

// 表单数据
//contentType := "application/x-www-form-urlencoded"
//data := "name=jm&age=20"
// json
contentType := "application/json"
data := `{"name":"jm","age":20}`
resp, err := http.Post(url, contentType, strings.NewReader(data))

看完以下的编写方式，我们觉得应该有更舒适第三方http库，只需要：

http.Get(url,json对象参数|结构体参数)
http.Post(url,options,data) //options负责设置http头等信息，data是参数json对象或结构体

服务端

```go
// http server

func sayHello(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Hello world")
}

func main() {
    http.HandleFunc("/", sayHello)
    err := http.ListenAndServe(":9527", nil)
    if err != nil {
        fmt.Printf("http server failed, err:%v\n", err)
        return
    }
}
```

自定义server

```go
s := &http.Server{
    Addr:           ":9527",
    Handler:        myHandler,
    ReadTimeout:    10 * time.Second,
    WriteTimeout:   10 * time.Second,
    MaxHeaderBytes: 1 << 20,
}
log.Fatal(s.ListenAndServe())
```

context

在 Go http包的Server中，每一个请求在都有一个对应的 goroutine 去处理。请求处理函数通常会启动额外的 goroutine 用来访问后端服务，比如数据库和RPC服务。用来处理一个请求的 goroutine 通常需要访问一些与请求特定的数据，比如终端用户的身份认证信息、验证相关的token、请求的截止时间。当一个请求被取消或超时时，所有用来处理该请求的 goroutine 都应该迅速退出，然后系统才能释放这些 goroutine 占用的资源。

介绍goroutine时，我们看到范例并没有在main函数里使用context，goroutine也会自动退出。原因是只有一种情况正在运行的goroutine会因为其他goroutine的结束被终止，就是main函数的退出或程序停止执行.

sync.WaitGroup解决了协程协同同步完成问题，context主要为了解决协程协同取消问题

Context接口

context.Context是一个接口，该接口定义了四个需要实现的方法

type Context interface {
    Deadline() (deadline time.Time, ok bool) //返回当前Context被取消的时间，也就是完成工作的截止时间
    Done() <-chan struct{} //返回一个Channel，这个Channel会在当前工作完成或者上下文被取消之后关闭，多次调用Done方法会返回同一个Channel
    Err() error //返回当前Context结束的原因
    Value(key interface{}) interface{} //从Context中返回键对应的值，对于同一个上下文来说，多次调用Value 并传入相同的Key会返回相同的结果，该方法仅用于传递跨API和进程间跟请求域的数据
}

注意：以下介绍的都是函数，并不是创建后context上下问对像的方法，而是context包的函数

context.Background函数
context.TODO函数

Go内置两个函数：Background()和TODO()，这两个函数分别返回一个实现了Context接口的background和todo。我们代码中最开始都是以这两个内置的上下文对象作为最顶层的partent context，衍生出更多的子上下文对象。

Background()主要用于main函数、初始化以及测试代码中，作为Context这个树结构的最顶层的Context，也就是根Context。

TODO()，它目前还不知道具体的使用场景，如果我们不知道该使用什么Context的时候，可以使用这个。

background和todo本质上都是emptyCtx结构体类型，是一个不可取消，没有设置截止时间，没有携带任何值的Context。

context.withCancel函数

WithCancel返回带有新Done通道的父节点的副本。当调用返回的cancel函数或当关闭父上下文的Done通道时，将关闭返回上下文的Done通道，无论先发生什么情况。

func gen(ctx context.Context) <-chan int {
    dst := make(chan int)
    n := 1
    go func() {
        for {
            select {
            case <-ctx.Done():
                return // return结束该goroutine，防止泄露
            case dst <- n:
                n++
            }
        }
    }()
    return dst
}
func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel() // 当我们取完需要的整数后调用cancel

    for n := range gen(ctx) {
        fmt.Println(n)
        if n == 5 {
            break
        }
    }
}

context.withDeadline函数

返回父上下文的副本，并将deadline调整为不迟于d。如果父上下文的deadline已经早于d，则WithDeadline(parent, d)在语义上等同于父上下文。当截止日过期时，当调用返回的cancel函数时，或者当父上下文的Done通道关闭时，返回上下文的Done通道将被关闭，以最先发生的情况为准。

func main() {
    d := time.Now().Add(50 * time.Millisecond)
    ctx, cancel := context.WithDeadline(context.Background(), d)

    // 尽管ctx会过期，但在任何情况下调用它的cancel函数都是很好的实践。
    // 如果不这样做，可能会使上下文及其父类存活的时间超过必要的时间。
    defer cancel()

    select {
    case <-time.After(1 * time.Second):
        fmt.Println("overslept")
    case <-ctx.Done():
        fmt.Println(ctx.Err())
    }
}

context.WithTimeout函数

func main() {
    // 设置一个50毫秒的超时
    ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*50)
    wg.Add(1)
    go worker(ctx)
    time.Sleep(time.Second * 5)
    cancel() // 通知子goroutine结束
    wg.Wait()
    fmt.Println("over")
}

context.WithValue函数

WithValue返回父节点的副本，其中与key关联的值为val。

仅对API和进程间传递请求域的数据使用上下文值，而不是使用它来传递可选参数给函数。

type TraceCode string

func worker(){
    ...
    key := TraceCode("TRACE_CODE")
    traceCode, ok := ctx.Value(key).(string) // 在子goroutine中获取trace code        
    ...
}
func main(){
    ...
    // 在系统的入口中设置trace code传递给后续启动的goroutine实现日志数据聚合
    ctx = context.WithValue(ctx, TraceCode("TRACE_CODE"), "2009")
    wg.Add(1)
    go worker(ctx)
    ...
}

关于cancel()函数

以上范例中的cancel函数，是通过context.With*系列函数返回得到的第二个值，用于通知同一个context下的所有goroutine结束/取消。

golang的context设计，让我们明白一个道理，能简单处理好一个问题，就是好的解决方案，没有高贵之分。

json/xml

json

json可以和map、struct、interface相互转换

// 将struct、map转换成json 字符串
json.Marshal(struct|map)

//将json字符串转换成Person结构体
type Person struct{
    ...
}
jsonStr := []byte(`{"age":"18","name":"5lmh.com","marry":false}`)
var p Person
json.Unmarshal(jsonStr,&p)

弱类型的js、php可以随时动态自由的转换json字符串，这个确实舒服太多，怪不得php开发者总说数组强大。

xml

与json包的方法是一样，只是数据源不一样
```
xml.Marshal(struct|map)
xml.Unmarshal(xmlStr,&p)
```
msgpack

MSGPack是二进制的json，性能更快，更省空间

需要安装第三方包：go get -u github.com/vmihailenco/msgpack

```go
msgpack.Marshal(struct|map)
msgpack.Unmarshal(msgpackbinary,&p)
```

reflect反射

反射是指在程序运行期对程序本身进行访问和修改的能力

reflect包封装了反射相关的方法：

获取类型信息：reflect.TypeOf，是静态的

获取值信息：reflect.ValueOf，是动态的

反射可以获取interface类型信息、获取值信息、修改值信息

反射可以查看结构体字段、类型、方法，修改结构体的值，调用方法

空接口结合反射

可以通过空接口可以表示任何参数，利用反射判断参数类型

官方标准库

转载请标注来源：golang常用标准库.html - 9ong.com