go pkg fmt

Go 语言中的  fmt  包是标准库中用于 ​​ 格式化输入输出 ​​ 的核心工具，其名称源自“format”的缩写。通过 ​​ 格式化动词 ​​ 和 ​​ 灵活的函数设计 ​​，兼顾了简单使用与深度定制需求。无论是基础的终端交互，还是复杂的文件读写和字符串处理，均可通过该包高效实现。对于需要精细化控制的场景，结合自定义接口（如  Stringer、Formatter）能进一步提升代码的可读性和维护性

Printing

一、通用格式动词

二、布尔类型

三、整数类型

四、浮点数与复数

五、字符串与字节切片

六、指针与切片

七、宽度与精度控制

语法

1

%[flags][width][.precision]verb

规则

1. 宽度：最小输出字符数（不足补空格/0）。
2. 精度：
   • 浮点数：小数点后位数（%g/%G 为最大有效位数）。
   • 字符串：最大字符数（按 rune 截断，十六进制按字节截断）。
3. 标志：
   • +：显示数值的正负号（如 %+d → +42）。
   • -：左对齐（默认右对齐）。
   • 0：用 0 填充（如 %05d → 00042）。
   • #：改变格式（如 %#x → 0x1a）。
   • （空格）：正数留空（如 % d → 42）。

示例

1
2
3

fmt.Printf("%6.2f", 3.1415)   // 输出 "  3.14"（宽度6，精度2）
fmt.Printf("%-8s", "Go")      // 输出 "Go      "（左对齐）
fmt.Printf("%+05d", 42)       // 输出 "+0042"（0填充，显示符号）

八、特殊类型处理

结构体

• %v 格式：{field1 value1 field2 value2 ...}。
• %+v 格式：添加字段名（如 {Name:"Alice", Age:30}）。
• %#v 格式：Go 语法表示（如 main.Person{Name:"Alice", Age:30}）。

Map

• 默认格式：map[key1:value1 key2:value2 ...]。
• %#v 格式：map[KeyType]ValueType{key1:value1, ...}。

接口值

• 输出内部具体值，而非接口本身（如 var i interface{} = 42 → 42）。

九、优先级与递归处理

1. 接口处理优先级：
   • 若值实现 Formatter 接口，调用其 Format 方法。
   • 若使用 %#v 且实现 GoStringer 接口，调用 GoString()。
   • 若实现 error 或 String() string 接口，调用对应方法。
2. 递归陷阱

十、Print 系列函数对比

十一、注意事项

1. 未导出字段：结构体的未导出字段不会触发 String() 或 Error() 方法。
2. 浮点数精度：%g 会删除末尾的零（如 3.140000 → 3.14）。
3. 切片与字符串：字节切片（[]byte）使用 %s/%q 时按字符串处理。
4. 指针与整数：%d、%x 等动词可格式化指针地址为整数。

Explicit argument indexes

一、基本语法

在 Printf、Sprintf、Fprintf 等函数中，默认情况下格式化动词按参数顺序依次处理。但通过 [n] 语法，可以显式指定参数的索引（从 1 开始计数）。

格式规则

1

%[索引][标志][宽度][.精度]动词

• 索引：必须是 [n] 形式，n 为参数位置（从 1 开始）。
• 若对 宽度 或 精度 使用 *，可用 [n] 指定参数来源。

二、核心用法

1. 交换参数顺序

1

fmt.Sprintf("%[2]d %[1]d", 11, 22) // 输出 "22 11"

• %[2]d：使用第 2 个参数 22。
• %[1]d：使用第 1 个参数 11。

2. 动态设置宽度/精度

1
2
3

fmt.Sprintf("%[3]*.[2]*[1]f", 12.0, 2, 6)
// 等价于 fmt.Sprintf("%6.2f", 12.0)
// 输出 " 12.00"

• %[3]*：宽度取第 3 个参数 6。
• .[2]*：精度取第 2 个参数 2。
• [1]f：值取第 1 个参数 12.0。

3. 重复使用参数

1
2

fmt.Sprintf("%d %d %#[1]x %#x", 16, 17)
// 输出 "16 17 0x10 0x11"

• 前两个 %d 按顺序使用参数 16 和 17。
• %#[1]x：再次使用第 1 个参数 16，格式化为十六进制并添加 0x。
• %#x：继续使用下一个参数（即第 2 个参数 17），格式化为十六进制。

三、索引对后续动词的影响

显式索引会重置后续动词的参数位置：

1
2

fmt.Printf("%[2]s %s %[1]s", "A", "B", "C")
// 输出 "B C A"

• %[2]s → 参数 2（“B”）。
• 下一个 %s 使用参数 3（“C”）。
• %[1]s → 参数 1（“A”）。

四、复杂示例

动态格式控制

1
2
3
4
5
6
7

width := 8
precision := 3
value := 3.1415926

fmt.Printf("%[3]*.[2]*[1]f", value, precision, width)
// 等价于 fmt.Printf("%8.3f", value)
// 输出 "   3.142"

