《Go语言四十二章经》第三十二章 fmt包

作者：李骁

32.1 fmt包格式化I/O

上一章我们有提到fmt格式化I/O，这一章我们就详细来说说。在fmt包，有关格式化输入输出的方法就两大类：Scan 和 Print ，分别在scan.go 和 print.go 文件中。

print.go文件中定义了如下函数：

  1. func Printf(format string,  a ...interface{}) (n int,  err error)
  2. func Fprintf(w io.Writer,  format string,  a ...interface{}) (n int,  err error)
  3. func Sprintf(format string,  a ...interface{}) string
  5. func Print(a ...interface{}) (n int,  err error)
  6. func Fprint(w io.Writer,  a ...interface{}) (n int,  err error)
  7. func Sprint(a ...interface{}) string
  9. func Println(a ...interface{}) (n int,  err error)
  10. func Fprintln(w io.Writer,  a ...interface{}) (n int,  err error)
  11. func Sprintln(a ...interface{}) string

这9个函数，按照两个维度来说明，基本上可以说明白了。当然这两个维度是我个人为了记忆而分，并不是官方的说法。

一：如果把”Print”理解为核心关键字，那么后面跟的后缀有”f”和”ln”以及””，着重的是内容输出的结果；

如果后缀是”f”, 则指定了format
如果后缀是”ln”, 则有换行符

  1. Println、Fprintln、Sprintln 输出内容时会加上换行符；
  2. Print、Fprint、Sprint        输出内容时不加上换行符；
  3. Printf、Fprintf、Sprintf    按照指定格式化文本输出内容。

二：如果把”Print”理解为核心关键字，那么前面的前缀有”F”和”S”以及””，着重的是输出内容的来源；

如果前缀是”F”, 则指定了io.Writer
如果前缀是”S”, 则是输出到字符串

  1. Print、Printf、Println      输出内容到标准输出os.Stdout；
  2. Fprint、Fprintf、Fprintln  输出内容到指定的io.Writer；
  3. Sprint、Sprintf、Sprintln  输出内容到字符串。

scan.go文件中定义了如下函数：

  1. func Scanf(format string,  a ...interface{}) (n int,  err error)
  2. func Fscanf(r io.Reader,  format string,  a ...interface{}) (n int,  err error)
  3. func Sscanf(str string,  format string,  a ...interface{}) (n int,  err error)
  5. func Scan(a ...interface{}) (n int,  err error)
  6. func Fscan(r io.Reader,  a ...interface{}) (n int,  err error)
  7. func Sscan(str string,  a ...interface{}) (n int,  err error)
  9. func Scanln(a ...interface{}) (n int,  err error)
  10. func Fscanln(r io.Reader,  a ...interface{}) (n int,  err error)
  11. func Sscanln(str string,  a ...interface{}) (n int,  err error)

这9个函数可以扫描格式化文本以生成值。同样也可以按照两个维度来说明。

一：如果把”Scan”理解为核心关键字，那么后面跟的后缀有”f”和”ln”以及””，着重的是输入内容的结果；

如果后缀是”f”, 则指定了format
如果后缀是”ln”, 则有换行符

  1. Scanln、Fscanln、Sscanln   读取到换行时停止，并要求一次提供一行所有条目；
  2. Scan、Fscan、Sscan          读取内容时不关注换行；
  3. Scanf、Fscanf、Sscanf      根据格式化文本读取。

二：如果把”Scan”理解为核心关键字，那么前面的前缀有”F”和”S”以及””，着重的是输入内容的来源；

如果前缀是”F”, 则指定了io.Reader
如果前缀是”S”, 则是从字符串读取

  1. Scan、Scanf、Scanln     从标准输入os.Stdin读取文本；
  2. Fscan、Fscanf、Fscanln  从指定的io.Reader接口读取文本；
  3. Sscan、Sscanf、Sscanln  从一个参数字符串读取文本。

32.2 格式化verb应用

在应用上，我们主要讲讲格式化verb ，fmt包中格式化的主要功能函数都在format.go文件中。

