09-golang格式化输出

文章目录

概念

在 Golang 中，格式化的输入与输出，都需要使用到格式化占位符。比如获取用户输入的数据的函数 fmt.Scanf() ，格式化输出的函数 fmt.Printf()。

Go 语言的格式化占位符大概可分为普通占位符、布尔占位符、整数占位符、浮点数 和复数占位符、字符串 与 字节切片 占位符、指针占位符以及其它标记等。

哪些函数支持

fmt包实现了类似C语言printf和scanf的格式化I/O。主要分为向外输出内容和获取输入内容两大部分。

在 Go 语言中，标准包 fmt 有好多格式化的工具函数，函数名末尾通常以 f 结尾，列举如下：

fmt.Printf 格式化字符串并打印到终端（标准输出）。
fmt.Sprintf 格式化字符串并返回。
fmt.Sscanf 从字符串中解析占位符的对应位置数据。
fmt.Fscanf 从 io.Reader 类型中读取数据并解析占位符的对应位置数据，用于读取文件、终端（标准输入）。
fmt.Fprintf 将格式化的字符串数据输出到 io.Writer 类型中，用于输出到文件。
fmt.Errorf 格式化方式创建一个错误类型消息。

Print

Print系列函数会将内容输出到系统的标准输出，区别如下

Print函数：直接输出内容，但不换行。
Printf函数：支持格式化输出字符串。
Println函数：输出内容，采用空格间隔，并换行。

示例如下

package main
import (
	"fmt"
)
func main() {
    
    
	fmt.Print("在终端打印信息。")
	name := "咸蛋黄派"
	fmt.Printf("我是: %s\n", name)
	fmt.Println("在终端打印第一条信息","在终端打印第二条信息")
}

输出结果

在终端打印信息。我是: 咸蛋黄派
在终端打印第一条信息 在终端打印第二条信息

Sprint

Sprint系列函数会把传入的数据生成并返回一个字符串，不会在终端显示。

Sprint函数：用默认的类型格式将传入的参数返回为字符串，不会在终端显示；
Sprintf函数：用占位符将传入的变量返回为字符串，不会在终端显示；
Sprintln函数：用默认的类型格式将传入的参数返回为字符串，字符串和变量之间用空格间隔，有回车，不会在终端显示；

示例如下

package main

import (
	"fmt"
)

func main() {
    
    
	s1 := fmt.Sprint("Sprint没换行")
	name := "咸蛋黄派"
	age := 18
	s2 := fmt.Sprintf("name:%s,age:%d\n", name, age)
	const num1, num2, num3 = "5", "10", "15"
	s3 := fmt.Sprintln(num1, num2, num3)
	fmt.Print(s1, s2, s3)
}

输出结果

Sprint没换行name:咸蛋黄派,age:18
5 10 15

总结：

Println和Sprintln 输出用用空格间隔，有回车；

Printf和Sprintf 支持占位符；

f：支持占位符， ln：不支持占位符，空格间隔 S：不在终端显示

这块没有重点展开讲解各个函数，只是简单罗列下，如果还不明白自行查一下，也可以问我。

下来看看本篇的重点…

占位符使用

占位符需要使用 % 符号表示，简单展示一个。

s := fmt.Sprintf("%s真帅", "咸蛋黄派")
fmt.Println(s)

// 输出
咸蛋黄派真帅

%s 标示字符串，将"咸蛋黄派"字符串填充到%s 位置。下来看看到底有哪些占位符？

常见占位符

%T 类型占位符
%v 值占位符
%d 整数占位符
%f 浮点占位符
%c 字符占位符
%s 字符串的占位符

占位符类型

结构体

首先创建一个下面实例需要使用到的结构体，具体概念这里不展开讲述，后面会详细说。

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。可以通过tys快速生成代码片段

package main

import "fmt"

type Human struct {
    
    
	Name string
}

func main() {
    
    
	people := Human{
    
    Name: "xiandanhuang"}
	fmt.Printf("people: %v\n", people)
}

