美文网首页
12.包

12.包

作者: 雪上霜 | 来源:发表于2020-04-17 15:55 被阅读0次

    在工程化的Go语言开发项目中，Go语言的源码复用是建立在包（package）基础之上的。本文介绍了Go语言中如何定义包、如何导出包的内容及如何导入其他包。

    Go语言的包（package）

    包介绍

    包（package）是多个Go源码的集合，是一种高级的代码复用方案，Go语言为我们提供了很多内置包，如fmt、os、io等。

    定义包

    我们还可以根据自己的需要创建自己的包。一个包可以简单理解为一个存放.go文件的文件夹。 该文件夹下面的所有go文件都要在代码的第一行添加如下代码，声明该文件归属的包。

    package 包名

    注意事项：

    • 一个文件夹下面直接包含的文件只能归属一个package，同样一个package的文件不能在多个文件夹下。
    • 包名可以不和文件夹的名字一样，包名不能包含 - 符号。
    • 包名为main的包为应用程序的入口包，这种包编译后会得到一个可执行文件，而编译不包含main包的源代码则不会得到可执行文件。

    可见性

    如果想在一个包中引用另外一个包里的标识符（如变量、常量、类型、函数等）时，该标识符必须是对外可见的（public）。在Go语言中只需要将标识符的首字母大写就可以让标识符对外可见了。

    举个例子， 我们定义一个包名为pkg2的包，代码如下：

    package pkg2

import "fmt"

// 包变量可见性

var a = 100 // 首字母小写，外部包不可见，只能在当前包内使用

// 首字母大写外部包可见，可在其他包中使用
const Mode = 1

type person struct { // 首字母小写，外部包不可见，只能在当前包内使用
    name string
}

// 首字母大写，外部包可见，可在其他包中使用
func Add(x, y int) int {
    return x + y
}

func age() { // 首字母小写，外部包不可见，只能在当前包内使用
    var Age = 18 // 函数局部变量，外部包不可见，只能在当前函数内使用
    fmt.Println(Age)
}

    结构体中的字段名和接口中的方法名如果首字母都是大写，外部包可以访问这些字段和方法。例如：

    type Student struct {
    Name  string //可在包外访问的方法
    class string //仅限包内访问的字段
}

type Payer interface {
    init() //仅限包内访问的方法
    Pay()  //可在包外访问的方法
}

    包的导入

    要在代码中引用其他包的内容，需要使用import关键字导入使用的包。具体语法如下:

    import "包的路径"

    注意事项：

    • import导入语句通常放在文件开头包声明语句的下面。
    • 导入的包名需要使用双引号包裹起来。
    • 包名是从$GOPATH/src/后开始计算的，使用/进行路径分隔。
    • Go语言中禁止循环导入包。

    单行导入

    单行导入的格式如下：

    import "包1"
import "包2"

    多行导入

    多行导入的格式如下：

    import (
    "包1"
    "包2"
)

    自定义包名

    在导入包名的时候，我们还可以为导入的包设置别名。通常用于导入的包名太长或者导入的包名冲突的情况。具体语法格式如下：

    import 别名 "包的路径"

    单行导入方式定义别名：

    import "fmt"
import m "github.com/Q1mi/studygo/pkg_test"

func main() {
    fmt.Println(m.Add(100, 200))
    fmt.Println(m.Mode)
}

    多行导入方式定义别名：

    import (
    "fmt"
    m "github.com/Q1mi/studygo/pkg_test"
 )