我们先来了解下有哪些verb：

  1. 通用：
  2. %v    值的默认格式表示。当输出结构体时，扩展标志（%+v）会添加字段名
  3. %#v    值的Go语法表示
  4. %T    值的类型的Go语法表示
  5. %%    百分号
  7. 布尔值：
  8. %t    单词true或false
  10. 整数：
  11. %b    表示为二进制
  12. %c    该值对应的unicode码值
  13. %d    表示为十进制
  14. %o    表示为八进制
  15. %q    该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示
  16. %x    表示为十六进制，使用a-f
  17. %X    表示为十六进制，使用A-F
  18. %U    表示为Unicode格式：U+1234，等价于"U+%04X"
  20. 浮点数、复数的两个组分：
  21. %b    无小数部分、二进制指数的科学计数法，如-123456p-78；参见strconv.FormatFloat 
  22. %e    科学计数法，如-1234.456e+78 
  23. %E    科学计数法，如-1234.456E+78 
  24. %f    有小数部分    但无指数部分，如123.456 
  25. %F    等价于%f 
  26. %g    根据实际情况采用%e或%f格式（以获得    更简洁、准确的输出）
  27. %G    根据实际情况采用%E或%F格式（以获得更简洁、准确的输出）
  29. 字符串和[]byte：
  30. %s    直接输出字符串或者[]byte
  31. %q    该值对应的双引号括起来的Go语法字符串字面值，必要时会采用安全的转义表示
  32. %x    每个字节用两字符十六进制数表示（使用a-f）
  33. %X    每个字节用两字符十六进制数表示（使用A-F）
  35. 指针：
  36. %p    表示为十六进制，并加上前导的0x
  38. 宽度通过一个紧跟在百分号后面的十进制数指定，如果未指定宽度，则表示值时除必需之外不作填充。精度通过（可能有的）宽度后跟点号后跟的十进制数指定。如果未指定精度，会使用默认精度；如果点号后没有跟数字，表示精度为0。举例如下：
  40. %f:    默认宽度，默认精度
  41. %9f   宽度9，默认精度
  42. %.2f   默认宽度，精度2 
  43. %9.2f  宽度9，精度2
  44. %9.f   宽度9，精度0
  46. 对于整数，宽度和精度都设置输出总长度。采用精度时表示右对齐并用0填充，而宽度默认表示用空格填充。
  48. 对于浮点数，宽度设置输出总长度；精度设置小数部分长度（如果有的话），除了%g/%G，此时精度设置总的数字个数。例如，对数字123.45，格式%6.2f 输出123.45；格式%.4g输出123.5。%e和%f的默认精度是6，%g的默认精度是可以将该值区分出来需要的最小数字个数。
  50. 对复数，宽度和精度会分别用于实部和虚部，结果用小括号包裹。因此%f用于1.2+3.4i输出(1.200000+3.400000i)。
  52. 其它flag：
  54. +    总是输出数值的正负号；对%q（%+q）会生成全部是ASCII字符的输出（通过转义）；
  55. -    在输出右边填充空白而不是默认的左边（即从默认的右对齐切换为左对齐）；
  56. #    切换格式：
  57.       八进制数前加0（%#o），十六进制数前加0x（%#x）或0X（%#X），指针去掉前面的    0x（%#p）；
  58.      对%q（%#q），如果strconv.CanBackquote返回真会输出反引号括起来的未转义字符串；
  59.      对%U（%#U），如果字符是可打印的，会在输出Unicode格式、空格、单引号括起来    的go字面值；
  60. ' '    对数值，正数前加空格而负数前加负号；
  61.       对字符串采用%x或%X时（% x或% X）会给各打印的字节之间加空格；
  62. 0    使用0而不是空格填充，对于数值类型会把填充的0放在正负号后面；

verb会忽略不支持的flag。

