Go的常用包

flag包

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

os.Args()

 //功能:简单获取命令行参数
 func main()  {
    if (len(os.Args)) >0 { //Args是一个[] string
       for index,arg:=range os.Args{
          fmt.Printf("arg[%d]=%v\n",index,arg)
       }
    }
 }  //os.Args是一个存储命令行参数的字符串切片，它的第一个元素是执行文件的名称

flag参数类型

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

下面介绍两种常用的定义命令行flag参数的方法

flag.Type()

 //定义三个命令行参数
 name:=flag.String("name","huangsir","姓名")
 age:=flag.Int("age",18,"年龄")
 married:=flag.Bool("married",false,"是否结婚")
 delay:=flag.Duration("d",0,"时间间隔"）
 //我们需要知道，此时的name age married delay 都是对应类型的指针类型

flag.TypeVar()

 var name stringvar age intvar married boolvar 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 xxx(空格，一个-符号)

• --flag xxx(空格，两个-符号)

• -flag=xxx(等号，一个-符号)

• --flag=xxx(等号，两个-符号)

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

flag解析在第一个非flag参数之前停止，或者在终止符“-”之后停止

其他函数

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

栗子

 func main()  {
    //定义命令行参数
    var name string
    var age int
    var married bool
    var delay time.Duration //时间段类型
    flag.StringVar(&name,"name","xiaohuang","thename")
    flag.IntVar(&age,"age",18,"theage")
    flag.BoolVar(&married,"married",false,"themarried")
    flag.DurationVar(&delay,"delay",1*time.Hour,"thedelay")
    //命令行参数解析
    flag.Parse()
    fmt.Println(name,age,married,delay)
    //返回命令行参数后的其他参数
    fmt.Println(flag.Args())
    fmt.Println(flag.NArg())
    fmt.Println(flag.NFlag())
 ​
 ​
 }
 ​
 ​
 ​
 //demo.exe -name huangxinci    terminal修改命令行参数的值
 //打印结果
 huangxinci 18 false 0s   
 []
 0
 1

log包

Go中的内置log包实现了简单的日志服务，Log打印的信息和普通的输出不一样的地方在于它会打印出执行时间，log包中定义了Logger类型，该类型提供了一些格式化输出的方法

栗子

 func main()  {
    log.Println("这是一条很普通的日志")
    //log.Fatal("这是一条会触发fatal的日志")
    //log.Panicln("这是一条会触发panic的日志")
 }
 //logger会打印每条日志信息的日期 时间，默认输出到系统的terminal中
 Fatal系列函数会在写入日志信息后调用os.Exit(1)退出程序
 Panic系列函数会在写入日志信息后触发panic

标准logger的配置

默认情况下的logger只会提供日志的事件信息，但很多情况下这是远远不够的，我们还可以通过设置logger得到更多信息，以下是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的初始值)

进行设置的栗子

 func main() {
    log.SetFlags(log.Llongfile|log.Lmicroseconds|log.Ldate) //设置输出日期和输出到微秒级别，以及文件的绝对路径
    log.Println("这是一条很普通的日志。")
 }
 ​
 //输出：2021/11/04 16:57:48.806863 D:/GoProject/src/golangstudy/jike/log/newdemo.go:7: 这是一条很普通的日志。

配置日志前缀

 func Prefix() string //查看标准logger的输出前缀
 func SetPrefix(prefix string) //设置标准logger的输出前缀
 ​
 func main()  {
    log.SetFlags(log.Llongfile|log.Lmicroseconds|log.Ldate)
    log.Println("这是一条普通的日志")
    log.SetPrefix("[小黄出品]")
    log.Println("这是一条普通的日志")
 }
 ​
 //output:
 2021/11/04 17:16:22.651103 D:/GoProject/src/golangstudy/jike/log/demo3.go:7: 这是一条普通的日志
 [小黄出品]2021/11/04 17:16:22.665601 D:/GoProject/src/golangstudy/jike/log/demo3.go:9: 

配置日志输出的位置

 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("这是一条很普通的日志。")
 }//输出到xx.log文件中

当然，标准的logger配置应该在init函数中完成而不是main函数

time包

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

时间的类型

time.Time表示时间类型，我们可以通过time.Now()函数获取当前的时间对象，然后获取时间对象的部分信息

