我爱分享网Go字符串格式化教程展示了如何在Golang中格式化字符串。在fmt包中，我们找到了实现格式化I/O的函数。
$ go version go version go1.18.1 linux/amd64
我们使用Go版本1.18。
为了在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-单词真假
- s-字符串
- v-默认格式
- #v-值的Go语法表示
- T-值类型的Go语法表示
- p-指针地址
- %-双%%打印单个%
标志是一组修改输出格式的字符。有效标志集取决于转换字符。width是一个非负十进制整数，表示要写入输出的最小符文数。如果要打印的值小于宽度，则用空格填充结果。即使结果更大，该值也不会被截断。
对于整数转换字符，precision指定要写入的最小数字位数。如果要写入的值小于此数字，则用前导零填充结果。对于字符串，它是要打印的最大符文数。对于e、E、f和F动词，它是小数点后要打印的位数。对于g和Gverbsit是要打印的最大有效数字位数。
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字符串格式通用动词
以下示例使用了一些一般动词。
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字符串格式索引
格式化函数按照给定参数的顺序应用格式说明符。下一个示例展示了如何更改它们的顺序。
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
去字符串格式转换字符
格式转换字符定义了类型及其对应参数的解释。
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字符串格式整数
以下示例格式化整数。
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字符串格式精度
以下示例设置浮点值的精度。
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)
}
对于浮点值，精度是小数点后要打印的位数。
$ 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
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字符串格式标志
标志是一组修改输出格式的字符。有效标志集取决于说明符字符。Perl识别以下标志：
- spaceÂ以空格为前缀的非负数
- +Â以加号为前缀的非负数
- -Â左对齐字段
- 0Â使用零而不是空格来右对齐
- #Â为任何八进制、前缀非零十六进制加上0x或0X，放置前导0，前缀非零二进制与0b
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字符串格式宽度
宽度是要输出的最小符文数。它由紧接在动词前的可选十进制数指定。如果不存在，宽度是表示该值所需的任何值。
如果宽度大于该值，则用空格填充。
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中的字符串格式化。
列出所有Go教程。
