《Go语言四十二章经》第三十二章 fmt包与日志log包
32.1 fmt包格式化I/O
上一章我们有提到fmt格式化I/O，这一章我们就详细来说说。在fmt包，有关格式化输入输出的方法就两大类：Scan 和 Print ，分别在scan.go 和 print.go 文件中。
print.go文件中定义了如下函数：
func Printf(format string, a ...interface{}) (n int, err error)
func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)
func Sprintf(format string, a ...interface{}) string
func Print(a ...interface{}) (n int, err error)
func Fprint(w io.Writer, a ...interface{}) (n int, err error)
func Sprint(a ...interface{}) string
func Println(a ...interface{}) (n int, err error)
func Fprintln(w io.Writer, a ...interface{}) (n int, err error)
func Sprintln(a ...interface{}) string
这9个函数，按照两个维度来说明，基本上可以说明白了。当然这两个维度是我个人为了记忆而分，并不是官方的说法。
一：如果把"Print"理解为核心关键字，那么后面跟的后缀有"f"和"ln"以及""，着重的是输出内容的最终结果；
如果后缀是"f", 则指定了format 如果后缀是"ln", 则有换行符
Println、Fprintln、Sprintln 输出内容时会加上换行符；
Print、Fprint、Sprint 输出内容时不加上换行符；
Printf、Fprintf、Sprintf 按照指定格式化文本输出内容。
二：如果把"Print"理解为核心关键字，那么前面的前缀有"F"和"S"以及""，着重的是输出内容的目标（终端）；
如果前缀是"F", 则指定了io.Writer 如果前缀是"S", 则是输出到字符串
Print、Printf、Println 输出内容到标准输出os.Stdout；
Fprint、Fprintf、Fprintln 输出内容到指定的io.Writer；
Sprint、Sprintf、Sprintln 输出内容到字符串。
scan.go文件中定义了如下函数：
func Scanf(format string, a ...interface{}) (n int, err error)
func Fscanf(r io.Reader, format string, a ...interface{}) (n int, err error)
func Sscanf(str string, format string, a ...interface{}) (n int, err error)
func Scan(a ...interface{}) (n int, err error)
func Fscan(r io.Reader, a ...interface{}) (n int, err error)
func Sscan(str string, a ...interface{}) (n int, err error)
func Scanln(a ...interface{}) (n int, err error)
func Fscanln(r io.Reader, a ...interface{}) (n int, err error)
func Sscanln(str string, a ...interface{}) (n int, err error)
这9个函数可以扫描格式化文本以生成值。同样也可以按照两个维度来说明。
一：如果把"Scan"理解为核心关键字，那么后面跟的后缀有"f"和"ln"以及""，着重的是输入内容的结果；
如果后缀是"f", 则指定了format 如果后缀是"ln", 则有换行符
Scanln、Fscanln、Sscanln 读取到换行时停止，并要求一次提供一行所有条目；
Scan、Fscan、Sscan 读取内容时不关注换行；
Scanf、Fscanf、Sscanf 根据格式化文本读取。
二：如果把"Scan"理解为核心关键字，那么前面的前缀有"F"和"S"以及""，着重的是输入内容的来源（终端）；
如果前缀是"F", 则指定了io.Reader 如果前缀是"S", 则是从字符串读取
Scan、Scanf、Scanln 从标准输入os.Stdin读取文本；
Fscan、Fscanf、Fscanln 从指定的io.Reader接口读取文本；
Sscan、Sscanf、Sscanln 从一个参数字符串读取文本。
32.2 格式化verb应用
在应用上，我们主要讲讲格式化verb ，fmt包中格式化的主要功能函数都在format.go文件中。
我们先来了解下有哪些verb：
| 符号 | 含义 |
|---|---|
| 通用： | |
| %v | 值的默认格式 表示。当输出结构体时，扩展标志（%+v）会添加字段名 |
| %#v | 值的Go语法表示 |
| %T | 值的类型的Go语法表示 |
| %% | 百分号 |
| 符号 | 含义 |
|---|---|
| 布尔值： | |
| %t | 单词true或false |
| 符号 | 含义 |
|---|---|
| 整数： | |
| %b | 表示为二进制 |
| %c | 该值对应的unicode码值 |
| %d | 表示为十进制 |
| %o | 表示为八进制 |
| %q | 该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示 |
| %x | 表示为十六进制，使用a-f |
| %X | 表示为十六进制，使用A-F |
| %U | 表示为Unicode格式：U+1234，等价于"U+%04X" |
| 符号 | 含义 |
|---|---|
| 浮点数、复数的两个组分： | |
| %b | 无小数部分、二进制指数的科学计数法，如-123456p-78；参见strconv.FormatFloat |
| %e | 科学计数法，如-1234.456e+78 |
| %E | 科学计数法，如-1234.456E+78 |
| %f | 有小数部分但无指数部分，如123.456 |
| %F | 等价于%f |
| %g | 根据实际情况采用%e或%f格式（以获得更简洁、准确的输出） |
| %G | 根据实际情况采用%E或%F格式（以获得更简洁、准确的输出） |
| 符号 | 含义 |
|---|---|
| 字符串和[]byte： | |
| %s | 直接输出字符串或者[]byte |
| %q | 该值对应的双引号括起来的Go语法字符串字面值，必要时会采用安全的转义表示 |
| %x | 每个字节用两字符十六进制数表示（使用a-f） |
| %X | 每个字节用两字符十六进制数表示（使用A-F） |
| 符号 | 含义 |
|---|---|
| 指针： | |
| %p | 表示为十六进制， 并加上前导的0x |
宽度通过一个紧跟在百分号后面的十进制数指定，如果未指定宽度，则表示值时除必需之外不作填充。精度通过（可能有的）宽度后跟点号后跟的十进制数指定。如果未指定精度，会使用默认精度；如果点号后没有跟数字，表示精度为0。举例如下：
| 符号 | 含义 |
|---|---|
| %f | 默认宽度，默认精度 |
| %9f | 宽度9，默认精度 |
| %.2f | 默认宽度，精度2 |
| %9.2f | 宽度9，精度2 |
| %9.f | 宽度9，精度0 |
对于整数，宽度和精度都设置输出总长度。采用精度时表示右对齐并用0填充，而宽度默认表示用空格填充。
对于浮点数，宽度设置输出总长度；精度设置小数部分长度（如果有的话），除了%g/%G，此时精度设置总的数字个数。例如，对数字123.45，格式%6.2f 输出123.45；格式%.4g输出123.5。%e和%f的默认精度是6，%g的默认精度是可以将该值区分出来需要的最小数字个数。
对复数，宽度和精度会分别用于实部和虚部，结果用小括号包裹。因此%f用于1.2+3.4i输出(1.200000+3.400000i)。
其它flag：
| 符号 | 含义 |
|---|---|
| + | 总是输出数值的正负号；对%q（%+q）会生成全部是ASCII字符的输出（通过转义）； |
| - | 在输出右边填充空白而不是默认的左边（即从默认的右对齐切换为左对齐）； |
| # | 切换格式：八进制数前加0（%#o），十六进制数前加0x（%#x）或0X（%#X），指针去掉前面的0x（%#p）； 对%q（%#q），如果strconv.CanBackquote返回真会输出反引号括起来的未转义字符串； 对%U（%#U），如果字符是可打印的，会在输出Unicode格式、空格、单引号括起来的Go字面值； |
| ' ' | 对数值，正数前加空格而负数前加负号；对字符串采用%x或%X时（% x或% X）会给各打印的字节之间加空格； |
| 0 | 使用0而不是空格填充，对于数值类型会把填充的0放在正负号后面； |
verb会忽略不支持的旗标（flag）。
下面我们用一个程序来演示下：
package main
import (
"fmt"
"os"
)
type User struct {
name string
age int
}
var valF float64 = 32.9983
var valI int = 89
var valS string = "Go is an open source programming language that makes it easy to build simple, reliable, and efficient software."
var valB bool = true
func main() {
p := User{"John", 28}
fmt.Printf("Printf struct %%v : %v\n", p)
fmt.Printf("Printf struct %%+v : %+v\n", p)
fmt.Printf("Printf struct %%#v : %#v\n", p)
fmt.Printf("Printf struct %%T : %T\n", p)
fmt.Printf("Printf struct %%p : %p\n", &p)
fmt.Printf("Printf float64 %%v : %v\n", valF)
fmt.Printf("Printf float64 %%+v : %+v\n", valF)
fmt.Printf("Printf float64 %%#v : %#v\n", valF)
fmt.Printf("Printf float64 %%T : %T\n", valF)
fmt.Printf("Printf float64 %%f : %f\n", valF)
fmt.Printf("Printf float64 %%4.3f : %4.3f\n", valF)
fmt.Printf("Printf float64 %%8.3f : %8.3f\n", valF)
fmt.Printf("Printf float64 %%-8.3f : %-8.3f\n", valF)
fmt.Printf("Printf float64 %%e : %e\n", valF)
fmt.Printf("Printf float64 %%E : %E\n", valF)
fmt.Printf("Printf int %%v : %v\n", valI)
fmt.Printf("Printf int %%+v : %+v\n", valI)
fmt.Printf("Printf int %%#v : %#v\n", valI)
fmt.Printf("Printf int %%T : %T\n", valI)
fmt.Printf("Printf int %%d : %d\n", valI)
fmt.Printf("Printf int %%8d : %8d\n", valI)
fmt.Printf("Printf int %%-8d : %-8d\n", valI)
fmt.Printf("Printf int %%b : %b\n", valI)
fmt.Printf("Printf int %%c : %c\n", valI)
fmt.Printf("Printf int %%o : %o\n", valI)
fmt.Printf("Printf int %%U : %U\n", valI)
fmt.Printf("Printf int %%q : %q\n", valI)
fmt.Printf("Printf int %%x : %x\n", valI)
fmt.Printf("Printf string %%v : %v\n", valS)
fmt.Printf("Printf string %%+v : %+v\n", valS)
fmt.Printf("Printf string %%#v : %#v\n", valS)
fmt.Printf("Printf string %%T : %T\n", valS)
fmt.Printf("Printf string %%x : %x\n", valS)
fmt.Printf("Printf string %%X : %X\n", valS)
fmt.Printf("Printf string %%s : %s\n", valS)
fmt.Printf("Printf string %%200s : %200s\n", valS)
fmt.Printf("Printf string %%-200s : %-200s\n", valS)
fmt.Printf("Printf string %%q : %q\n", valS)
fmt.Printf("Printf bool %%v : %v\n", valB)
fmt.Printf("Printf bool %%+v : %+v\n", valB)
fmt.Printf("Printf bool %%#v : %#v\n", valB)
fmt.Printf("Printf bool %%T : %T\n", valB)
fmt.Printf("Printf bool %%t : %t\n", valB)
s := fmt.Sprintf("a %s", "string")
fmt.Println(s)
fmt.Fprintf(os.Stderr, "an %s\n", "error")
}
程序输出：
Printf struct %v : {John 28}
Printf struct %+v : {name:John age:28}
Printf struct %#v : main.User{name:"John", age:28}
Printf struct %T : main.User
Printf struct %p : 0xc000048400
Printf float64 %v : 32.9983
Printf float64 %+v : 32.9983
Printf float64 %#v : 32.9983
Printf float64 %T : float64
Printf float64 %f : 32.998300
Printf float64 %4.3f : 32.998
Printf float64 %8.3f : 32.998
Printf float64 %-8.3f : 32.998
Printf float64 %e : 3.299830e+01
Printf float64 %E : 3.299830E+01
Printf int %v : 89
Printf int %+v : 89
Printf int %#v : 89
Printf int %T : int
Printf int %d : 89
Printf int %8d : 89
Printf int %-8d : 89
Printf int %b : 1011001
Printf int %c : Y
Printf int %o : 131
Printf int %U : U+0059
Printf int %q : 'Y'
Printf int %x : 59
Printf string %v : Go is an open source programming language that makes it easy to build simple, reliable, and efficient software.
Printf string %+v : Go is an open source programming language that makes it easy to build simple, reliable, and efficient software.
Printf string %#v : "Go is an open source programming language that makes it easy to build simple, reliable, and efficient software."
Printf string %T : string
Printf string %x : 476f20697320616e206f70656e20736f757263652070726f6772616d6d696e67206c616e67756167652074686174206d616b6573206974206561737920746f206275696c642073696d706c652c202072656c6961626c652c2020616e6420656666696369656e7420736f6674776172652e
Printf string %X : 476F20697320616E206F70656E20736F757263652070726F6772616D6D696E67206C616E67756167652074686174206D616B6573206974206561737920746F206275696C642073696D706C652C202072656C6961626C652C2020616E6420656666696369656E7420736F6674776172652E
Printf string %s : Go is an open source programming language that makes it easy to build simple, reliable, and efficient software.
Printf string %200s : Go is an open source programming language that makes it easy to build simple, reliable, and efficient software.
Printf string %-200s : Go is an open source programming language that makes it easy to build simple, reliable, and efficient software.
Printf string %q : "Go is an open source programming language that makes it easy to build simple, reliable, and efficient software."
Printf bool %v : true
Printf bool %+v : true
Printf bool %#v : true
Printf bool %T : bool
Printf bool %t : true
a string
an error
我们主要通过fmt.Printf来理解这些flag 的含义，这对我们今后的开发有较强的实际作用。至于其他函数，我就不一一举例，有兴趣可以进一步研究。
32.3 日志log包
Go语言标准包中有日志功能，对应在log包中。主要结构体是：
type Logger struct {
mu sync.Mutex // ensures atomic writes; protects the following fields
prefix string // prefix to write at beginning of each line
flag int // properties
out io.Writer // destination for output
buf []byte // for accumulating text to write
}
func New(out io.Writer, prefix string, flag int) *Logger {
return &Logger{out: out, prefix: prefix, flag: flag}
}
在log包中通过New函数得到一个Logger结构体指针，这个函数的三个参数分别是out，prefix，flag。pfefix可以指定日志信息的前缀，比如“[Debug]”等，一般根据实际需要定义，可根据情况随时通过SetPrefix()函数修改。flag是日志的前缀信息（在prefix之后），包括可配置的时间格式等，一般默认为LstdFlags就可以了。out是日志输出的目标，只要实现了io.Writer接口就可以作为out，log包中默认指定stderr为out，所以log包默认都是输出到标准设备。
var std = New(os.Stderr, "", LstdFlags)
func Println(v ...interface{}) {
std.Output(2, fmt.Sprintln(v...))
}
也可以按照上面的思路，把日志信息写入到文件。
logfile, err := os.OpenFile("my.log", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
if err != nil {
log.Fatalln("fail to create log file!")
}
defer logfile.Close()
l:=log.New(logfile, "", log.LstdFlags)
l.Println("test")
num:=5
l.Println("test %d",num)
因为logfile已经实现了io.Writer，所以这里用做out，日志信息被写入到文件。log的方法Printf()可以把信息按照一定格式来写入。另外，在写入日志信息时都有加入并发锁，这是mu sync.Mutex的作用。
最后，log包的日志功能基本上能满足一般的开发需要，但相对还是比较简单，缺少日志分层控制，缺少对json格式的支持等， 所以如果有需要灵活定制或大并发、大吞吐量的日志开发需求，建议考虑使用其他方法或途径来实现。
本书《Go语言四十二章经》内容在github上同步地址：https://github.com/ffhelicopter/Go42
虽然本书中例子都经过实际运行，但难免出现错误和不足之处，烦请您指出；如有建议也欢迎交流。