// 输出结果
people: {
    
    xiandanhuang}

通用占位符

占位符	说明	举例
%v	获取数据的值	Printf(“%v”, people)
%+v	获取数据的值，如果结构体，会携带字段名	Printf(“%+v”, people)
%#v	获取数据的值，如果是结构体，会携带结构体名和字段名	Printf(“#v”, people)
%T	获取数据类型	Printf(“%T”, people)
%%	字面上的一个百分号	Printf(“%%”)

示例如下

package main

import "fmt"

type Human struct {
    
    
	Name string
}

func main() {
    
    
	people := Human{
    
    Name: "xiandanhuang"}
	fmt.Printf("people: %v\n", people)        // 打印结构体的值
	fmt.Printf("people: %+v\n", people)       // 打印结构体的字段名+值
	fmt.Printf("people: %#v\n", people)       // 打印结构体名字值+结构体（字段名字+字段的值）
	fmt.Printf("people: %T\n", people)        // 打印类型
	fmt.Printf("%%")
}

输出结果

people: {
    
    xiandanhuang}
people: {
    
    Name:xiandanhuang}
people: main.Human{
    
    Name:"xiandanhuang"}
people: main.Human
%

布尔占位符

占位符	说明	举例
%t	true 或 false	Printf(“%t”, true)

示例如下

fmt.Printf("%t", true)
// 输出
true

整数占位符

占位符	说明	举例
%b	二进制表示	Printf(“%b”, 4)
%c	相应Unicode码点所表示的字符	Printf(“%c”, 0x82d7)
%d	十进制表示	Printf(“%d”, 0x12)
%o	八进制表示	Printf(“%o”, 10)
%q	单引号围绕的字符字面值，由Go语法安全地转义	Printf(“%q”, 0x4E2D)
%x	十六进制表示，字母形式为小写 a-f	Printf(“%x”, 13)
%X	十六进制表示，字母形式为大写 A-F	Printf(“%x”, 13)
%U	Unicode格式：U+1234，等同于 “U+%04X”	Printf(“%U”, 0x4E2D)

示例如下

%b：二进制

fmt.Printf("%b", 4)
// 输出
100

%c：Unicode 码转字符

fmt.Printf("%c", 0x82d7)
// 输出
苗

%d、%5d、%-5d、%05d：十进制整数表示

fmt.Printf("%d,%d,%d", 10, 010, 0x10)
// 输出三个数据： 10 十进制，010 八进制，0x10 十六进制
10,8,16

占位符还可以指定最小宽度，格式如下：

%5d：最小宽度为 5，右对齐，左边留白。

%-5d：左对齐，右边留白。

%05d：数字位数不足 5 位时，左边补零。

fmt.Printf("|%5d|%-5d|%05d|", 1, 1, 1)
// 输出
|    1|1    |00001|

%o、%#o：八进制表示

fmt.Printf("%o,%o,%o", 10, 010, 0x10)
// 输出
12,10,20

在很多开发语言中，0 打头的数字都表示八进制。通过 %#o 输出带 0 开头。

fmt.Printf("\n%#o\n", 10)
// 输出
012

%q：同 %c 类似，都是Unicode 码转字符，只是结果多了单引号。

fmt.Printf("%q", 0x82d7)
// 输出
'苗'

汉字对应表：http://www.chi2ko.com/tool/CJK.htm

%x、%#x：十六进制表示，字母形式为小写 a-f，%#x 输出带 0x 开头。

fmt.Printf("%x, %#x", 13, 13)
// 输出
d, 0xd

%X、%#X：十六进制表示，字母形式为小写 A-F，%#X 输出带 0X 开头。

fmt.Printf("%X, %#X", 13, 13)
// 输出
D, 0XD

%U、%#U

%U：转化为 Unicode 格式规范。

fmt.Printf("%U", 0x82d7)
// 输出
U+82D7

%#U：转化为 Unicode 格式并带上对应的字符。

fmt.Printf("%#U", 0x82d7)
// 输出
U+82D7 '苗'

