投稿
  1. 首页
  2. C

09-golang格式化输出

照片剪裁 • 2022-6-10 • C • 阅读 20

09-golang格式化输出,第1张

文章目录
    • 概念
    • 哪些函数支持
      • Print
      • Sprint
    • 占位符使用
    • 占位符类型
      • 结构体
      • 通用占位符
      • 布尔占位符
      • 整数占位符
      • 浮点数和复数
      • 字符串与字节切片
      • 指针
    • 其它标记
      • 精度截断字符串
    • 实例

概念

在 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
%
布尔占位符
占位符说明举例
%ttrue 或 falsePrintf(“%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-fPrintf(“%x”, 13)
%X十六进制表示，字母形式为大写 A-FPrintf(“%x”, 13)
%UUnicode格式：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+78Printf("%e”, 10.2)
%E科学计数法，例如 -1234.456E+78Printf("%e”, 10.2)
%f有小数点而无指数，例如 123.456Printf("%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十六进制表示，前缀 0xPrintf("%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开头的十六进制数表示
}

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/1295268.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
照片剪裁 照片剪裁 一级用户组
0 0
上一篇 2022-06-10
下一篇 2022-06-10

发表评论

登录后才能评论

评论列表（0条）

保存