8.1 fmt

跟煎鱼学 Go
Search…
跟煎鱼学 Go
Introduction
8.1 fmt
前言
1
package main
2
​
3
import (
4
    "fmt"
5
)
6
​
7
func main() {
8
    fmt.Println("Hello World!")
9
}
Copied!
标准开场见多了，那内部标准库又是怎么输出这段英文的呢？今天一起来围观下源码吧 🤭
原型
1
func Print(a ...interface{}) (n int, err error) {
2
    return Fprint(os.Stdout, a...)
3
}
4
​
5
func Println(a ...interface{}) (n int, err error) {
6
    return Fprintln(os.Stdout, a...)
7
}
8
​
9
func Printf(format string, a ...interface{}) (n int, err error) {
10
    return Fprintf(os.Stdout, format, a...)
11
}
Copied!
Print：使用默认格式说明符打印格式并写入标准输出。当两者都不是字符串时，在操作数之间添加空格
Println：同上，不同的地方是始终在操作数之间添加空格，并附加换行符
Printf：根据格式说明符进行格式化并写入标准输出
以上三类就是最常见的格式化 I/O 的方法，我们将基于此去进行拆解描述
执行流程
案例一：Print
在这里我们使用 Print 方法做一个分析，便于后面的加深理解 😄
1
func Print(a ...interface{}) (n int, err error) {
2
    return Fprint(os.Stdout, a...)
3
}
Copied!
Print 使用默认格式说明符打印格式并写入标准输出。另外当两者都为非空字符串时将插入一个空格
原型
1
func Fprint(w io.Writer, a ...interface{}) (n int, err error) {
2
    p := newPrinter()
3
    p.doPrint(a)
4
    n, err = w.Write(p.buf)
5
    p.free()
6
    return
7
}
Copied!
该函数一共有两个形参：
w：输出流，只要实现 io.Writer 就可以（抽象）为流的写入
a：任意类型的多个值
分析主干流程
1、 p := newPrinter(): 申请一个临时对象池（sync.Pool）
1
var ppFree = sync.Pool{
2
    New: func() interface{} { return new(pp) },
3
}
4
​
5
func newPrinter() *pp {
6
    p := ppFree.Get().(*pp)
7
    p.panicking = false
8
    p.erroring = false
9
    p.fmt.init(&p.buf)
10
    return p
11
}
Copied!
ppFree.Get()：基于 sync.Pool 实现 *pp 的临时对象池，每次获取一定会返回一个新的 pp 对象用于接下来的处理
*pp.panicking：用于解决无限递归的 panic、recover 问题，会根据该参数在 catchPanic 及时掐断
*pp.erroring：用于表示正在处理错误无效的 verb 标识符，主要作用是防止调用 handleMethods 方法
*pp.fmt.init(&p.buf)：初始化 fmt 配置，会设置 buf 并且清空 fmtFlags 标志位
2、 p.doPrint(a): 执行约定的格式化动作（参数间增加一个空格、最后一个参数增加换行符）
1
func (p *pp) doPrint(a []interface{}) {
2
    prevString := false
3
    for argNum, arg := range a {
4
        true && false
5
        isString := arg != nil && reflect.TypeOf(arg).Kind() == reflect.String
6
        // Add a space between two non-string arguments.
7
        if argNum > 0 && !isString && !prevString {
8
            p.buf.WriteByte(' ')
9
        }
10
        p.printArg(arg, 'v')
11
        prevString = isString
12
    }
13
}
Copied!
可以看到底层通过判断该入参，同时满足以下条件就会添加分隔符（空格）：
当前入参为多个参数（例如：Slice）
当前入参不为 nil 且不为字符串（通过反射确定）
当前入参不为首项或上一个入参不为字符串
而在 Print 方法中，不需要指定格式符。实际上在该方法内直接指定为 v。也就是默认格式的值
1
p.printArg(arg, 'v')
Copied!
1.w.Write(p.buf): 写入标准输出（io.Writer）
2.*pp.free(): 释放已缓存的内容。在使用完临时对象后，会将 buf、arg、value 清空再重新存放到 ppFree 中。以便于后面再取出重用（利用 sync.Pool 的临时对象特性）
案例二：Printf
标识符
Verbs
1
%v    the value in a default format
2
    when printing structs, the plus flag (%+v) adds field names
