go os.args/time/md5/base/log包简单使用(37)

开发运维 2023-07-15 法医 手机阅读
Scan me!

os.args模块和time,md5以及base和log模块请输入图片描述

9.os.args模块

os.args是在os模块中，我们可以简单打印os.args，而后传递 一些参数

package main
import (
    "os"
    "fmt"
)
 
func main(){
    fmt.Println(os.Args)
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run args.go www.linuxea.com
[/tmp/go-build909504842/b001/exe/args www.linuxea.com]

打印的结果是，文件的目录和传入的参数

也可以进行build

[root@linuxea.com /opt/Golang/work4/stdpkg]# go build args.go 
[root@linuxea.com /opt/Golang/work4/stdpkg]# chmod +x args

如下：

[root@linuxea.com /opt/Golang/work4/stdpkg]# ./args www.linuxea.com
[./args www.linuxea.com]

命令后传递参数可以看flag

10.flag模块绑定变量

  • 示例

我们定义一个flag的参数传递

首先定义个变量

var port int

而后使用flag.IntVar()绑定命令行参数，这里需要传递指针，参数，默认值，备注。如下：

  • 参数-P
  • 默认值88
  • 备注nginx port
flag.IntVar(&port,"P",88,"nginx port")

解析命令行参数

flag.Parse()

而后打印

fmt.Println(port)

在如法炮制一个host的string和verbor的布尔类型参数，如下

package main
 
import (
    "flag"
    "fmt"
)
func main(){
    var port int
    var host string
    var verbor bool
    flag.IntVar(&port,"P",88,"nginx port")
    flag.StringVar(&host,"H","127.0.0.1","-host addr")
    flag.BoolVar(&verbor,"v",false,"detail log")
    
    flag.Parse()
    fmt.Println(host,port,verbor)
}

运行默认的参数就是127.0.0.1 88

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run flag.go -P 66 -H 10.0.0.96
10.0.0.96 66 false

我们可以传递参数，-P和-H，-P是int类型，-H是string类型，-V是bool类型，如果输入错误就会报错，并且打出使用信息

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run flag.go -P st -H 10.0.0.96 -v
invalid value "st" for flag -P: parse error
Usage of /tmp/go-build440964329/b001/exe/flag:
  -H string
        -host addr (default "127.0.0.1")
  -P int
        nginx port (default 88)
  -v    detail log
exit status 2

使用-P和-H传递参数，如果不加-v默认就是false

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run flag.go -P 66 -H 10.0.0.96 
10.0.0.96 66 false

加上-V就变成了true

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run flag.go -P 66 -H 10.0.0.96 -v
10.0.0.96 66 true

10.1--help

利用boolvar编写help帮助

声明一个Boolvar的help变量

var help bool
flag.BoolVar(&help,"help",false,"help")
func main(){
    var port int
    var host string
    var verbor bool
    var help bool
    flag.IntVar(&port,"P",88,"nginx port")
    flag.StringVar(&host,"H","127.0.0.1","-host addr")
    flag.BoolVar(&verbor,"v",false,"detail log")
    flag.BoolVar(&help,"help",false,"help")
    
    flag.Parse()
 
    fmt.Println(host,port,verbor)
}

而后判断help如果为true就打印帮助信息，这里调用flag.Usage()。

    if help{
        flag.Usage()
    }else {
        fmt.Println(host,port,verbor)
    }

运行

加上-h

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run flag.go -h
Usage of /tmp/go-build717929224/b001/exe/flag:
  -H string
        -host addr (default "127.0.0.1")
  -P int
        nginx port (default 88)
  -help
        help
  -v    detail log
exit status 2

而这个flag.Usage()可以改写

10.2flag.Usag

  • flag.Usage()

flag.Usage()是一个无参的函数，我们进行重新赋值

    flag.Usage = func(){
        fmt.Println("Usage flagargs:n    -H --host 127.0.0.1n    -P --port 80n    -V")
    }

而后在调用，就发现已经被改写了

package main
 
import (
    "flag"
    "fmt"
)
func main(){
    var port int
    var host string
    var verbor bool
    var help bool
    flag.IntVar(&port,"P",88,"nginx port")
    flag.StringVar(&host,"H","127.0.0.1","-host addr")
    flag.BoolVar(&verbor,"v",false,"detail log")
    flag.BoolVar(&help,"help",false,"help")
    
 
    flag.Usage = func(){
        fmt.Println("Usage flagargs:n    -H --host 127.0.0.1n    -P --port 80n    -V")
    }
 
    flag.Parse()
 
    if help{
        flag.Usage()
    }else {
        fmt.Println(host,port,verbor)
    }
}

运行，使用-H

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run flag.go -h
Usage flagargs:
    -H --host 127.0.0.1
    -P --port 80
    -V
exit status 2

或者我们在加一个参数，使用flag.PrintlnDefaults()

10.3flag.PrintDefault

  • flag.PrintDefault

在原来的基础上，加上flag.PrintDefaults()

    flag.Usage = func(){
        fmt.Println("Usage flagargs: [ -H --host 127.0.0.1  -P --port 80 -V ]")
        flag.PrintDefaults()
    }

代码块

[root@linuxea.com /opt/Golang/work4/stdpkg]# cat flag.go 
package main
 
import (
    "flag"
    "fmt"
)
func main(){
    var port int
    var host string
    var verbor bool
    var help bool
    flag.IntVar(&port,"P",88,"nginx port")
    flag.StringVar(&host,"H","127.0.0.1","-host addr")
    flag.BoolVar(&verbor,"v",false,"detail log")
    flag.BoolVar(&help,"help",false,"help")
    
 
    flag.Usage = func(){
        fmt.Println("Usage flagargs: [ -H --host 127.0.0.1  -P --port 80 -V ]")
        flag.PrintDefaults()
    }
 
    flag.Parse()
 
    if help{
        flag.Usage()
    }else {
        fmt.Println(host,port,verbor)
    }
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run flag.go -h
Usage flagargs: [ -H --host 127.0.0.1  -P --port 80 -V ]
  -H string
        -host addr (default "127.0.0.1")
  -P int
        nginx port (default 88)
  -help
        help
  -v    detail log
exit status 2

那么，现在看到的就是自己的定义的格式。

10.4flag.args

  • flag.args

现在，假如还要传递一些没有名称的flag，就是可以使用flag.args

在原有的代码上加上flag.args

    if help{
        flag.Usage()
    }else {
        fmt.Println(host,port,verbor)
        fmt.Println(flag.Args())
    }

我们添加一个Usage的信息[args01 args02]

并且在条件处理中也添加

    flag.Usage = func(){
        fmt.Println("Usage flagargs: [ -H --host 127.0.0.1  -P --port 80 -V ] [args01 args02]")
        flag.PrintDefaults()
    }

代码块

package main
 
import (
    "flag"
    "fmt"
    )
 
func main(){
 
    var port int
    var host string
    var verbor bool
    var help bool
    flag.IntVar(&port,"P",88,"nginx port")
    flag.StringVar(&host,"H","127.0.0.1","-host addr")
    flag.BoolVar(&verbor,"v",false,"detail log")
    flag.BoolVar(&help,"help",false,"help")
 
    flag.Usage = func(){
        fmt.Println("Usage flagargs: [ -H --host 127.0.0.1  -P --port 80 -V ] [args01 args02]")
        flag.PrintDefaults()
    }
 
    flag.Parse()
 
    if help{
        flag.Usage()
    }else {
        fmt.Println(host,port,verbor)
        fmt.Println(flag.Args())
    }
 
}

假如不传递任何参数，就是空的[]

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run flag.go
127.0.0.1 88 false
[]

传入参数

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run flag.go mark linuxea.com
127.0.0.1 88 false
[mark linuxea.com]

并且使用-H可以看到在Usage中添加的信息。

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run flag.go -H
flag needs an argument: -H
Usage flagargs: [ -H --host 127.0.0.1  -P --port 80 -V ] [args01 args02]
  -H string
        -host addr (default "127.0.0.1")
  -P int
        nginx port (default 88)
  -help
        help
  -v    detail log
exit status 2

10.5

我们换一种方式，赋值给每个flag，然后使用指针调用，如下：

package main
 
import (
    "flag"
    "fmt"
    )
 
func main(){
 
    port := flag.Int("P",88,"nginx port")
    host := flag.String("H","127.0.0.1","-host addr")
    verbor := flag.Bool("v",false,"detail log")
    help := flag.Bool("help",false,"help")
 
    flag.Usage = func(){
        fmt.Println("Usage flagargs: [ -H --host 127.0.0.1  -P --port 80 -V ] [args01 args02]")
        flag.PrintDefaults()
    }
 
    flag.Parse()
 
    fmt.Printf("%T %T %T %Tn",*port,*host,*verbor,*help)
    fmt.Printf("%v %v %v %vn",*port,*host,*verbor,*help)
 
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run flags.go
int string bool bool
88 127.0.0.1 false false

-v

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run flags.go -v
int string bool bool
88 127.0.0.1 true false

-H

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run flags.go -H
flag needs an argument: -H
Usage flagargs: [ -H --host 127.0.0.1  -P --port 80 -V ] [args01 args02]
  -H string
        -host addr (default "127.0.0.1")
  -P int
        nginx port (default 88)
  -help
        help
  -v    detail log
exit status 2

11.time模块

导入time模块，time的类型也是time.Time。我们使用time.Now()获取当前时间

  • 示例代码
package main
import (
    "fmt"
    "time"
)
func main(){
    now := time.Now()
    fmt.Printf("%Tn",now)
    fmt.Printf("%v",now)
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run time.go
time.Time
2019-10-02 21:29:02.017017987 +0800 CST m=+0.000473262

时间类型

  • 秒 time.Second
  • 分钟 time.Minute
  • 小时 time.Hour

11.1时间转换

最基础的方式是将时间转换成字符串

一般来讲有这样几种方式

2000/01/01 08:01:01

或者

2000-01-01 08:01:01

在go中，2006表示年，01表示月，02表示天，小时24进制使用15，分钟使用04表示，秒使用05表示

那么现在使用now.Format()来转换时间，如下

func main(){
    now := time.Now()
    fmt.Printf("%Tn",now)
    fmt.Printf("%vn",now)
 
    fmt.Println(now.Format("2006-01-02 15:04:05"))
    fmt.Println(now.Format("2006/01/02 15:04:05"))
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run time.go
time.Time
2019-10-02 21:48:34.622411579 +0800 CST m=+0.000180147
2019-10-02 21:48:34
2019/10/02 21:48:34
  • 年月日/时分秒

假如此刻只需要年月日， now.Format("2006/01/02")即可，如果只是时分秒now.Format("15:04:05")即可

package main
import (
    "fmt"
    "time"
)
func main(){
    now := time.Now()
    fmt.Println(now.Format("2006/01/02"))
    fmt.Println(now.Format("15:04:05"))
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run time.go
time.Time
2019/10/02
21:50:18

  • 转换unix时间戳

    now.Unix()

package main
import (
    "fmt"
    "time"
)
func main(){
    now := time.Now()
    fmt.Println(now.Unix())
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run time.go
1570065936

  • 纳秒

    now.UnixNano()

package main
import (
    "fmt"
    "time"
)
func main(){
    now := time.Now()
    fmt.Println(now.UnixNano())
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run time.go
1570066422096765619

11.2转换时间

  • 将字符串转换成时间
  • time.Parse

time.Parse又两个返回值，一个是err，一个是转换的值

转换的格式必须一样

  • 示例

我们定义一个时间格式，假如现在是2015/08/06 06:00:00，如下

    now := "2015/08/06 06:00:00"

而后使用time.Parse进行转换，在time.Parse("2006/01/02 15:04:05“)中的第一段时间是模板，第二段的时间是转换的时间。比如现在将now变量的2015/08/06 06:00:00按照2006/01/02 15:04:05格式转换成字符串。如下：

这里使用t和err进行接收返回值

    t,err := time.Parse("2006/01/02 15:04:05",now)

而后打印

fmt.Println(err,t)

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run time2.go
<nil> 2015-08-06 06:00:00 +0000 UTC
  • 将unix时间戳转换时间

示例:

    at := time.Unix(0,0)
    fmt.Println(at)

代码块

package main
import (
    "fmt"
    "time"
)
func main(){
    at := time.Unix(0,0)
    fmt.Println(at)
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run time2.go
1970-01-01 08:00:00 +0800 CST

11.3计算时间区间

需要两个time类型的时间进行计算时间区间，于是我们就定义两个时间点，分别是now和date，date的时间需要通过字符串转换

    now := time.Now()
    date := "2019/10/02 00:00:00"
    t,err := time.Parse("2006/01/02 15:04:05",date)

然后通过now.Sum计算当前时间和date的时间差。并且打印出类型

d := now.Sub(t)
fmt.Println(d)
fmt.Printf("%T",d)

代码块

package main
import (
    "fmt"
    "time"
)
func main(){
    now := time.Now()
 
    date := "2019/10/02 00:00:00"
    t,err := time.Parse("2006/01/02 15:04:05",date)
    fmt.Println(t,err)
    d := now.Sub(t)
    fmt.Println(d)
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run time3.go
2019-10-02 00:00:00 +0000 UTC <nil>
26h23m59.68928344s
time.Duration

当前时间与date时间差了26h23m59.68928344s，时间区间的类型是time.Duration

### 11.4休眠时间

time.Sleep需要设置一个时间区间，比如，休眠三秒

    fmt.Println(time.Now())
    time.Sleep(time.Second * 3)
    fmt.Println(time.Now())

代码块

package main
import (
    "fmt"
    "time"
)
func main(){
    fmt.Println(time.Now())
    time.Sleep(time.Second * 3)
    fmt.Println(time.Now())
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run time4.go
2019-10-03 10:35:32.848757428 +0800 CST m=+0.000131262
2019-10-03 10:35:35.849273679 +0800 CST m=+3.000647522

11.5添加时间区间

我们给当前的时间加上几个小时后打印

package main
import (
    "fmt"
    "time"
)
func main(){
    fmt.Println(time.Now())
    now := time.Now()
    t := now.Add(3 * time.Hour)
    fmt.Println(t)
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run time4.go
2019-10-03 10:41:26.584561434 +0800 CST m=+0.000090932
2019-10-03 13:41:26.58466329 +0800 CST m=+10800.000192739

11.6解析时间区间

  • time.ParseDuration

可以将时间格式解析，time.ParseDuration又两个返回值

    d,err := time.ParseDuration("3h2m5s")
    fmt.Println(err,d)

代码块

package main
import (
    "fmt"
    "time"
)
func main(){
    d,err := time.ParseDuration("3h2m5s")
    fmt.Println(err,d)
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run time5.go
<nil> 3h2m5s

并且可以转换成小时，分钟，秒，只需使用Hours，Minutes，Seconds即可

fmt.Println(d.Hours())
package main
import (
    "fmt"
    "time"
)
func main(){
    d,err := time.ParseDuration("3h2m5s")
    fmt.Println(err,d)
    fmt.Println(d.Hours())
    fmt.Println(d.Minutes())
    fmt.Println(d.Seconds())
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run time5.go
<nil> 3h2m5s
3.0347222222222223
182.08333333333334
10925

12.md5

crypto/md5的计算hash，在使用md5.sum的时候需要传入一个字节，如果传入的是字符串，需要转换下，而后计算hash结果，转换后是byte类型的数组，而后将数组转换成一个16进制

  • 示例

计算mark的md5值

func main(){
    md := md5.Sum([]byte("mark"))
    fmt.Println(md)
}

打印

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run md5.go
[234 130 65 12 122 153 145 129 107 94 238 235 225 149 226 10]
  • 转换16进制

转换成16进制，使用fmt.Printf("%x",md)即可，但是这里是16进制的int类型，这里的%x百分号小x是小写

func main(){
    md := md5.Sum([]byte("mark"))
    fmt.Printf("%x",md)
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run md5.go
ea82410c7a9991816b5eeeebe195e20a
  • 转换16进制字符串

如果要转换成字符串，就使用fmt.Sprintf或者hex.EncodeToString进行转换。要使用hex.EncodeToString就需要导入包

import "encoding/hex"

Sprintf转换字符串，这里的%X将会转换成大写

    md := md5.Sum([]byte("mark"))
    x := fmt.Sprintf("%X",md)
    fmt.Println(x)

hex.EncodeToString转换字符串

    fmt.Println(hex.EncodeToString(md[:]))

代码块

package main
import (
    "fmt"
    "crypto/md5"
    "encoding/hex"
)
func main(){
    md := md5.Sum([]byte("mark"))
    fmt.Printf("%xn",md)
    fmt.Printf("%Tn",md)
 
    x := fmt.Sprintf("%X",md)
    fmt.Println(hex.EncodeToString(md[:]))
    fmt.Println(x)
    fmt.Printf("%T",x)
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run md5.go
ea82410c7a9991816b5eeeebe195e20a
[16]uint8
ea82410c7a9991816b5eeeebe195e20a
EA82410C7A9991816B5EEEEBE195E20A
string

12.1md5.New批量计算

通常值比较小直接就可以进行计算，如果值比较大，就可以使用md5.New一个对象进行批量计算，但是计算的结果和一次计算也是一样的。

  • 示例

定义一个m的md5.New

m := md5.New()

而后通过m.Write批量计算

m.Write([]byte("m"))
m.Write([]byte("a"))
m.Write([]byte("r"))
m.Write([]byte("k"))

而后通过sum计算，但是这里sum传递一个nil即可，因为这里没有值

fmt.Printf("%xn",m.Sum(nil))

代码块

[root@linuxea.com /opt/Golang/work4/stdpkg]# cat md52.go
package main
import (
    "fmt"
    "crypto/md5"
)
func main(){
    m := md5.New()
    m.Write([]byte("m"))
    m.Write([]byte("a"))
    m.Write([]byte("r"))
    m.Write([]byte("k"))
 
    fmt.Printf("%xn",m.Sum(nil))
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run md52.go 
ea82410c7a9991816b5eeeebe195e20a

13.base64

使用base64，需要导入"encoding/base64"，转换成string类型，加上EncodeToString

base64编码和解码都较为简单

  • 编码示例
package main
import (
    "encoding/base64"
    "fmt"
)
func main(){
    e :=  base64.StdEncoding.EncodeToString([]byte("mark"))
    fmt.Println(e)
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run base64.go
bWFyaw==
  • 解码示例

解码使用base64.StdEncoding.DecodeString，会返回两个返回值，这里使用bytes和err接收

package main
import (
    "encoding/base64"
    "fmt"
)
func main(){
    e :=  base64.StdEncoding.EncodeToString([]byte("mark"))
    fmt.Println(e)
    bytes,err := base64.StdEncoding.DecodeString(e)
    fmt.Println(string(bytes),err)
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run base644.go
bWFyaw==
mark <nil>

除了这些还有URLEncoding,RawURLEncoding,RawEncoding

14.日志[log]

log模块，首先要导入log模块

  • log示例
package main
import (
    "log"
)
func main(){
    log.Printf("[info] %s","susu")
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run log.go
2019/10/03 15:47:13 [info] susu
  • log和Panic示例

Panicf会答应日志并触发一个Panicf

package main
import (
    "log"
)
func main(){
    log.Printf("[info] %s","susu")
 
    log.Panicf("[Panicf] %s","error")
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run log.go
2019/10/03 15:55:23 [info] susu
2019/10/03 15:55:23 [Panicf] error
panic: [Panicf] error
 
goroutine 1 [running]:
log.Panicf(0x4c673f, 0xb, 0xc000043f78, 0x1, 0x1)
    /usr/local/go/src/log/log.go:340 +0xc0
main.main()
    /opt/Golang/work4/stdpkg/log.go:8 +0xcb
exit status 2
  • log.Fatalf示例

Fatalf在打印日志后也会退出

package main
import (
    "log"
)
func main(){
    log.Printf("[info] %s","susu")
 
    //log.Panicf("[Panicf] %s","error")
 
    log.Fatalf("[Fatalf] %s","Fatalf")
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run log.go
2019/10/03 16:00:27 [info] susu
2019/10/03 16:00:27 [Fatalf] Fatalf
exit status 1
  • log.SetPrefix示例，日志加前缀

日志加前缀[SetPrefix-]，如下:

log.SetPrefix("SetPrefix-")

将这段放在哪里，后面的日志中就会有这个前缀，

package main
import (
    "log"
)
func main(){
    log.Printf("[info] %s","susu")
    log.SetPrefix("SetPrefix-")
    log.Fatalf("[Fatalf] %s","Fatalf")
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run log.go
2019/10/03 16:34:05 [info] susu
SetPrefix-2019/10/03 16:34:05 [Fatalf] Fatalf
exit status 1
  • 日志加上文件名

log.SetFlags(log.Flags() | log.Lshortfile )，Lshortfile打印的是文件名i

package main
import (
    "log"
)
func main(){
    log.Printf("[info] %s","susu")
    log.SetPrefix("SetPrefix-")
    log.SetFlags(log.Flags() | log.Lshortfile )
    log.Fatalf("[Fatalf] %s","Fatalf")
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run log.go 
2019/10/03 17:13:19 [info] susu
SetPrefix-2019/10/03 17:13:19 log.go:14: [Fatalf] Fatalf
exit status 1

log.SetFlags(log.Flags() | log.Llongfile)，Llongfile打印的是文件全路径

package main
import (
    "log"
)
func main(){
    log.Printf("[info] %s","susu")
 
    log.SetPrefix("SetPrefix-")
 
    log.SetFlags(log.Flags() | log.Llongfile)
 
    log.Fatalf("[Fatalf] %s","Fatalf")
}

运行

[root@linuxea.com /opt/Golang/work4/stdpkg]# go run log.go
2019/10/03 17:14:19 [info] susu
SetPrefix-2019/10/03 17:14:19 /opt/Golang/work4/stdpkg/log.go:14: [Fatalf] Fatalf
exit status 1