func main() {
    fmt.Println(m.Add(100, 200))
    fmt.Println(m.Mode)
}

    匿名导入包

    如果只希望导入包，而不使用包内部的数据时，可以使用匿名导入包。具体的格式如下：

    import _ "包的路径"

    匿名导入的包与其他方式导入的包一样都会被编译到可执行文件中。

    init()初始化函数

    init()函数介绍

    在Go语言程序执行时导入包语句会自动触发包内部init()函数的调用。需要注意的是： init()函数没有参数也没有返回值。 init()函数在程序运行时自动被调用执行，不能在代码中主动调用它。

    包初始化执行的顺序如下图所示： 包中的init()执行时机

    init()函数执行顺序

    Go语言包会从main包开始检查其导入的所有包，每个包中又可能导入了其他的包。Go编译器由此构建出一个树状的包引用关系，再根据引用顺序决定编译顺序，依次编译这些包的代码。

    在运行时，被最后导入的包会最先初始化并调用其init()函数， 如下图示：

    包之间的init()执行顺序

    练习题

    1. 编写一个calc包实现加减乘除四个功能函数，在snow这个包中导入并使用加减乘除四个函数实现数学运算。

    time包

    时间和日期是我们编程中经常会用到的，本文主要介绍了Go语言内置的time包的基本用法。

    time包
    time包提供了时间的显示和测量用的函数。日历的计算采用的是公历。

    时间类型
    time.Time类型表示时间。我们可以通过time.Now()函数获取当前的时间对象，然后获取时间对象的年月日时分秒等信息。示例代码如下：

    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)
}

    时间戳
    时间戳是自1970年1月1日（08:00:00GMT）至当前时间的总毫秒数。它也被称为Unix时间戳（UnixTimestamp）。

    基于时间对象获取时间戳的示例代码如下：

    func timestampDemo() {
    now := time.Now()            //获取当前时间
    timestamp1 := now.Unix()     //时间戳
    timestamp2 := now.UnixNano() //纳秒时间戳
    fmt.Printf("current timestamp1:%v\n", timestamp1)
    fmt.Printf("current timestamp2:%v\n", timestamp2)
}

    使用time.Unix()函数可以将时间戳转为时间格式。

    func timestampDemo2(timestamp int64) {
    timeObj := time.Unix(timestamp, 0) //将时间戳转为时间格式
    fmt.Println(timeObj)
    year := timeObj.Year()     //年
    month := timeObj.Month()   //月
    day := timeObj.Day()       //日
    hour := timeObj.Hour()     //小时
    minute := timeObj.Minute() //分钟
    second := timeObj.Second() //秒
    fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)
}

    时间间隔
    time.Duration是time包定义的一个类型，它代表两个时间点之间经过的时间，以纳秒为单位。time.Duration表示一段时间间隔，可表示的最长时间段大约290年。

    time包中定义的时间间隔类型的常量如下：

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

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

    时间操作
    Add
    我们在日常的编码过程中可能会遇到要求时间+时间间隔的需求，Go语言的时间对象有提供Add方法如下：

    func (t Time) Add(d Duration) Time
    举个例子，求一个小时之后的时间：

    func main() {
    now := time.Now()
    later := now.Add(time.Hour) // 当前时间加1小时后的时间
    fmt.Println(later)
}

    Sub
求两个时间之间的差值：

func (t Time) Sub(u Time) Duration
返回一个时间段t-u。如果结果超出了Duration可以表示的最大值/最小值，将返回最大值/最小值。要获取时间点t-d（d为Duration），可以使用t.Add(-d)。

Equal
func (t Time) Equal(u Time) bool
判断两个时间是否相同，会考虑时区的影响，因此不同时区标准的时间也可以正确比较。本方法和用t==u不同，这种方法还会比较地点和时区信息。

Before
func (t Time) Before(u Time) bool
如果t代表的时间点在u之前，返回真；否则返回假。

After
func (t Time) After(u Time) bool
如果t代表的时间点在u之后，返回真；否则返回假。