3
%#v    a Go-syntax representation of the value
4
%T    a Go-syntax representation of the type of the value
5
%%    a literal percent sign; consumes no value
6
%t    the word true or false
Copied!
Flags
1
+    always print a sign for numeric values;
2
    guarantee ASCII-only output for %q (%+q)
3
-    pad with spaces on the right rather than the left (left-justify the field)
4
#    alternate format: add leading 0 for octal (%#o), 0x for hex (%#x);
5
    0X for hex (%#X); suppress 0x for %p (%#p);
6
    for %q, print a raw (backquoted) string if strconv.CanBackquote
7
    returns true;
8
    always print a decimal point for %e, %E, %f, %F, %g and %G;
9
    do not remove trailing zeros for %g and %G;
10
    write e.g. U+0078 'x' if the character is printable for %U (%#U).
11
' '    (space) leave a space for elided sign in numbers (% d);
12
    put spaces between bytes printing strings or slices in hex (% x, % X)
13
0    pad with leading zeros rather than spaces;
14
    for numbers, this moves the padding after the sign
Copied!
详细建议参见 Godoc​
原型
1
func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
2
    p := newPrinter()
3
    p.doPrintf(format, a)
4
    n, err = w.Write(p.buf)
5
    p.free()
6
    return
7
}
Copied!
与 Print 相比，最大的不同就是 doPrintf 方法了。在这里我们来详细看看其代码，如下：
1
func (p *pp) doPrintf(format string, a []interface{}) {
2
    end := len(format)
3
    argNum := 0         // we process one argument per non-trivial format
4
    afterIndex := false // previous item in format was an index like [3].
5
    p.reordered = false
6
formatLoop:
7
    for i := 0; i < end; {
8
        p.goodArgNum = true
9
        lasti := i
10
        for i < end && format[i] != '%' {
11
            i++
12
        }
13
        if i > lasti {
14
            p.buf.WriteString(format[lasti:i])
15
        }
16
        if i >= end {
17
            // done processing format string
18
            break
19
        }
20
​
21
        // Process one verb
22
        i++
23
​
24
        // Do we have flags?
25
        p.fmt.clearflags()
26
    simpleFormat:
27
        for ; i < end; i++ {
28
            c := format[i]
29
            switch c {
30
            case '#':   //'#'、'0'、'+'、'-'、' '
31
                ...
32
            default:
33
                if 'a' <= c && c <= 'z' && argNum < len(a) {
34
                    ...
35
                    p.printArg(a[argNum], rune(c))
36
                    argNum++
37
                    i++
38
                    continue formatLoop
39
                }
40
​
41
                break simpleFormat
42
            }
43
        }
44
​
45
        // Do we have an explicit argument index?
46
        argNum, i, afterIndex = p.argNumber(argNum, format, i, len(a))
47
​
48
        // Do we have width?
49
        if i < end && format[i] == '*' {
50
            ...
51
        }
52
​
53
        // Do we have precision?
54
        if i+1 < end && format[i] == '.' {
55
            ...
56
        }
57
​
58
        if !afterIndex {
59
            argNum, i, afterIndex = p.argNumber(argNum, format, i, len(a))
60
        }
61
​
62
        if i >= end {
63
            p.buf.WriteString(noVerbString)
64
            break
65
        }
66
​
67
        ...
68
​
69
        switch {
70
        case verb == '%': // Percent does not absorb operands and ignores f.wid and f.prec.
71
            p.buf.WriteByte('%')
72
        case !p.goodArgNum:
73
            p.badArgNum(verb)
74
        case argNum >= len(a): // No argument left over to print for the current verb.
75
            p.missingArg(verb)
76
        case verb == 'v':
77
            ...
78
            fallthrough
79
        default:
80
            p.printArg(a[argNum], verb)
81
            argNum++
82
        }
83
    }
84
​
85
    if !p.reordered && argNum < len(a) {
86
        ...
87
    }
88
}
Copied!
分析主干流程
1.写入 % 之前的字符内容
2.如果所有标志位处理完毕（到达字符尾部），则跳出处理逻辑
3.（往后移）跳过 % ，开始处理其他 verb 标志位
4.清空（重新初始化） fmt 配置
5.处理一些基础的 verb 标识符（simpleFormat）。如：'#'、'0'、'+'、'-'、' ' 以及简单的 verbs 标识符（不包含精度、宽度和参数索引）。需要注意的是，若当前字符为简单 verb 标识符。则直接进行处理。完成后会直接后移到下一个字符。其余标志位则变更 fmt 配置项，便于后续处理
6.处理参数索引（argument index）
7.处理参数宽度（width）
8.处理参数精度（precision）
9.% 之后若不存在 verbs 标识符则返回 noVerbString。值为 %!(NOVERB)
10.处理特殊 verbs 标识符（如：'%%'、'%#v'、'%+v'）、错误情况（如：参数索引指定错误、参数集个数与 verbs 标识符数量不匹配）或进行格式化参数集
11.常规流程处理完毕
在特殊情况下，若提供的参数集比 verb 标识符多。fmt 将会贪婪检查下去，将多出的参数集以特定的格式输出，如下：
1
fmt.Printf("%d", 1, 2, 3)
2
// 1%!(EXTRA int=2, int=3)
Copied!
约定前缀额外标志：%!(EXTRA
当前参数的类型
约定格式符：=
当前参数的值（默认以 %v 格式化）
约定格式符：)
值得注意的是，当指定了参数索引或实际处理的参数小于入参的参数集时，就不会进行贪婪匹配来展示
案例三：Println
原型
1
func Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
2
    p := newPrinter()
3
    p.doPrintln(a)
4
    n, err = w.Write(p.buf)
5
    p.free()
6
    return
7
}
Copied!
在这个方法中，最大的区别就是 doPrintln，我们一起来看看，如下：
1
func (p *pp) doPrintln(a []interface{}) {
2
    for argNum, arg := range a {
3
        if argNum > 0 {
4
            p.buf.WriteByte(' ')
5
        }
6
        p.printArg(arg, 'v')
7
    }
8
    p.buf.WriteByte('\n')
9
}
Copied!
分析主干流程
循环入参的参数集，并以空格分隔
格式化当前参数，默认以 %v 对参数进行格式化
在结尾添加 \n 字符
如何格式化参数
在上例的执行流程分析中，可以看到格式化参数这一步是在 p.printArg(arg, verb) 执行的，我们一起来看看它都做了些什么？
1
func (p *pp) printArg(arg interface{}, verb rune) {
2
    p.arg = arg
3
    p.value = reflect.Value{}
4
​
5
    if arg == nil {
6
        switch verb {
7
        case 'T', 'v':
8
            p.fmt.padString(nilAngleString)
9
        default:
10
            p.badVerb(verb)
11
        }
12
        return
13
    }
14
​
15
    switch verb {
16
    case 'T':
17
        p.fmt.fmt_s(reflect.TypeOf(arg).String())
18
        return
19
    case 'p':
20
        p.fmtPointer(reflect.ValueOf(arg), 'p')
21
        return
22
    }
23
​
24
    // Some types can be done without reflection.
25
    switch f := arg.(type) {
26
    case bool:
27
        p.fmtBool(f, verb)
28
    case float32:
29
        p.fmtFloat(float64(f), 32, verb)
30
    ...
31
    case reflect.Value:
32
        if f.IsValid() && f.CanInterface() {
33
            p.arg = f.Interface()
34
            if p.handleMethods(verb) {
35
                return
36
            }
37
        }
38
        p.printValue(f, verb, 0)
39
    default:
40
        if !p.handleMethods(verb) {
41
            p.printValue(reflect.ValueOf(f), verb, 0)
42
        }
43
    }
44
}
Copied!
在小节代码中可以看见，fmt 本身对不同的类型做了不同的处理。这样子就避免了通过反射确定。相对的提高了性能
其中有两个特殊的方法，分别是 handleMethods 和 badVerb，接下来分别来看看他们的作用是什么
1、badVerb
它主要用于格式化并处理错误的行为。我们可以一起来看看，代码如下：
1
func (p *pp) badVerb(verb rune) {
2
    p.erroring = true
3
    p.buf.WriteString(percentBangString)
4
    p.buf.WriteRune(verb)
5
    p.buf.WriteByte('(')
6
    switch {
7
    case p.arg != nil:
8
        p.buf.WriteString(reflect.TypeOf(p.arg).String())
9
        p.buf.WriteByte('=')
10
        p.printArg(p.arg, 'v')
11
    ...
12
    default:
13
        p.buf.WriteString(nilAngleString)
14
    }
15
    p.buf.WriteByte(')')
16
    p.erroring = false
17
}
Copied!
在处理错误格式化时，我们可以对比以下例子：
1
fmt.Printf("%s", []int64{1, 2, 3})
2
// [%!s(int64=1) %!s(int64=2) %!s(int64=3)]%
Copied!
在 badVerb 中可以看到错误字符串的处理主要分为以下部分：
约定前缀错误标志：%!
当前的格式化操作符
约定格式符：(
当前参数的类型
约定格式符：=
当前参数的值（默认以 %v 格式化）
约定格式符：)
2、handleMethods
1
func (p *pp) handleMethods(verb rune) (handled bool) {
2
    if p.erroring {
3
        return
4
    }
5
    // Is it a Formatter?
6
    if formatter, ok := p.arg.(Formatter); ok {
7
        handled = true
8
        defer p.catchPanic(p.arg, verb)
9
        formatter.Format(p, verb)
10
        return
11
    }
12
​
13
    // If we're doing Go syntax and the argument knows how to supply it, take care of it now.
14
    ...
15
​
16
    return false
17
}
Copied!
这个方法比较特殊，一般在自定义结构体和未知情况下进行调用。主要流程是：
若当前参数为错误 verb 标识符，则直接返回
判断是否实现了 Formatter 
实现，则利用自定义 Formatter 格式化参数
未实现，则最大程度的利用 Go syntax 默认规则去格式化参数
拓展
在 fmt 标准库中可以通过自定义结构体来实现方法的自定义，大致如下几种
fmt.State
1
type State interface {
2
    Write(b []byte) (n int, err error)
3
​
4
    Width() (wid int, ok bool)
5
​
6
    Precision() (prec int, ok bool)
7
​
8
    Flag(c int) bool
9
}
Copied!
State 用于获取标志位的状态值，涉及如下：
Write：将格式化完毕的字符写入缓冲区中，等待下一步处理
Width：返回宽度信息和是否被设置
Precision：返回精度信息和是否被设置
Flag：返回特殊标志符（'#'、'0'、'+'、'-'、' '）是否被设置
fmt.Formatter
1
type Formatter interface {
2
    Format(f State, c rune)
3
}
Copied!
Formatter 用于实现自定义格式化方法。可通过在自定义结构体中实现 Format 方法来实现这个目的
另外，可以通过 f 获取到当前标识符的宽度、精度等状态值。c 为 verb 标识符，可以得到其动作是什么
fmt.Stringer
1
type Stringer interface {
2
    String() string
3
}
Copied!
当该对象为 String、Array、Slice 等类型时，将会调用 String() 方法对类字符串进行格式化
fmt.GoStringer
1
type GoStringer interface {
2
    GoString() string
3
}
Copied!
当格式化特定 verb 标识符（%v）时，将调用 GoString() 方法对其进行格式化
总结
通过本文对 fmt 标准库的分析，可以发现它有以下特点：
在拓展性方面，可以自定义格式化方法等
在完整度方面，尽可能的贪婪匹配，输出参数集
在性能方面，每种不同的参数类型，都实现了不同的格式化处理操作
在性能方面，尽可能的最短匹配，格式化参数集
总的来说，fmt 标准库有许多值得推敲的细节，希望你能够在本文学到 😄
第8课标准库
8.2 log
Last modified 2yr ago
Copy link
Contents