• %[3]*：宽度来自第 3 个参数 width=8。
• .[2]*：精度来自第 2 个参数 precision=3。
• [1]f：值来自第 1 个参数 value=3.1415926。

多次复用同一参数

1
2
3

name := "Alice"
fmt.Printf("%[1]s: %[1]q (length=%d)", name, len(name))
// 输出 "Alice: "Alice" (length=5)"

• %[1]s 和 %[1]q 均使用第 1 个参数 name。
• %d 使用第 2 个参数 len(name)。

五、注意事项

1. 索引范围：索引从 1 开始，且不能超过参数总数。
2. 动态参数顺序：显式索引后，后续动词默认从 n+1 开始。
3. 可读性：复杂索引可能降低代码可读性，建议适度使用。
4. 错误示例：

   1 2	fmt.Printf("%[0]d", 42) // 错误：索引从 1 开始 fmt.Printf("%[3]d", 1, 2) // 错误：索引 3 超出参数范围

六、使用场景

通过显式参数索引，可以实现更灵活的格式化控制，尤其在需要重复使用参数或动态设置格式时非常有用。

Format errors

一、错误类型与格式

当格式化动词与参数类型不匹配或参数数量不匹配时，fmt 包会生成特定错误信息，格式为 %!动词(错误描述)。

1. 类型不匹配或未知动词

2. 参数数量问题

3. 动态宽度/精度参数错误

4. 参数索引错误

二、Panic 处理

如果 Error()、String() 或 GoString() 方法触发 panic，错误信息会被捕获并标记为 PANIC。

示例

1
2
3
4
5
6
7

type MyType struct{}
func (m *MyType) String() string { panic("bad") }

func main() {
    var m MyType
    fmt.Printf("%s", m) // 输出：%!s(PANIC=bad)
}

特殊场景

三、错误格式总结

所有错误信息遵循以下模式：

1

%!动词(错误类型=描述)

• 动词：触发错误的格式化动词（如 %d 对应 d）。
• 错误类型：错误类别（如 BADWIDTH、MISSING）。
• 描述：具体错误原因（如 string=hi 表示传入字符串）。

四、调试建议

1. 检查动词与参数类型：确保 %d 对应整数，%s 对应字符串等。
2. 验证参数数量：格式化字符串中的动词数量需与参数数量匹配。
3. 动态参数校验：确保 * 宽度/精度参数为整数。
4. 处理 nil 值：为可能为 nil 的类型实现安全的 String() 方法。

五、错误示例解析

示例 1

1

fmt.Printf("%d %s", "hello", 42)

• 输出：%!d(string=hello) %!s(int=42)
• 原因：%d 需要整数但传入字符串，%s 需要字符串但传入整数。

示例 2

1

fmt.Printf("%[3]d", 1, 2)

• 输出：%!d(BADINDEX)
• 原因：索引 [3] 超出参数范围（只有 2 个参数）。

通过理解这些错误信息，可以快速定位格式化代码中的问题，尤其是在处理复杂格式字符串或动态参数时。

Scanning

一、扫描函数分类

二、输入处理规则

1. 空格与换行符

• Scan/Fscan/Sscan：将换行符（\n）视为普通空格。
• Scanln/Fscanln/Sscanln：遇到换行符后停止扫描，且要求参数后必须紧跟换行符或 EOF。
• Scanf/Fscanf/Sscanf：根据格式字符串处理空格和换行符。

2. 格式字符串中的空格

• 普通字符：必须与输入严格匹配（如 "a%b" 要求输入中有 a 后跟 % 匹配的内容）。
• 换行符：格式中的 \n 匹配输入中的零或多个空格后跟一个换行符。
• 连续空格：格式中的连续空格匹配输入中的任意多个空格（至少一个，除非在换行符旁）。

三、格式化动词

通用动词

浮点数与复数