一个demo

 func main()  {
    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.Println(year,month,day,hour,minute,second)
 }

时间戳

时间戳：自1960年1月1日08:00:00至当前时间的总毫秒数，它也被称为Unix时间戳

demo:

 func main()  {
    now:=time.Now()
    t1:=now.Unix()   //时间戳
    t2:=now.UnixNano()  //纳秒级时间戳
    fmt.Println(t1)
    fmt.Println(t2)
 }
 //output
 1636018671
 1636018671762398700

time.Unix()

 //把时间戳转化为日期
 func main()  {
    now:=time.Now()
    t1:=now.Unix()   //时间戳
    t2:=now.UnixNano()  //纳秒级时间戳
    t3:=time.Unix(t1,0)
    fmt.Println(t1)
    fmt.Println(t2)
    fmt.Println(t3)
 }
 //output
 1636018671
 1636018671762398700
 2021-11-04 17:37:51 +0800 CST

时间间隔

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

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

时间操作

Add

 时间+时间间隔
 func (t Time) Add(d Duration) Time
 ​
 func main()  {
    now:=time.Now()
    later:=now.Add(time.Hour)
    fmt.Println(later)
 }

Sub

 两个时间的时间差
 func (t Time) Sub(u Time) Duration

Equal Before After

 func (t Time) Equal(u Time) bool  //判断两个时间是否相同，会考虑时区影响
 func (t Time) Before(u Time) bool  //t 在 u 之前，则返回真，否则返回假
 func (t Time) After(u Time) bool  //t 在 u之后，则返回真，否则返回假

定时器

 使用time.Tick(时间间隔)来设置定时器，定时器的本质上是一个channel
 func main() {
    ticker := time.Tick(time.Second) //定义一个1秒间隔的定时器
    for i := range ticker {
       fmt.Println(i)//每秒都会执行的任务
    }
 }

时间格式化

时间类型有一个自带的方法进行格式化，需要注意的是Go语言中格式化的时间模板是Go的诞生时间 2006/01/02 15:04 记忆方法2006 1 2 3 4

strcnov包

 

实现了基本数据类型与其字符串表示的转换，主要用以下常用函数:Atoi() Itoa() Parese系列 Format系列

string和int之间的转换

Atoi()

 Atoi() 函数用于将字符串类型的整数转换为int类型，函数签名如下
 func Atoi(s string) (i int, err error)
 ​
 func main()  {
    s1:="100"
    res,err:=strconv.Atoi(s1)
    if err!=nil {
       fmt.Println("failed to change ,err:",err)
       return
    }
    fmt.Println(res)
 }

Itoa()

 Itoa() //用于将int类型数据转换为对应的字符串表示，具体的函数签名如下
 func Itoa(i int) string
 ​
 func main()  {
    a:=100
    i:=strconv.Itoa(a)
    /*if err!=nil {
       fmt.Println("failed to change the data,err:",err)
       return
    } */
    fmt.Println(i)
 } //这个函数是strcnov包里面我们用的最多的

Parse系列函数

 Parse类函数用于转换字符串为给定类型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint()
 ​
 func ParseBool(str string) (value bool, err error)  //返回字符串表示的bool值，接受1 0 t f T F true false 否则返回错误
 ​
 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
 ​
 func ParseUint(s string, base int, bitSize int) (n uint64, err error) //类似于ParseInt但不接受正负号
 ​
 func ParseFloat(s string, bitSize int) (f float64, err error)
 //解析一个表示浮点数的字符串并返回其值

Format系列

 实现了将给定类型数据格式化为string类型数据的功能
 FormatBool()
 func FormatBool(b bool) string //根据b的值返回true或者false 
 ​
 FormatInt()
 func FormatInt(i int64, base int) string //返回i的base进制的字符串表示
 ​
 FormatUint()
 func FormatUint(i uint64, base int) string //FormatInt的无符号整数版本
 ​
 FormatFloat()
 func FormatFloat(f float64, fmt byte, prec, bitSize int) string //将浮点数表示为字符串

其他

 isPrint()
 func IsPrint(r rune) bool//判断一个字符是否为可打印的 r必须是:字母（广义） 数字 标点  符号 ASCII空格

除上文列出的函数外，strconv包中还有Append系列 Quote系列等函数