Go 字符串格式
最后修改时间 2024 年 4 月 11 日
在本文中，我们将展示如何在 Golang 中格式化字符串。在 fmt 包中，我们找到了实现格式化 I/O 的函数。
为了在 Go 中格式化字符串，我们使用包括 fmt.Printf、fmt.Sprintf 或 fmt.Fscanf 在内的函数。
这些函数将格式字符串和参数列表作为参数。
%[flags][width][.precision]verb
格式字符串的语法如下。方括号 [] 中的选项是可选的。
末尾的动词定义了其相应参数的类型和解释。
- d - 十进制整数
- o - 八进制整数
- O - 带 0o 前缀的八进制整数
- b - 二进制整数
- x - 小写十六进制整数
- X - 大写十六进制整数
- f - 十进制浮点数，小写
- F - 十进制浮点数，大写
- e - 科学计数法（尾数/指数），小写
- E - 科学计数法（尾数/指数），大写
- g - %e 或 %f 的最短表示
- G - %E 或 %F 的最短表示
- c - 由相应 Unicode 码点表示的字符
- q - 带引号的字符
- U - Unicode 转义序列
- t - 单词 true 或 false
- s - 字符串
- v - 默认格式
- #v - Go 语法表示的值
- T - Go 语法表示的值的类型
- p - 指针地址
- % - 双 %% 打印单个 %
flags 是一组修改输出格式的字符。有效标志的集合取决于转换字符。width 是一个非负十进制整数，表示要写入输出的最小字符数。如果待打印的值短于宽度，则结果用空格填充。即使结果较大，也不会截断该值。
对于整数转换字符，precision 指定要写入的最小位数。如果待写入的值短于此数字，则结果将用前导零填充。对于字符串，它是要打印的字符数上限。对于 e、E、f 和 F 动词，它是小数点后要打印的位数。对于 g 和 G 动词，它是要打印的有效数字的最大数量。
Go 字符串格式函数
格式化函数根据指定的格式说明符格式化字符串。
fmt_funs.go
package main
import (
"fmt"
)
func main() {
name := "Jane"
age := 17
fmt.Printf("%s is %d years old\n", name, age)
res := fmt.Sprintf("%s is %d years old", name, age)
fmt.Println(res)
}
在代码示例中，我们使用了两个字符串格式化函数：fmt.Printf 和 fmt.Sprintf。
fmt.Printf("%s is %d years old\n", name, age)
fmt.Printf 函数将格式化后的字符串打印到控制台。%s 期望一个字符串值，%d 期望一个整数值。
res := fmt.Sprintf("%s is %d years old", name, age)
fmt.Sprintf 函数将字符串格式化到一个变量中。
$ go run fmt_funs.go Jane is 17 years old Jane is 17 years old
Go 字符串格式通用动词
以下示例使用了一些通用动词。
general.go
package main
import (
"fmt"
)
type User struct {
name string
occupation string
}
func main() {
msg := "and old falcon"
n := 16
w := 12.45
r := true
u := User{"John Doe", "gardener"}
vals := []int{1, 2, 3, 4, 5}
ctrs := map[string]string{
"sk": "Slovakia",
"ru": "Russia",
"de": "Germany",
"no": "Norway",
}
fmt.Printf("%v %v %v %v %v\n %v %v\n", msg, n, w, u, r, vals, ctrs)
fmt.Printf("%v %+v\n", u, u)
fmt.Println("--------------------")
fmt.Printf("%#v %#v %#v %#v %#v\n %#v %#v\n", msg, n, w, u, r, vals, ctrs)
fmt.Printf("%T %T %T %T %T %T %T\n", msg, n, w, u, r, vals, ctrs)
fmt.Println("--------------------")
fmt.Printf("The prices dropped by 12%%\n")
}
该示例展示了 Go 的通用动词。%v 和 %#v 对于确定 Go 数据类型的值很有用。%T 对于确定变量的数据类型很有用。%% 仅输出百分号。
$ go run general.go
and old falcon 16 12.45 {John Doe gardener} true
[1 2 3 4 5] map[de:Germany no:Norway ru:Russia sk:Slovakia]
{John Doe gardener} {name:John Doe occupation:gardener}
--------------------
"and old falcon" 16 12.45 main.User{name:"John Doe", occupation:"gardener"} true
[]int{1, 2, 3, 4, 5} map[string]string{"de":"Germany", "no":"Norway", "ru":"Russia", "sk":"Slovakia"}
string int float64 main.User bool []int map[string]string
--------------------
The prices dropped by 12%
Go 字符串格式索引
格式化函数按照给定参数的顺序应用格式说明符。下一个示例展示了如何更改它们的顺序。
indexing.go
package main
import (
"fmt"
)
func main() {
n1 := 2
n2 := 3
n3 := 4
res := fmt.Sprintf("There are %d oranges %d apples %d plums", n1, n2, n3)
fmt.Println(res)
res2 := fmt.Sprintf("There are %[2]d oranges %d apples %[1]d plums", n1, n2, n3)
fmt.Println(res2)
}
我们格式化了两个字符串。在第一种情况下，变量按照指定的顺序应用。在第二种情况下，我们使用 [2] 和 [1] 字符更改它们的顺序，它们分别取第三个和第二个参数。
$ go run indexing.go There are 2 oranges 3 apples 4 plums There are 3 oranges 4 apples 2 plums
Go 字符串格式转换字符
格式转换字符定义了其相应参数的类型和解释。
con_chars.go
package main
import (
"fmt"
)
func main() {
fmt.Printf("%d\n", 1671)
fmt.Printf("%o\n", 1671)
fmt.Printf("%x\n", 1671)
fmt.Printf("%X\n", 1671)
fmt.Printf("%#b\n", 1671)
fmt.Printf("%f\n", 1671.678)
fmt.Printf("%F\n", 1671.678)
fmt.Printf("%e\n", 1671.678)
fmt.Printf("%E\n", 1671.678)
fmt.Printf("%g\n", 1671.678)
fmt.Printf("%G\n", 1671.678)
fmt.Printf("%s\n", "Zetcode")
fmt.Printf("%c %c %c %c %c %c %c\n", 'Z', 'e', 't',
'C', 'o', 'd', 'e')
fmt.Printf("%p\n", []int{1, 2, 3})
fmt.Printf("%d%%\n", 1671)
fmt.Printf("%t\n", 3 > 5)
fmt.Printf("%t\n", 5 > 3)
}
该示例展示了 Go 的字符串格式转换字符。
$ go run con_chars.go 1671 3207 687 687 0b11010000111 1671.678000 1671.678000 1.671678e+03 1.671678E+03 1671.678 1671.678 Zetcode Z e t C o d e 0xc0000c0000 1671% false true
Go 字符串格式整数
以下示例格式化整数。
integers.go
package main
import (
"fmt"
)
func main() {
val := 122
fmt.Printf("%d\n", val)
fmt.Printf("%c\n", val)
fmt.Printf("%q\n", val)
fmt.Printf("%x\n", val)
fmt.Printf("%X\n", val)
fmt.Printf("%o\n", val)
fmt.Printf("%O\n", val)
fmt.Printf("%b\n", val)
fmt.Printf("%U\n", val)
}
整数以十进制、十六进制、八进制和二进制表示形式进行格式化。它还被格式化为字符字面量、带引号的字符字面量，以及 Unicode 转义序列。
$ go run integers.go 122 z 'z' 7a 7A 172 0o172 1111010 U+007A
Go 字符串格式精度
以下示例设置了浮点值的精度。
precision.go
package main
import (
"fmt"
)
func main() {
fmt.Printf("%0.f\n", 16.540)
fmt.Printf("%0.2f\n", 16.540)
fmt.Printf("%0.3f\n", 16.540)
fmt.Printf("%0.5f\n", 16.540)
}
对于浮点值，precision 是小数点后要打印的位数。
$ go run precision.go 17 16.54 16.540 16.54000
Go 字符串格式科学计数法
e、E、g 和 G 动词用于将数字格式化为科学计数法。
- f - 十进制浮点数，小写
- F - 十进制浮点数，大写
- e - 科学计数法（尾数/指数），小写
- E - 科学计数法（尾数/指数），大写
- g - 使用 %e 或 %f 的最短表示
- G - 使用 %E 或 %F 的最短表示
scientific.go
package main
import (
"fmt"
)
func main() {
val := 1273.78888769000
fmt.Printf("%f\n", val)
fmt.Printf("%e\n", val)
fmt.Printf("%g\n", val)
fmt.Printf("%E\n", val)
fmt.Printf("%G\n", val)
fmt.Println("-------------------------")
fmt.Printf("%.10f\n", val)
fmt.Printf("%.10e\n", val)
fmt.Printf("%.10g\n", val)
fmt.Printf("%.10E\n", val)
fmt.Printf("%.10G\n", val)
fmt.Println("-------------------------")
val2 := 66_000_000_000.1200
fmt.Printf("%f\n", val2)
fmt.Printf("%e\n", val2)
fmt.Printf("%g\n", val2)
fmt.Printf("%E\n", val2)
fmt.Printf("%G\n", val2)
}
该示例以普通十进制和科学计数法格式化浮点值。
$ go run scientific.go 1273.788888 1.273789e+03 1273.78888769 1.273789E+03 1273.78888769 ------------------------- 1273.7888876900 1.2737888877e+03 1273.788888 1.2737888877E+03 1273.788888 ------------------------- 66000000000.120003 6.600000e+10 6.600000000012e+10 6.600000E+10 6.600000000012E+10
Go 字符串格式标志
flags 是一组修改输出格式的字符。有效标志的集合取决于说明符字符。Perl 识别以下标志
- space 为非负数添加前导空格
- + 为非负数添加加号前缀
- - 字段内左对齐
- 0 使用零而不是空格右对齐
- # 为任何八进制添加前导 0，为非零十六进制添加 0x 或 0X 前缀，为非零二进制添加 0b 前缀
flags.go
package main
import (
"fmt"
)
func main() {
fmt.Printf("%+d\n", 1691)
fmt.Println("---------------------")
fmt.Printf("%#x\n", 1691)
fmt.Printf("%#X\n", 1691)
fmt.Printf("%#b\n", 1691)
fmt.Println("---------------------")
fmt.Printf("%10d\n", 1691)
fmt.Printf("%-10d\n", 1691)
fmt.Printf("%010d\n", 1691)
}
该示例在字符串格式说明符中使用标志。
$ go run flags.go
+1691
---------------------
0x69b
0X69B
0b11010011011
---------------------
1691
1691
0000001691
Go 字符串格式宽度
width 是要输出的最小字符数。它由紧接在动词前面的可选十进制数指定。如果省略，则宽度将是表示该值所需的任何宽度。
如果宽度大于该值，则用空格填充。
width.go
package main
import (
"fmt"
)
func main() {
w := "falcon"
n := 122
h := 455.67
fmt.Printf("%s\n", w)
fmt.Printf("%10s\n", w)
fmt.Println("---------------------")
fmt.Printf("%d\n", n)
fmt.Printf("%7d\n", n)
fmt.Printf("%07d\n", n)
fmt.Println("---------------------")
fmt.Printf("%10f\n", h)
fmt.Printf("%11f\n", h)
fmt.Printf("%12f\n", h)
}
示例使用了字符串、整数和浮点数的宽度。
fmt.Printf("%07d\n", n)
如果前面有一个 0 字符，则数字不会用空格填充，而是用 0 字符填充。
$ go run width.go
falcon
falcon
---------------------
122
122
0000122
---------------------
455.670000
455.670000
455.670000
来源
在本文中，我们涵盖了 Golang 中的字符串格式化。