定时器
使用time.Tick(时间间隔)来设置定时器，定时器的本质上是一个通道（channel）。

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

    时间格式化
    时间类型有一个自带的方法Format进行格式化，需要注意的是Go语言中格式化时间模板不是常见的Y-m-d H:M:S而是使用Go的诞生时间2006年1月2号15点04分（记忆口诀为2006 1 2 3 4）。也许这就是技术人员的浪漫吧。

    补充：如果想格式化为12小时方式，需指定PM。

    func formatDemo() {
    now := time.Now()
    // 格式化的模板为Go的出生时间2006年1月2号15点04分 Mon Jan
    // 24小时制
    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"))
}
解析字符串格式的时间
now := time.Now()
fmt.Println(now)
// 加载时区
loc, err := time.LoadLocation("Asia/Shanghai")
if err != nil {
    fmt.Println(err)
    return
}
// 按照指定时区和指定格式解析字符串时间
timeObj, err := time.ParseInLocation("2006/01/02 15:04:05", "2019/08/04 14:15:20", loc)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Println(timeObj)
fmt.Println(timeObj.Sub(now))
    image.png

    练习题：

    获取当前时间，格式化输出为2017/06/19 20:30:05`格式。
    编写程序统计一段代码的执行耗时时间，单位精确到微秒。

    flag

    Go语言标准库flag基本使用

    Go语言内置的flag包实现了命令行参数的解析，flag包使得开发命令行工具更为简单。

    os.Args

    如果你只是简单的想要获取命令行参数，可以像下面的代码示例一样使用os.Args来获取命令行参数。

    package main

import (
    "fmt"
    "os"
)

//os.Args demo
func main() {
    //os.Args是一个[]string
    if len(os.Args) > 0 {
        for index, arg := range os.Args {
            fmt.Printf("args[%d]=%v\n", index, arg)
        }
    }
}

    将上面的代码执行go build -o "args_demo"编译之后，执行：

    $ ./args_demo a b c d
args[0]=./args_demo
args[1]=a
args[2]=b
args[3]=c
args[4]=d

    os.Args是一个存储命令行参数的字符串切片，它的第一个元素是执行文件的名称。

    flag包基本使用

    本文介绍了flag包的常用函数和基本用法，更详细的内容请查看官方文档。

    导入flag包

    import flag

    flag参数类型

    flag包支持的命令行参数类型有bool、int、int64、uint、uint64、float float64、string、duration。

    flag参数 有效值
    字符串flag 合法字符串
    整数flag 1234、0664、0x1234等类型，也可以是负数。
    浮点数flag 合法浮点数
    bool类型flag 1, 0, t, f, T, F, true, false, TRUE, FALSE, True, False。
    时间段flag 任何合法的时间段字符串。如”300ms”、”-1.5h”、”2h45m”。合法的单位有”ns”、”us” /“µs”、”ms”、”s”、”m”、”h”。

    定义命令行flag参数

    有以下两种常用的定义命令行flag参数的方法。

    flag.Type()

    基本格式如下：

    flag.Type(flag名, 默认值, 帮助信息)*Type 例如我们要定义姓名、年龄、婚否三个命令行参数，我们可以按如下方式定义：

    name := flag.String("name", "张三", "姓名")
age := flag.Int("age", 18, "年龄")
married := flag.Bool("married", false, "婚否")
delay := flag.Duration("d", 0, "时间间隔")

    需要注意的是，此时name、age、married、delay均为对应类型的指针。

    flag.TypeVar()

    基本格式如下： flag.TypeVar(Type指针, flag名, 默认值, 帮助信息) 例如我们要定义姓名、年龄、婚否三个命令行参数，我们可以按如下方式定义：

    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()

    通过以上两种方法定义好命令行flag参数后，需要通过调用flag.Parse()来对命令行参数进行解析。

    支持的命令行参数格式有以下几种：

    • -flag xxx （使用空格，一个-符号）
    • --flag xxx （使用空格，两个-符号）
    • -flag=xxx （使用等号，一个-符号）
    • --flag=xxx （使用等号，两个-符号）

    其中，布尔类型的参数必须使用等号的方式指定。

    Flag解析在第一个非flag参数（单个”-“不是flag参数）之前停止，或者在终止符”–“之后停止。

    flag其他函数

    flag.Args()  ////返回命令行参数后的其他参数，以[]string类型
flag.NArg()  //返回命令行参数后的其他参数个数
flag.NFlag() //返回使用的命令行参数个数

    完整示例

    定义

    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_demo -help
Usage of ./flag_demo:
  -age int
        年龄 (default 18)
  -d duration
        时间间隔
  -married
        婚否
  -name string
        姓名 (default "张三")

    正常使用命令行flag参数：

    $ ./flag_demo -name 沙河娜扎 --age 28 -married=false -d=1h30m
沙河娜扎 28 false 1h30m0s
[]
0
4

    使用非flag命令行参数：

    $ ./flag_demo a b c
张三 18 false 0s
[a b c]
3
0

    log

    无论是软件开发的调试阶段还是软件上线之后的运行阶段，日志一直都是非常重要的一个环节，我们也应该养成在程序中记录日志的好习惯。

    log

    Go语言内置的log包实现了简单的日志服务。本文介绍了标准库log的基本使用。

    使用Logger

    log包定义了Logger类型，该类型提供了一些格式化输出的方法。本包也提供了一个预定义的“标准”logger，可以通过调用函数Print系列(Print|Printf|Println）、Fatal系列（Fatal|Fatalf|Fatalln）、和Panic系列（Panic|Panicf|Panicln）来使用，比自行创建一个logger对象更容易使用。

    例如，我们可以像下面的代码一样直接通过log包来调用上面提到的方法，默认它们会将日志信息打印到终端界面：

    package main

import (
    "log"
)

func main() {
    log.Println("这是一条很普通的日志。")
    v := "很普通的"
    log.Printf("这是一条%s日志。\n", v)
    log.Fatalln("这是一条会触发fatal的日志。")
    log.Panicln("这是一条会触发panic的日志。")
}

    编译并执行上面的代码会得到如下输出：

    2017/06/19 14:04:17 这是一条很普通的日志。
2017/06/19 14:04:17 这是一条很普通的日志。
2017/06/19 14:04:17 这是一条会触发fatal的日志。

    logger会打印每条日志信息的日期、时间，默认输出到系统的标准错误。Fatal系列函数会在写入日志信息后调用os.Exit(1)。Panic系列函数会在写入日志信息后panic。

    配置logger

    标准logger的配置

    默认情况下的logger只会提供日志的时间信息，但是很多情况下我们希望得到更多信息，比如记录该日志的文件名和行号等。log标准库中为我们提供了定制这些设置的方法。

    log标准库中的Flags函数会返回标准logger的输出配置，而SetFlags函数用来设置标准logger的输出配置。

    func Flags() int
func SetFlags(flag int)

    flag选项

    log标准库提供了如下的flag选项，它们是一系列定义好的常量。

    const (
    // 控制输出日志信息的细节，不能控制输出的顺序和格式。
    // 输出的日志在每一项后会有一个冒号分隔：例如2009/01/23 01:23:23.123123 /a/b/c/d.go:23: message
    Ldate         = 1 << iota     // 日期：2009/01/23
    Ltime                         // 时间：01:23:23
    Lmicroseconds                 // 微秒级别的时间：01:23:23.123123（用于增强Ltime位）
    Llongfile                     // 文件全路径名+行号： /a/b/c/d.go:23
    Lshortfile                    // 文件名+行号：d.go:23（会覆盖掉Llongfile）
    LUTC                          // 使用UTC时间
    LstdFlags     = Ldate | Ltime // 标准logger的初始值
)

    下面我们在记录日志之前先设置一下标准logger的输出选项如下：

    func main() {
    log.SetFlags(log.Llongfile | log.Lmicroseconds | log.Ldate)
    log.Println("这是一条很普通的日志。")
}

    编译执行后得到的输出结果如下：

    2017/06/19 14:05:17.494943 .../log_demo/main.go:11: 这是一条很普通的日志。

    配置日志前缀

    log标准库中还提供了关于日志信息前缀的两个方法：

    func Prefix() string
func SetPrefix(prefix string)

    其中Prefix函数用来查看标准logger的输出前缀，SetPrefix函数用来设置输出前缀。

    func main() {
    log.SetFlags(log.Llongfile | log.Lmicroseconds | log.Ldate)
    log.Println("这是一条很普通的日志。")
    log.SetPrefix("[小王子]")
    log.Println("这是一条很普通的日志。")
}

    上面的代码输出如下：

    [小王子]2017/06/19 14:05:57.940542 .../log_demo/main.go:13: 这是一条很普通的日志。

    这样我们就能够在代码中为我们的日志信息添加指定的前缀，方便之后对日志信息进行检索和处理。

    配置日志输出位置

    func SetOutput(w io.Writer)

    SetOutput函数用来设置标准logger的输出目的地，默认是标准错误输出。

    例如，下面的代码会把日志输出到同目录下的xx.log文件中。

    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.Println("这是一条很普通的日志。")
    log.SetPrefix("[小王子]")
    log.Println("这是一条很普通的日志。")
}

    如果你要使用标准的logger，我们通常会把上面的配置操作写到init函数中。

    func init() {
    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)
}

    创建logger

    log标准库中还提供了一个创建新logger对象的构造函数–New，支持我们创建自己的logger示例。New函数的签名如下：

    func New(out io.Writer, prefix string, flag int) *Logger

    New创建一个Logger对象。其中，参数out设置日志信息写入的目的地。参数prefix会添加到生成的每一条日志前面。参数flag定义日志的属性（时间、文件等等）。

    举个例子：

    func main() {
    logger := log.New(os.Stdout, "<New>", log.Lshortfile|log.Ldate|log.Ltime)
    logger.Println("这是自定义的logger记录的日志。")
}

    将上面的代码编译执行之后，得到结果如下：

    <New>2017/06/19 14:06:51 main.go:34: 这是自定义的logger记录的日志。

    总结

    Go内置的log库功能有限，例如无法满足记录不同级别日志的情况，我们在实际的项目中根据自己的需要选择使用第三方的日志库，如logrus、zap等。

    strconv

    Go语言中strconv包实现了基本数据类型和其字符串表示的相互转换。

    strconv包

    strconv包实现了基本数据类型与其字符串表示的转换，主要有以下常用函数： Atoi()、Itia()、parse系列、format系列、append系列。

    更多函数请查看官方文档。

    string与int类型转换

    这一组函数是我们平时编程中用的最多的。

    Atoi()

    Atoi()函数用于将字符串类型的整数转换为int类型，函数签名如下。

    func Atoi(s string) (i int, err error)

    如果传入的字符串参数无法转换为int类型，就会返回错误。

    s1 := "100"
i1, err := strconv.Atoi(s1)
if err != nil {
    fmt.Println("can't convert to int")
} else {
    fmt.Printf("type:%T value:%#v\n", i1, i1) //type:int value:100
}

    Itoa()

    Itoa()函数用于将int类型数据转换为对应的字符串表示，具体的函数签名如下。

    func Itoa(i int) string

    示例代码如下：

    i2 := 200
s2 := strconv.Itoa(i2)
fmt.Printf("type:%T value:%#v\n", s2, s2) //type:string value:"200"

    a的典故

    【扩展阅读】这是C语言遗留下的典故。C语言中没有string类型而是用字符数组(array)表示字符串，所以Itoa对很多C系的程序员很好理解。

    Parse系列函数

    Parse类函数用于转换字符串为给定类型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint()。

    ParseBool()

    func ParseBool(str string) (value bool, err error)

    返回字符串表示的bool值。它接受1、0、t、f、T、F、true、false、True、False、TRUE、FALSE；否则返回错误。

    ParseInt()

    func ParseInt(s string, base int, bitSize int) (i int64, err error)

    返回字符串表示的整数值，接受正负号。

    base指定进制（2到36），如果base为0，则会从字符串前置判断，”0x”是16进制，”0”是8进制，否则是10进制；

    bitSize指定结果必须能无溢出赋值的整数类型，0、8、16、32、64 分别代表 int、int8、int16、int32、int64；

    返回的err是*NumErr类型的，如果语法有误，err.Error = ErrSyntax；如果结果超出类型范围err.Error = ErrRange。

    ParseUnit()

    func ParseUint(s string, base int, bitSize int) (n uint64, err error)

    ParseUint类似ParseInt但不接受正负号，用于无符号整型。

    ParseFloat()

    func ParseFloat(s string, bitSize int) (f float64, err error)

    解析一个表示浮点数的字符串并返回其值。

    如果s合乎语法规则，函数会返回最为接近s表示值的一个浮点数（使用IEEE754规范舍入）。

    bitSize指定了期望的接收类型，32是float32（返回值可以不改变精确值的赋值给float32），64是float64；

    返回值err是*NumErr类型的，语法有误的，err.Error=ErrSyntax；结果超出表示范围的，返回值f为±Inf，err.Error= ErrRange。

    代码示例

    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)

    这些函数都有两个返回值，第一个返回值是转换后的值，第二个返回值为转化失败的错误信息。

    Format系列函数

    Format系列函数实现了将给定类型数据格式化为string类型数据的功能。

    FormatBool()

    func FormatBool(b bool) string

    根据b的值返回”true”或”false”。

    FormatInt()

    func FormatInt(i int64, base int) string

    返回i的base进制的字符串表示。base 必须在2到36之间，结果中会使用小写字母’a’到’z’表示大于10的数字。

    FormatUint()

    func FormatUint(i uint64, base int) string

    是FormatInt的无符号整数版本。

    FormatFloat()

    func FormatFloat(f float64, fmt byte, prec, bitSize int) string

    函数将浮点数表示为字符串并返回。

    bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。

    fmt表示格式：’f’（-ddd.dddd）、’b’（-ddddp±ddd，指数为二进制）、’e’（-d.dddde±dd，十进制指数）、’E’（-d.ddddE±dd，十进制指数）、’g’（指数很大时用’e’格式，否则’f’格式）、’G’（指数很大时用’E’格式，否则’f’格式）。

    prec控制精度（排除指数部分）：对’f’、’e’、’E’，它表示小数点后的数字个数；对’g’、’G’，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表示f。

    代码示例

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

    其他

    isPrint()

    func IsPrint(r rune) bool

    返回一个字符是否是可打印的，和unicode.IsPrint一样，r必须是：字母（广义）、数字、标点、符号、ASCII空格。

    CanBackquote()

    func CanBackquote(s string) bool

    返回字符串s是否可以不被修改的表示为一个单行的、没有空格和tab之外控制字符的反引号字符串。

    其他

    除上文列出的函数外，strconv包中还有Append系列、Quote系列等函数。具体用法可查看官方文档。

    Context

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

    为什么需要Context
    基本示例
    package main

    import (
    "fmt"
    "sync"

    "time"

    )

    var wg sync.WaitGroup

    // 初始的例子

    func worker() {
    for {
    fmt.Println("worker")
    time.Sleep(time.Second)
    }
    // 如何接收外部命令实现退出
    wg.Done()
    }

    func main() {
    wg.Add(1)
    go worker()
    // 如何优雅的实现结束子goroutine
    wg.Wait()
    fmt.Println("over")
    }
    全局变量方式
    package main

    import (
    "fmt"
    "sync"

    "time"

    )

    var wg sync.WaitGroup
    var exit bool

    // 全局变量方式存在的问题：
    // 1. 使用全局变量在跨包调用时不容易统一
    // 2. 如果worker中再启动goroutine，就不太好控制了。

    func worker() {
    for {
    fmt.Println("worker")
    time.Sleep(time.Second)
    if exit {
    break
    }
    }
    wg.Done()
    }

    func main() {
    wg.Add(1)
    go worker()
    time.Sleep(time.Second * 3) // sleep3秒以免程序过快退出
    exit = true // 修改全局变量实现子goroutine的退出
    wg.Wait()
    fmt.Println("over")
    }
    通道方式
    package main

    import (
    "fmt"
    "sync"

    "time"

    )

    var wg sync.WaitGroup

    // 管道方式存在的问题：
    // 1. 使用全局变量在跨包调用时不容易实现规范和统一，需要维护一个共用的channel

    func worker(exitChan chan struct{}) {
    LOOP:
    for {
    fmt.Println("worker")
    time.Sleep(time.Second)
    select {
    case <-exitChan: // 等待接收上级通知
    break LOOP
    default:
    }
    }
    wg.Done()
    }

    func main() {
    var exitChan = make(chan struct{})
    wg.Add(1)
    go worker(exitChan)
    time.Sleep(time.Second * 3) // sleep3秒以免程序过快退出
    exitChan <- struct{}{} // 给子goroutine发送退出信号
    close(exitChan)
    wg.Wait()
    fmt.Println("over")
    }
    官方版的方案
    package main

    import (
    "context"
    "fmt"
    "sync"

    "time"

    )

    var wg sync.WaitGroup

    func worker(ctx context.Context) {
    LOOP:
    for {
    fmt.Println("worker")
    time.Sleep(time.Second)
    select {
    case <-ctx.Done(): // 等待上级通知
    break LOOP
    default:
    }
    }
    wg.Done()
    }

    func main() {
    ctx, cancel := context.WithCancel(context.Background())
    wg.Add(1)
    go worker(ctx)
    time.Sleep(time.Second * 3)
    cancel() // 通知子goroutine结束
    wg.Wait()
    fmt.Println("over")
    }
    当子goroutine又开启另外一个goroutine时，只需要将ctx传入即可：

    package main

    import (
    "context"
    "fmt"
    "sync"

    "time"

    )

    var wg sync.WaitGroup

    func worker(ctx context.Context) {
    go worker2(ctx)
    LOOP:
    for {
    fmt.Println("worker")
    time.Sleep(time.Second)
    select {
    case <-ctx.Done(): // 等待上级通知
    break LOOP
    default:
    }
    }
    wg.Done()
    }

    func worker2(ctx context.Context) {
    LOOP:
    for {
    fmt.Println("worker2")
    time.Sleep(time.Second)
    select {
    case <-ctx.Done(): // 等待上级通知
    break LOOP
    default:
    }
    }
    }
    func main() {
    ctx, cancel := context.WithCancel(context.Background())
    wg.Add(1)
    go worker(ctx)
    time.Sleep(time.Second * 3)
    cancel() // 通知子goroutine结束
    wg.Wait()
    fmt.Println("over")
    }
    Context初识
    Go1.7加入了一个新的标准库context，它定义了Context类型，专门用来简化 对于处理单个请求的多个 goroutine 之间与请求域的数据、取消信号、截止时间等相关操作，这些操作可能涉及多个 API 调用。

    对服务器传入的请求应该创建上下文，而对服务器的传出调用应该接受上下文。它们之间的函数调用链必须传递上下文，或者可以使用WithCancel、WithDeadline、WithTimeout或WithValue创建的派生上下文。当一个上下文被取消时，它派生的所有上下文也被取消。

    Context接口
    context.Context是一个接口，该接口定义了四个需要实现的方法。具体签名如下：

    type Context interface {
    Deadline() (deadline time.Time, ok bool)
    Done() <-chan struct{}
    Err() error
    Value(key interface{}) interface{}
    }
    其中：

    Deadline方法需要返回当前Context被取消的时间，也就是完成工作的截止时间（deadline）；
    Done方法需要返回一个Channel，这个Channel会在当前工作完成或者上下文被取消之后关闭，多次调用Done方法会返回同一个Channel；
    Err方法会返回当前Context结束的原因，它只会在Done返回的Channel被关闭时才会返回非空的值；
    如果当前Context被取消就会返回Canceled错误；
    如果当前Context超时就会返回DeadlineExceeded错误；
    Value方法会从Context中返回键对应的值，对于同一个上下文来说，多次调用Value 并传入相同的Key会返回相同的结果，该方法仅用于传递跨API和进程间跟请求域的数据；
    Background()和TODO()
    Go内置两个函数：Background()和TODO()，这两个函数分别返回一个实现了Context接口的background和todo。我们代码中最开始都是以这两个内置的上下文对象作为最顶层的partent context，衍生出更多的子上下文对象。

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

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

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

    With系列函数
    此外，context包中还定义了四个With系列函数。

    WithCancel
    WithCancel的函数签名如下：

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

    取消此上下文将释放与其关联的资源，因此代码应该在此上下文中运行的操作完成后立即调用cancel。

    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
    }
}

    }
    上面的示例代码中，gen函数在单独的goroutine中生成整数并将它们发送到返回的通道。 gen的调用者在使用生成的整数之后需要取消上下文，以免gen启动的内部goroutine发生泄漏。

    WithDeadline
    WithDeadline的函数签名如下：

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

    取消此上下文将释放与其关联的资源，因此代码应该在此上下文中运行的操作完成后立即调用cancel。

    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())
}

    }
    上面的代码中，定义了一个50毫秒之后过期的deadline，然后我们调用context.WithDeadline(context.Background(), d)得到一个上下文（ctx）和一个取消函数（cancel），然后使用一个select让主程序陷入等待：等待1秒后打印overslept退出或者等待ctx过期后退出。 因为ctx50秒后就过期，所以ctx.Done()会先接收到值，上面的代码会打印ctx.Err()取消原因。

    WithTimeout
    WithTimeout的函数签名如下：

    func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
    WithTimeout返回WithDeadline(parent, time.Now().Add(timeout))。

    取消此上下文将释放与其相关的资源，因此代码应该在此上下文中运行的操作完成后立即调用cancel，通常用于数据库或者网络连接的超时控制。具体示例如下：

    package main

    import (
    "context"
    "fmt"
    "sync"

    "time"

    )

    // context.WithTimeout

    var wg sync.WaitGroup

    func worker(ctx context.Context) {
    LOOP:
    for {
    fmt.Println("db connecting ...")
    time.Sleep(time.Millisecond * 10) // 假设正常连接数据库耗时10毫秒
    select {
    case <-ctx.Done(): // 50毫秒后自动调用
    break LOOP
    default:
    }
    }
    fmt.Println("worker done!")
    wg.Done()
    }

    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")
    }
    WithValue
    WithValue函数能够将请求作用域的数据与 Context 对象建立关系。声明如下：

    func WithValue(parent Context, key, val interface{}) Context
    WithValue返回父节点的副本，其中与key关联的值为val。

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

    所提供的键必须是可比较的，并且不应该是string类型或任何其他内置类型，以避免使用上下文在包之间发生冲突。WithValue的用户应该为键定义自己的类型。为了避免在分配给interface{}时进行分配，上下文键通常具有具体类型struct{}。或者，导出的上下文关键变量的静态类型应该是指针或接口。

    package main

    import (
    "context"
    "fmt"
    "sync"

    "time"

    )

    // context.WithValue

    type TraceCode string

    var wg sync.WaitGroup

    func worker(ctx context.Context) {
    key := TraceCode("TRACE_CODE")
    traceCode, ok := ctx.Value(key).(string) // 在子goroutine中获取trace code
    if !ok {
    fmt.Println("invalid trace code")
    }
    LOOP:
    for {
    fmt.Printf("worker, trace code:%s\n", traceCode)
    time.Sleep(time.Millisecond * 10) // 假设正常连接数据库耗时10毫秒
    select {
    case <-ctx.Done(): // 50毫秒后自动调用
    break LOOP
    default:
    }
    }
    fmt.Println("worker done!")
    wg.Done()
    }

    func main() {
    // 设置一个50毫秒的超时
    ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*50)
    // 在系统的入口中设置trace code传递给后续启动的goroutine实现日志数据聚合
    ctx = context.WithValue(ctx, TraceCode("TRACE_CODE"), "12512312234")
    wg.Add(1)
    go worker(ctx)
    time.Sleep(time.Second * 5)
    cancel() // 通知子goroutine结束
    wg.Wait()
    fmt.Println("over")
    }
    使用Context的注意事项
    推荐以参数的方式显示传递Context
    以Context作为参数的函数方法，应该把Context作为第一个参数。
    给一个函数方法传递Context的时候，不要传递nil，如果不知道传递什么，就使用context.TODO()
    Context的Value相关方法应该传递请求域的必要数据，不应该用于传递可选参数
    Context是线程安全的，可以放心的在多个goroutine中传递
    客户端超时取消示例
    调用服务端API时如何在客户端实现超时控制？

    server端
    // context_timeout/server/main.go
    package main

    import (
    "fmt"
    "math/rand"
    "net/http"

    "time"

    )

    // server端，随机出现慢响应

    func indexHandler(w http.ResponseWriter, r *http.Request) {
    number := rand.Intn(2)
    if number == 0 {
    time.Sleep(time.Second * 10) // 耗时10秒的慢响应
    fmt.Fprintf(w, "slow response")
    return
    }
    fmt.Fprint(w, "quick response")
    }

    func main() {
    http.HandleFunc("/", indexHandler)
    err := http.ListenAndServe(":8000", nil)
    if err != nil {
    panic(err)
    }
    }
    client端
    // context_timeout/client/main.go
    package main

    import (
    "context"
    "fmt"
    "io/ioutil"
    "net/http"
    "sync"
    "time"
    )

    // 客户端

    type respData struct {
    resp *http.Response
    err error
    }

    func doCall(ctx context.Context) {
    transport := http.Transport{
    // 请求频繁可定义全局的client对象并启用长链接
    // 请求不频繁使用短链接
    DisableKeepAlives: true, }
    client := http.Client{
    Transport: &transport,
    }

    respChan := make(chan *respData, 1)
req, err := http.NewRequest("GET", "http://127.0.0.1:8000/", nil)
if err != nil {
    fmt.Printf("new requestg failed, err:%v\n", err)
    return
}
req = req.WithContext(ctx) // 使用带超时的ctx创建一个新的client request
var wg sync.WaitGroup
wg.Add(1)
defer wg.Wait()
go func() {
    resp, err := client.Do(req)
    fmt.Printf("client.do resp:%v, err:%v\n", resp, err)
    rd := &respData{
        resp: resp,
        err:  err,
    }
    respChan <- rd
    wg.Done()
}()

select {
case <-ctx.Done():
    //transport.CancelRequest(req)
    fmt.Println("call api timeout")
case result := <-respChan:
    fmt.Println("call server api success")
    if result.err != nil {
        fmt.Printf("call server api failed, err:%v\n", result.err)
        return
    }
    defer result.resp.Body.Close()
    data, _ := ioutil.ReadAll(result.resp.Body)
    fmt.Printf("resp:%v\n", string(data))
}

    }

    func main() {
    // 定义一个100毫秒的超时
    ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*100)
    defer cancel() // 调用cancel释放子goroutine资源
    doCall(ctx)
    }

    相关文章

      网友评论

          本文标题：12.包

          本文链接：https://www.haomeiwen.com/subject/gidyvhtx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|12.包|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！