浮点数和复数

占位符	说明	举例
%b	无小数部分的，指数为二的幂的科学计数法，与 strconv.FormatFloat 的 ‘b’ 转换格式一致。例如 -123456p-78
%e	科学计数法，例如 -1234.456e+78	Printf("%e”, 10.2)
%E	科学计数法，例如 -1234.456E+78	Printf("%e”, 10.2)
%f	有小数点而无指数，例如 123.456	Printf("%f”, 10.2)
%g	根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的0）	Printf("%g”, 10.20)
%G	根据情况选择 %E 或 %f 以产生更紧凑的（无末尾的0）	Printf("%G”, 10.20+2i)

示例如下

%b：浮点数转化为 2 的幂的科学计数法。

fmt.Printf("%b", 0.1)
// 输出
7205759403792794p-56

%e、%E：10 的幂的科学计数法。

fmt.Printf("%e", 10.2)
// 输出
1.020000e+01

fmt.Printf("%E", 10.2)
// 输出
1.020000E+01

区别：%e 与 %E 输出时的大小写之分。

%f、%.2f 等等：浮点数，%.2f 表示保留 2 位小数，%f 默认保留 6 位，%f 与 %F 等价。

fmt.Printf("%f", 10.2)
// 输出
10.200000

fmt.Printf("%.2f|%.2f", 10.232, 10.235)
// 输出
10.23|10.23

也可以加入最小宽度，如下：

%9.2f 宽度最小为 9，包含小数位在内，精度为 2。

%9.f 或 %9f 宽度最小为 9。

%g、%.3g：根据情况选择 %e 或 %f ，但末尾去除 0。

%f 情况如下：

fmt.Printf("%g|%g", 10.20, 1.200000+3.400000i)
// 输出
10.2|(1.2+3.4i)

%e 情况如下：

fmt.Printf("%g|%g", 2e2, 2E2)
// 输出
200|200

%.3g 表示的不是小数保留 3 位，而是只保留 3 个数字。

fmt.Printf("%.3g", 12.34)
// 输出
12.3

思考：官网中 %g 和 %G 是有区别的，但我测试下来是等价的，可能我的测试有问题，我给出官网文档，如下：

%g    %e for large exponents, %f otherwise. Precision is discussed below.
%G    %E for large exponents, %F otherwise

字符串与字节切片

占位符	说明	举例
%s	输出字符串表示（string类型或[]byte)	Printf("%s”, []byte("Go语言”))
%q	双引号围绕的字符串，由Go语法安全地转义	Printf("%q”, "Go语言”)
%x	十六进制，小写字母，每字节两个字符	Printf("%x”, "golang”)
%X	十六进制，大写字母，每字节两个字符	Printf("%X”, "golang”)

示例如下

%s：字符串或字节切片。

fmt.Printf("%s|%s", "咸蛋黄派", []byte("嘿嘿嘿"))
// 输出
咸蛋黄派|嘿嘿嘿

%q：有 Go 语言安全转义，双引号包裹。

fmt.Printf("%q", "咸蛋黄派")
// 输出
"咸蛋黄派"

%x、%X：十六进制，%x 小写字母 a - f，%X 大写字母 A - F。

fmt.Printf("%x|%X", "咸", "派")
// 输出
e88b97|E88B97

指针

占位符	说明	举例
%p	十六进制表示，前缀 0x	Printf("%p”, &people)

%p、%#p：地址，使用十六进制表示，%p 带 0x，%#p 不带。

num := 2
s := []int{
    
    1, 2}
fmt.Printf("%p|%p", &num, s)

// 输出
0xc00000a1d0|0xc00000a1e0

其它标记

占位符	说明	举例
+	总打印数值的正负号；对于%q（%+q）保证只输出ASCII编码的字符。	Printf("%+q”, "中文”) "\u4e2d\u6587”
-	在右侧而非左侧填充空格（左对齐该区域）
#	备用格式：为八进制添加前导 0（%#o）为十六进制添加前导 0x（%#x）或 0X（%#X），为 %p（%#p）去掉前导 0x；如果可能的话，%q（%#q）会打印原始（即反引号围绕的）字符串；如果是可打印字符，%U（%#U）会写出该字符的Unicode 编码形式（如字符 x 会被打印成 U+0078 ‘x’）	Printf("%#U”, ‘中’)
’ ‘	空格)为数值中省略的正负号留出空白（% d）	以十六进制（% x, % X）打印字符串或切片时，在字节之间用空格隔开
0	填充前导的0而非空格；对于数字，这会将填充移到正负号之后

+：打印数值的正负号，对于 %+q，只输出 ASCII 编码的字符，如果非 ASCII 编码，则转成 Unicode 编码输出。

fmt.Printf("%+d|%+d", 2, -2)
// 输出
+2|-2

fmt.Printf("%+q|%+q", "miao","苗")
// 输出
"miao"|"\u82d7"

-：在右侧填充空格，使用如 %-5d ，浮点%-9.2f 也支持。

fmt.Printf("%-5d|%5d", 2, -2)
// 输出
2    |   -2

#：添加前导符

为八进制添加前导 0，上面已举例。

为十六进制添加前导 0x 或 0X，上面已举例。

为 %#p去掉 0x。

%+q 打印字符串时使用反引号包裹。

fmt.Printf("%#q", "苗")
// 输出
`苗`

' ' 空格：为正负号留出空白位置。

fmt.Printf("|% d|", 2)
// 输出
| 2|

0：填充前导的 0，对于数字会移到正负号之后，非数字也可使用。

fmt.Printf("%05s", "a")
// 输出
0000a

fmt.Printf("%+05d", 1)
// 输出
+0001

精度截断字符串

给字符串使用精度，用来截断字符串。

fmt.Printf("%.2s", "咸蛋黄派")
// 输出
咸蛋

实例

type user struct {
    
    
	name string
}

func main() {
    
    
	u := user{
    
    "guo"}
	//Printf 格式化输出
	fmt.Printf("% + v\n", u)     //格式化输出结构
	fmt.Printf("%#v\n", u)       //输出值的 Go 语言表示方法
	fmt.Printf("%T\n", u)        //输出值的类型的 Go 语言表示
	fmt.Printf("%t\n", true)     //输出值的 true 或 false
	fmt.Printf("%b\n", 1024)     //二进制表示
	fmt.Printf("%c\n", 11111111) //数值对应的 Unicode 编码字符
	fmt.Printf("%d\n", 10)       //十进制表示
	fmt.Printf("%o\n", 8)        //八进制表示
	fmt.Printf("%q\n", 22)       //转化为十六进制并附上单引号
	fmt.Printf("%x\n", 1223)     //十六进制表示，用a-f表示
	fmt.Printf("%X\n", 1223)     //十六进制表示，用A-F表示
	fmt.Printf("%U\n", 1233)     //Unicode表示
	fmt.Printf("%b\n", 12.34)    //无小数部分，两位指数的科学计数法6946802425218990p-49
	fmt.Printf("%e\n", 12.345)   //科学计数法，e表示
	fmt.Printf("%E\n", 12.34455) //科学计数法，E表示
	fmt.Printf("%f\n", 12.3456)  //有小数部分，无指数部分
	fmt.Printf("%g\n", 12.3456)  //根据实际情况采用%e或%f输出
	fmt.Printf("%G\n", 12.3456)  //根据实际情况采用%E或%f输出
	fmt.Printf("%s\n", "wqdew")  //直接输出字符串或者[]byte
	fmt.Printf("%q\n", "dedede") //双引号括起来的字符串
	fmt.Printf("%x\n", "abczxc") //每个字节用两字节十六进制表示，a-f表示
	fmt.Printf("%X\n", "asdzxc") //每个字节用两字节十六进制表示，A-F表示
	fmt.Printf("%p\n", 0x123)    //0x开头的十六进制数表示
}