下面我们用一个程序来演示下：

  1. package main
  3. import (
  4.     "fmt"
  5.     "os"
  6. )
  8. type User struct {
  9.     name string
  10.     age  int
  11. }
  13. var valF float64 = 32.9983
  14. var valI int = 89
  15. var valS string = "Go is an open source programming language that makes it easy to build simple,  reliable,  and efficient software."
  16. var valB bool = true
  18. func main() {
  20.     p := User{"John",  28}
  22.     fmt.Printf("Printf struct %%v : %v\n",  p)
  23.     fmt.Printf("Printf struct %%+v : %+v\n",  p)
  24.     fmt.Printf("Printf struct %%#v : %#v\n",  p)
  25.     fmt.Printf("Printf struct %%T : %T\n",  p)
  27.     fmt.Printf("Printf struct %%p : %p\n",  &p)
  29.     fmt.Printf("Printf float64 %%v : %v\n",  valF)
  30.     fmt.Printf("Printf float64 %%+v : %+v\n",  valF)
  31.     fmt.Printf("Printf float64 %%#v : %#v\n",  valF)
  32.     fmt.Printf("Printf float64 %%T : %T\n",  valF)
  33.     fmt.Printf("Printf float64 %%f : %f\n",  valF)
  34.     fmt.Printf("Printf float64 %%4.3f : %4.3f\n",  valF)
  35.     fmt.Printf("Printf float64 %%8.3f : %8.3f\n",  valF)
  36.     fmt.Printf("Printf float64 %%-8.3f : %-8.3f\n",  valF)
  37.     fmt.Printf("Printf float64 %%e : %e\n",  valF)
  38.     fmt.Printf("Printf float64 %%E : %E\n",  valF)
  40.     fmt.Printf("Printf int %%v : %v\n",  valI)
  41.     fmt.Printf("Printf int %%+v : %+v\n",  valI)
  42.     fmt.Printf("Printf int %%#v : %#v\n",  valI)
  43.     fmt.Printf("Printf int %%T : %T\n",  valI)
  44.     fmt.Printf("Printf int %%d : %d\n",  valI)
  45.     fmt.Printf("Printf int %%8d : %8d\n",  valI)
  46.     fmt.Printf("Printf int %%-8d : %-8d\n",  valI)
  47.     fmt.Printf("Printf int %%b : %b\n",  valI)
  48.     fmt.Printf("Printf int %%c : %c\n",  valI)
  49.     fmt.Printf("Printf int %%o : %o\n",  valI)
  50.     fmt.Printf("Printf int %%U : %U\n",  valI)
  51.     fmt.Printf("Printf int %%q : %q\n",  valI)
  52.     fmt.Printf("Printf int %%x : %x\n",  valI)
  54.     fmt.Printf("Printf string %%v : %v\n",  valS)
  55.     fmt.Printf("Printf string %%+v : %+v\n",  valS)
  56.     fmt.Printf("Printf string %%#v : %#v\n",  valS)
  57.     fmt.Printf("Printf string %%T : %T\n",  valS)
  58.     fmt.Printf("Printf string %%x : %x\n",  valS)
  59.     fmt.Printf("Printf string %%X : %X\n",  valS)
  60.     fmt.Printf("Printf string %%s : %s\n",  valS)
  61.     fmt.Printf("Printf string %%200s : %200s\n",  valS)
  62.     fmt.Printf("Printf string %%-200s : %-200s\n",  valS)
  63.     fmt.Printf("Printf string %%q : %q\n",  valS)
  65.     fmt.Printf("Printf bool %%v : %v\n",  valB)
  66.     fmt.Printf("Printf bool %%+v : %+v\n",  valB)
  67.     fmt.Printf("Printf bool %%#v : %#v\n",  valB)
  68.     fmt.Printf("Printf bool %%T : %T\n",  valB)
  69.     fmt.Printf("Printf bool %%t : %t\n",  valB)
  71.     s := fmt.Sprintf("a %s",  "string")
  72.     fmt.Println(s)
  74.     fmt.Fprintf(os.Stderr,  "an %s\n",  "error")
  75. }

我们主要通过fmt.Printf来理解这些flag 的含义，这对我们今后的开发有较强的实际作用。至于其他函数，我就不一一举例，有兴趣可以进一步研究。