• 支持动词：%b、%e、%E、%f、%F、%g、%G、%x、%X、%v`。
• 示例：

  1 2	var f float64 fmt.Sscanf("0x1.8p+2", "%v", &f) // f = 6.0

特殊说明

• 不支持的 Printf 特性：%p、%T、# 和 + 标志。
• 隐式空格分隔：除 %c 外，所有动词解析前会跳过前导空格。

四、宽度控制

语法

1

%[宽度]动词

• 宽度：指定最大读取字符数（按 rune 计数，非字节）。
• 示例：

  1 2	var s string fmt.Sscanf("1234567", "%5s", &s) // s = "12345"

五、前缀与下划线

• 整数：支持 0b、0o、0x 前缀及数字下划线分隔。

  1 2	var i int fmt.Sscanf("0b1010_1100", "%v", &i) // i = 172

• 浮点数：支持十六进制（如 0x1.2p3）和下划线分隔。

  1 2	var f float64 fmt.Sscanf("3_141.592_6535", "%f", &f) // f = 3141.5926535

六、Scanner 接口

若类型实现 Scan 方法（即实现 Scanner 接口），扫描函数将调用该方法自定义解析逻辑。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

type MyType struct{ Value int }

func (m *MyType) Scan(f fmt.ScanState, verb rune) error {
    s, _ := f.Token(true, nil) // 读取整个 token
    m.Value, _ = strconv.Atoi(string(s))
    return nil
}

func main() {
    var m MyType
    fmt.Sscanf("42", "%v", &m) // m.Value = 42
}

七、注意事项

1. 必须传递指针：

   1 2 3

   var i int fmt.Scan(&i) // 正确 fmt.Scan(i) // 错误：非指针

2. 输入未完全消费：

   1 2	var a, b int fmt.Sscanf("10 20 30", "%d %d", &a, &b) // a=10, b=20，剩余 "30" 被忽略

3. 换行符处理：

   • \r\n 会被统一视为 \n。

4. 潜在数据丢失：

   • 若 io.Reader 未实现 ReadRune 和 UnreadRune，连续扫描可能跳过字符。建议使用 bufio.NewReader 包装。

八、错误示例

示例 1：参数不足

1
2
3

var i int
_, err := fmt.Sscanf("hello", "%d", &i)
fmt.Println(err) // 输出: expected integer

示例 2：类型不匹配

1
2
3

var f float64
_, err := fmt.Sscanf("not_a_float", "%f", &f)
fmt.Println(err) // 输出: parsing "not_a_float": invalid syntax

九、高级用法

批量扫描

1
2
3
4
5
6

input := "John 30 175.5"
var name string
var age int
var height float64
fmt.Sscanf(input, "%s %d %f", &name, &age, &height)
// name="John", age=30, height=175.5

动态宽度扫描

1
2

var s1, s2 string
fmt.Sscanf("ABCDEFG", "%3s%2s", &s1, &s2) // s1="ABC", s2="DE"

Functions

格式化输出函数

标准输出函数

字符串构建函数

文件/Writer 输出函数

字节追加函数

输入扫描函数

标准输入函数

字符串扫描函数

文件/Reader 扫描函数

工具函数

接口和类型

这些函数和接口构成了 Go 语言中用于格式化输入输出的强大工具集，为程序提供了灵活的文本处理能力。

demo 展示

实现 Stringer 和 GoStringer

1
2

persion: Name: John, Age: 30
persion: Persion{Name: "John", Age: 30}

实现 Formatter

1
2
3
4
5

默认: Host: localhost, Port: 5432, User: user, DB: example_db
详细信息: DBConfig{Host: localhost, Port: 5432, Username: user, Password: password, Database: example_db}
字符串表示: localhost:5432/example_db
带引号: "localhost:5432/example_db"
其他格式: unsupported format: x

Go fmt 包中的三个格式化接口及其优先级

在 Go 的 fmt 包中，Formatter、Stringer 和 GoStringer 这三个接口用于控制值的格式化输出。它们各有特定用途，并按照一定的优先级顺序被调用。

优先级顺序（从高到低）

1. Formatter 接口 (最高优先级)
2. GoStringer 接口 (中间优先级，特定于 %#v 格式)
3. Stringer 接口 (最低优先级)

1. Formatter 接口

1
2
3

type Formatter interface {
    Format(f State, verb rune)
}

• 最高优先级：如果一个类型实现了此接口，fmt 包将优先使用它来处理所有格式化操作
• 完全控制：可以自定义处理所有格式动词和标志
• 灵活性：能够根据不同的格式动词(v, s, q等)和标志(+, #等)提供不同输出
• 应用场景：需要对不同格式动词提供完全不同的输出形式时

2. GoStringer 接口

1
2
3

type GoStringer interface {
    GoString() string
}

• 特定优先级：仅当使用 %#v 格式动词且类型未实现 Formatter 接口时生效
• 用途：提供符合 Go 语法的值表示，主要用于调试和开发
• 典型输出：类似于可用于重建对象的 Go 代码片段
• 应用场景：调试时想查看值的 Go 语法表示

3. Stringer 接口

1
2
3

type Stringer interface {
    String() string
}

• 基础优先级：当类型未实现 Formatter 接口（对于 %v、%s 等），且未使用 %#v（或实现了但未使用 GoStringer）时生效
• 用途：提供类型的"原生"字符串表示
• 简单直接：只需返回一个字符串，不需要处理不同的格式动词
• 应用场景：希望类型有一个默认的字符串表示时

调用顺序逻辑

当调用 fmt 包的函数（如 Printf, Sprintf 等）时：

1. 首先检查值是否实现了 Formatter 接口，如果是，则调用其 Format 方法
2. 如果没有实现 Formatter，但格式是 %#v 且实现了 GoStringer，则调用 GoString()
3. 如果前两者都不适用，但实现了 Stringer，则在适当的格式中使用 String()
4. 如果都没实现，则使用 fmt 包的默认格式化规则