Package fmt

import "fmt"
Overview
Index
Examples

Overview ▾

软件包fmt使用与C的printf和scanf类似的功能实现格式化的I / O. 格式"动词"派生自C,但更简单.

Printing

动词:

General:

%v	the value in a default format
	when printing structs, the plus flag (%+v) adds field names
%#v	a Go-syntax representation of the value
%T	a Go-syntax representation of the type of the value
%%	a literal percent sign; consumes no value

Boolean:

%t	the word true or false

Integer:

%b	base 2
%c	the character represented by the corresponding Unicode code point
%d	base 10
%o	base 8
%O	base 8 with 0o prefix
%q	a single-quoted character literal safely escaped with Go syntax.
%x	base 16, with lower-case letters for a-f
%X	base 16, with upper-case letters for A-F
%U	Unicode format: U+1234; same as "U+%04X"

浮点和复杂成分:

%b	decimalless scientific notation with exponent a power of two,
	in the manner of strconv.FormatFloat with the 'b' format,
	e.g. -123456p-78
%e	scientific notation, e.g. -1.234456e+78
%E	scientific notation, e.g. -1.234456E+78
%f	decimal point but no exponent, e.g. 123.456
%F	synonym for %f
%g	%e for large exponents, %f otherwise. Precision is discussed below.
%G	%E for large exponents, %F otherwise
%x	hexadecimal notation (with decimal power of two exponent), e.g. -0x1.23abcp+20
%X	upper-case hexadecimal notation, e.g. -0X1.23ABCP+20

字符串和字节片(与这些动词等效地处理):

%s	the uninterpreted bytes of the string or slice
%q	a double-quoted string safely escaped with Go syntax
%x	base 16, lower-case, two characters per byte
%X	base 16, upper-case, two characters per byte

Slice:

%p	address of 0th element in base 16 notation, with leading 0x

Pointer:

%p	base 16 notation, with leading 0x
The %b, %d, %o, %x and %X verbs also work with pointers,
formatting the value exactly as if it were an integer.

%v的默认格式为:

bool:                    %t
int, int8 etc.:          %d
uint, uint8 etc.:        %d, %#x if printed with %#v
float32, complex64, etc: %g
string:                  %s
chan:                    %p
pointer:                 %p

对于复合对象,使用以下规则递归打印元素,其布局如下:

struct:             {field0 field1 ...}
array, slice:       [elem0 elem1 ...]
maps:               map[key1:value1 key2:value2 ...]
pointer to above:   &{}, &[], &map[]

宽度由动词前的可选十进制数字指定. 如果不存在,则宽度是表示值所必需的. 精度在(可选)宽度之后指定一个句点,后跟一个十进制数字. 如果不存在句点,则使用默认精度. 没有以下数字的句点指定精度为零. 例子:

%f     default width, default precision
%9f    width 9, default precision
%.2f   default width, precision 2
%9.2f  width 9, precision 2
%9.f   width 9, precision 0

宽度和精度以Unicode代码点(即,符文)为单位进行度量. (这与C的printf不同,后者始终以字节为单位.)两个标志中的一个或两个都可以用字符'*'替换,从而使它们的值可从下一个操作数(在格式化前的操作数之前)获得,必须是int类型.

对于大多数值,width是要输出的最小符文数,必要时用空格填充格式化的表单.

但是,对于字符串,字节片和字节数组,精度会限制要格式化的输入的长度(而不是输出的大小),并在必要时将其截断. 通常,它以符文为单位进行度量,但是对于这些类型,使用%x或%X格式进行格式化时,将以字节为单位进行度量.

对于浮点值,width设置字段的最小宽度,而precision设置小数点后的位数(如果适用),除了%g /%G精度设置最大的有效位数(删除零位). . 例如,给定12.345,格式%6.3f可打印12.345,而%.3g可打印12.3. %e,%f和%#g的默认精度为6; 对于%g,它是唯一标识该值所需的最少位数.

对于复数,宽度和精度分别应用于两个分量,并且将结果括在括号中,因此将%f应用于1.2 + 3.4i生成(1.200000 + 3.400000i).

其他标志:

+	always print a sign for numeric values;
	guarantee ASCII-only output for %q (%+q)
-	pad with spaces on the right rather than the left (left-justify the field)
#	alternate format: add leading 0b for binary (%#b), 0 for octal (%#o),
	0x or 0X for hex (%#x or %#X); suppress 0x for %p (%#p);
	for %q, print a raw (backquoted) string if strconv.CanBackquote
	returns true;
	always print a decimal point for %e, %E, %f, %F, %g and %G;
	do not remove trailing zeros for %g and %G;
	write e.g. U+0078 'x' if the character is printable for %U (%#U).
' '	(space) leave a space for elided sign in numbers (% d);
	put spaces between bytes printing strings or slices in hex (% x, % X)
0	pad with leading zeros rather than spaces;
	for numbers, this moves the padding after the sign

标记会被不需要它们的动词忽略. 例如,没有替代的十进制格式,因此%#d和%d的行为相同.

对于每个类似于Printf的函数,还有一个不带格式的Print函数,等效于为每个操作数说%v. 另一种变体Println在操作数之间插入空格,并添加换行符.

无论动词如何,如果操作数是接口值,那么将使用内部具体值,而不是接口本身. 从而:

var i interface{} = 23
fmt.Printf("%v\n", i)

will print 23.

Except when printed using the verbs %T and %p, special formatting considerations apply for operands that implement certain interfaces. In order of application:

1.如果操作数是reflect.Value,则将操作数替换为其所持有的具体值,然后使用下一个规则继续打印.

2.如果一个操作数实现了Formatter接口,它将被调用. Formatter提供了对格式的精细控制.

3.如果%v动词与#标志(%#v)一起使用,并且操作数实现GoStringer接口,则将调用该接口.

如果格式(对于Println等,隐式为%v)对字符串(%s%q%v%x%X)有效,则适用以下两个规则:

4.如果操作数实现错误接口,则将调用Error方法将对象转换为字符串,然后将根据动词的要求对其进行格式化(如果有).

5.如果操作数实现String()字符串方法,则将调用该方法将对象转换为字符串,然后将根据动词的要求对其进行格式化(如果有).

对于切片和结构之类的复合操作数,格式递归地应用于每个操作数的元素,而不是整个操作数. 因此%q将引用字符串切片中的每个元素,而%6.2f将控制浮点数组中每个元素的格式.

但是,在打印带有字符串状动词(%s%q%x%X)的字节片时,将其与字符串等同地视为一个项.

在诸如以下情况下避免递归

type X string
func (x X) String() string { return Sprintf("<%s>", x) }

在重复之前转换值:

func (x X) String() string { return Sprintf("<%s>", string(x)) }

无限递归也可以由自引用数据结构触发,例如包含自身作为元素的切片(如果该类型具有String方法). 但是,这种病理情况很少见,并且该软件包也无法防止它们.

打印结构时,fmt无法并且因此不会在未导出的字段上调用诸如Error或String之类的格式化方法.

显式参数索引:

在Printf,Sprintf和Fprintf中,默认行为是为每个格式化动词格式化在调用中传递的连续参数. 但是,动词前的符号[n]表示将格式化第n个单索引参数. 宽度或精度的'*'之前的相同符号选择保存该值的参数索引. 在处理了带括号的表达式[n]后,除非另外指出,否则后续动词将使用自变量n + 1,n + 2等.

例如,

fmt.Sprintf("%[2]d %[1]d\n", 11, 22)

将产生" 22 11",而

fmt.Sprintf("%[3]*.[2]*[1]f", 12.0, 2, 6)

相当于

fmt.Sprintf("%6.2f", 12.0)

将产生" 12.00". 由于显式索引会影响后续动词,因此可以通过为要重复的第一个参数重置索引来将该符号多次打印相同的值:

fmt.Sprintf("%d %d %#[1]x %#x", 16, 17)

将产生" 16 17 0x10 0x11".

格式错误:

如果为动词给出了无效的参数,例如为%d提供了字符串,则生成的字符串将包含问题的描述,如以下示例所示:

Wrong type or unknown verb: %!verb(type=value)
	Printf("%d", "hi"):        %!d(string=hi)
Too many arguments: %!(EXTRA type=value)
	Printf("hi", "guys"):      hi%!(EXTRA string=guys)
Too few arguments: %!verb(MISSING)
	Printf("hi%d"):            hi%!d(MISSING)
Non-int for width or precision: %!(BADWIDTH) or %!(BADPREC)
	Printf("%*s", 4.5, "hi"):  %!(BADWIDTH)hi
	Printf("%.*s", 4.5, "hi"): %!(BADPREC)hi
Invalid or invalid use of argument index: %!(BADINDEX)
	Printf("%*[2]d", 7):       %!d(BADINDEX)
	Printf("%.[2]d", 7):       %!d(BADINDEX)

所有错误均以字符串"%!"开头. 有时后面跟一个字符(动词),并以括号括起来.

如果Error或String方法在由打印例程调用时触发了紧急情况,则fmt软件包会重新格式化来自紧急情况的错误消息,并用表明它来自fmt软件包的指示来装饰它. 例如,如果String方法调用panic(" bad"),则生成的格式化消息看起来像

%!s(PANIC=bad)

%!s仅显示发生故障时正在使用的打印动词. 但是,如果恐慌是由nil接收者导致Error或String方法引起的,则输出为未经修饰的字符串" <nil>".

Scanning

一组类似的函数会扫描格式化的文本以产生值. 从os.Stdin读取Scan,Scanf和Scanln; Fscan,Fscanf和Fscanln从指定的io.Reader读取; 从参数字符串读取Sscan,Sscanf和Sscanln.

Scan,Fscan,Sscan将输入中的换行符视为空格.

Scanln,Fscanln和Sscanln停止在换行符处进行扫描,并要求在这些项目之后加上换行符或EOF.

Scanf,Fscanf和Sscanf根据类似于Printf的格式字符串解析参数. 在下面的文本中,"空格"表示除换行符外的任何Unicode空格字符.

在格式字符串中,由%字符引入的动词消耗并解析输入; 这些动词将在下面更详细地描述. 格式中除%,空格或换行符以外的其他字符将完全使用该输入字符,该字符必须存在. 格式字符串中包含零个或多个空格的换行符会在输入中消耗零个或多个空格,后跟一个换行符或输入结尾. 格式字符串中换行符后的空格在输入中消耗零个或多个空格. 否则,格式字符串中任何一个或多个空格的运行都会在输入中消耗尽可能多的空格. 除非格式字符串中的空格行与换行符相邻,否则该行必须占用输入中至少一个空格或找到输入的结尾.

The handling of spaces and newlines differs from that of C's scanf family: in C, newlines are treated as any other space, and it is never an error when a run of spaces in the format string finds no spaces to consume in the input.

这些动词的行为类似于Printf的行为. 例如,%x将扫描一个整数作为十六进制数,%v将扫描默认表示形式的值. 未实现Printf动词%p和%T以及标志#和+. 对于浮点和复数值,所有有效的格式化动词(%b%e%E%E%f%F%g%G%x%X和%v)都是等效的,并且接受十进制和十六进制表示法(例如:" 2.3 e + 7"," 0x4.5p-8")和数字分隔的下划线(例如:" 3.14159_26535_89793").

动词处理的输入是隐式用空格分隔的:除%c外,每个动词的实现都从丢弃其余输入中的前导空格开始,并且%s动词(和%v读入字符串)停止在第一个空格或第二个空格处占用输入换行符.

扫描不带格式或带有%v动词的整数时,可以接受熟悉的基本设置前缀0b(二进制),0o和0(八进制)和0x(十六进制),以数字分隔的下划线也是如此.

宽度在输入文本中解释,但是没有用于精确扫描的语法(没有%5.2f,只有%5f). 如果提供了width,它将在修剪前导空格后应用,并指定要满足动词阅读的最大符文数. 例如,

Sscanf(" 1234567 ", "%5s%d", &s, &i)

会将s设置为" 12345",将i设置为67

Sscanf(" 12 34 567 ", "%5s%d", &s, &i)

将s设置为" 12",将i设置为34.

在所有扫描功能中,回车符后紧跟换行符被视为普通换行符(\ r \ n表示与\ n相同).

在所有扫描功能中,如果操作数实现了Scan方法(即,它实现了Scanner接口),则该方法将用于扫描该操作数的文本. 另外,如果扫描的参数数量小于提供的参数数量,则会返回错误.

所有要扫描的参数都必须是指向Scanner接口的基本类型或实现的指针.

像Scanf和Fscanf一样,Sscanf不需要消耗其全部输入. 无法恢复Sscanf使用了多少输入字符串.

注意:Fscan等可以读取返回的输入后的一个字符(符文),这意味着调用扫描例程的循环可能会跳过某些输入. 仅当输入值之间没有空格时,这通常是一个问题. 如果提供给Fscan的阅读器实现了ReadRune,则该方法将用于读取字符. 如果阅读器还实现了UnreadRune,则将使用该方法保存字符,并且后续调用不会丢失数据. 要将ReadRune和UnreadRune方法附加到没有该功能的阅读器,请使用bufio.NewReader.

示例(格式)

这些示例说明了使用格式字符串进行打印的基础. Printf,Sprintf和Fprintf都采用格式字符串,该字符串指定如何格式化后续参数. 例如,%d(我们称其为"动词")说要打印相应的参数,该参数必须是整数(或包含整数的东西,例如int切片),以十进制表示. 动词%v(" v"表示"值")始终以默认格式设置参数格式,就像Print或Println会如何显示它一样. 特殊动词%T(" T"表示"类型")将打印参数的类型,而不是其值. 这些例子并不详尽. 有关所有详细信息,请参见软件包注释.

23
23
23
int *int
true true
42 42 2a 52 101010
3.141592653589793 3.141592653589793 3.14 (  3.14) 3.141593e+00
(110.7+22.5i) (110.7+22.5i) (110.70+22.50i) (1.11e+02+2.25e+01i)
128512 128512 😀 '😀' U+1F600 U+1F600 '😀'
foo "bar" foo "bar" "foo \"bar\"" `foo "bar"`
map[dachshund:false peanut:true] map[string]bool{"dachshund":false, "peanut":true}
{Kim 22} {Name:Kim Age:22} struct { Name string; Age int }{Name:"Kim", Age:22}
&{Kim 22} 0x0
[Kitano Kobayashi Kurosawa Miyazaki Ozu] ["Kitano" "Kobayashi" "Kurosawa" "Miyazaki" "Ozu"]
[Kitano Kobayashi Kurosawa] ["Kitano" "Kobayashi" "Kurosawa"] []string{"Kitano", "Kobayashi", "Kurosawa"}
[97 226 140 152] [97 226 140 152] a⌘ "a⌘" 61e28c98 61 e2 8c 98
1973-11-29 21:33:09 +0000 UTC "1973-11-29 21:33:09 +0000 UTC"

示例(打印机)

Print, Println, and Printf lay out their arguments differently. In this example we can compare their behaviors. Println always adds blanks between the items it prints, while Print adds blanks only between non-string arguments and Printf does exactly what it is told. Sprint, Sprintln, Sprintf, Fprint, Fprintln, and Fprintf behave the same as their corresponding Print, Println, and Printf functions shown here.

The vector (3 4) has length 5.
The vector ( 3 4 ) has length 5 .
The vector (3 4) has length 5.

func Errorf

func Errorf(format string, a ...interface{}) error

Errorf根据格式说明符设置格式,并将字符串作为满足错误的值返回.

如果格式说明符包含带有错误操作数的%w动词,则返回的错误将实现Unwrap方法,以返回操作数. 包含多个%w动词或向其提供未实现错误接口的操作数是无效的. 另外,%w动词是%v的同义词.

Example

Errorf函数使我们可以使用格式设置功能来创建描述性错误消息.

user "bueller" (id 17) not found

func Fprint

func Fprint(w io.Writer, a ...interface{}) (n int, err error)

Fprint的操作数使用默认格式进行格式化并写入w. 当都不是字符串时,在操作数之间添加空格. 它返回已写入的字节数以及遇到的任何写入错误.

Example

Kim is 22 years old.
21 bytes written.

func Fprintf

func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)

Fprintf根据格式说明符格式化并写入w. 它返回已写入的字节数以及遇到的任何写入错误.

Example

Kim is 22 years old.
21 bytes written.

func Fprintln

func Fprintln(w io.Writer, a ...interface{}) (n int, err error)

Fprintln格式使用其操作数的默认格式并写入w. 始终在操作数之间添加空格,并添加换行符. 它返回已写入的字节数以及遇到的任何写入错误.

Example

Kim is 22 years old.
21 bytes written.

func Fscan

func Fscan(r io.Reader, a ...interface{}) (n int, err error)

Fscan扫描从r读取的文本,并将连续的以空格分隔的值存储到连续的参数中. 换行符算作空格. 它返回成功扫描的项目数. 如果该数目少于参数数目,则err将报告原因.

func Fscanf

func Fscanf(r io.Reader, format string, a ...interface{}) (n int, err error)

Fscanf扫描从r读取的文本,将连续的以空格分隔的值存储到由格式确定的连续的参数中. 它返回成功解析的项目数. 输入中的换行符必须与格式中的换行符匹配.

Example

5 true gophers
3

func Fscanln

func Fscanln(r io.Reader, a ...interface{}) (n int, err error)

Fscanln与Fscan类似,但是Fscanln在换行符处停止扫描,并且在最后一个项目之后必须有换行符或EOF.

Example

3: dmr, 1771, 1.618034
3: ken, 271828, 3.141590

func Print

func Print(a ...interface{}) (n int, err error)

使用其操作数的默认格式打印格式并写入标准输出. 当都不是字符串时,在操作数之间添加空格. 它返回已写入的字节数以及遇到的任何写入错误.

Example

Kim is 22 years old.

func Printf

func Printf(format string, a ...interface{}) (n int, err error)

Printf根据格式说明符设置格式并写入标准输出. 它返回已写入的字节数以及遇到的任何写入错误.

Example

Kim is 22 years old.

func Println

func Println(a ...interface{}) (n int, err error)

Println格式使用其操作数的默认格式并写入标准输出. 始终在操作数之间添加空格,并添加换行符. 它返回已写入的字节数以及遇到的任何写入错误.

Example

Kim is 22 years old.

func Scan

func Scan(a ...interface{}) (n int, err error)

扫描会扫描从标准输入读取的文本,并将连续的以空格分隔的值存储到连续的参数中. 换行符算作空格. 它返回成功扫描的项目数. 如果该数目少于参数数目,则err将报告原因.

func Scanf

func Scanf(format string, a ...interface{}) (n int, err error)

Scanf扫描从标准输入读取的文本,将连续的空格分隔的值存储到由格式确定的连续的参数中. 它返回成功扫描的项目数. 如果该数目少于参数数目,则err将报告原因. 输入中的换行符必须与格式中的换行符匹配. 一个例外:动词%c始终扫描输入中的下一个符文,即使它是空格(或制表符等)或换行符也是如此.

func Scanln

func Scanln(a ...interface{}) (n int, err error)

Scanln与Scan相似,但是在换行符处停止扫描,并且在最后一个项目之后必须有换行符或EOF.

func Sprint

func Sprint(a ...interface{}) string

使用默认格式为其操作数设置Sprint格式,并返回结果字符串. 当都不是字符串时,在操作数之间添加空格.

Example

Kim is 22 years old.

func Sprintf

func Sprintf(format string, a ...interface{}) string

Sprintf根据格式说明符设置格式,并返回结果字符串.

Example

Kim is 22 years old.

func Sprintln

func Sprintln(a ...interface{}) string

Sprintln使用其操作数的默认格式进行格式化,并返回结果字符串. 始终在操作数之间添加空格,并添加换行符.

Example

Kim is 22 years old.

func Sscan

func Sscan(str string, a ...interface{}) (n int, err error)

Sscan扫描参数字符串,将连续的以空格分隔的值存储到连续的参数中. 换行符算作空格. 它返回成功扫描的项目数. 如果该数目少于参数数目,则err将报告原因.

func Sscanf

func Sscanf(str string, format string, a ...interface{}) (n int, err error)

Sscanf扫描参数字符串,将连续的以空格分隔的值存储到由格式确定的连续的参数中. 它返回成功解析的项目数. 输入中的换行符必须与格式中的换行符匹配.

Example

2: Kim, 22

func Sscanln

func Sscanln(str string, a ...interface{}) (n int, err error)

Sscanln与Sscan类似,但是Sscanln在换行符处停止扫描,并且在最后一个项目之后必须有换行符或EOF.

type Formatter

Formatter is the interface implemented by values with a custom formatter. The implementation of Format may call Sprint(f) or Fprint(f) etc. to generate its output.

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

type GoStringer

GoStringer由具有GoString方法的任何值实现,该方法定义该值的Go语法. GoString方法用于将作为操作数传递的值打印为%#v格式.

type GoStringer interface {
    GoString() string
}

Example

Person{Name: "Warren", Age: 31, Addr: &Address{City: "Denver", State: "CO", Country: "U.S.A."}}
Person{Name: "Theia", Age: 4}

type ScanState

ScanState表示传递给自定义扫描仪的扫描仪状态. 扫描程序可以一次扫描符文,或要求ScanState发现下一个以空格分隔的令牌.

type ScanState interface {
    // ReadRune reads the next rune (Unicode code point) from the input.
    // If invoked during Scanln, Fscanln, or Sscanln, ReadRune() will
    // return EOF after returning the first '\n' or when reading beyond
    // the specified width.
    ReadRune() (r rune, size int, err error)
    // UnreadRune causes the next call to ReadRune to return the same rune.
    UnreadRune() error
    // SkipSpace skips space in the input. Newlines are treated appropriately
    // for the operation being performed; see the package documentation
    // for more information.
    SkipSpace()
    // Token skips space in the input if skipSpace is true, then returns the
    // run of Unicode code points c satisfying f(c).  If f is nil,
    // !unicode.IsSpace(c) is used; that is, the token will hold non-space
    // characters. Newlines are treated appropriately for the operation being
    // performed; see the package documentation for more information.
    // The returned slice points to shared data that may be overwritten
    // by the next call to Token, a call to a Scan function using the ScanState
    // as input, or when the calling Scan method returns.
    Token(skipSpace bool, f func(rune) bool) (token []byte, err error)
    // Width returns the value of the width option and whether it has been set.
    // The unit is Unicode code points.
    Width() (wid int, ok bool)
    // Because ReadRune is implemented by the interface, Read should never be
    // called by the scanning routines and a valid implementation of
    // ScanState may choose always to return an error from Read.
    Read(buf []byte) (n int, err error)
}

type Scanner

扫描程序由具有Scan方法的任何值实现,该方法将扫描输入以表示值的形式并将结果存储在接收器中,接收器必须是有用的指针. 对于实现该方法的Scan,Scanf或Scanln的任何参数,调用Scan方法.

type Scanner interface {
    Scan(state ScanState, verb rune) error
}

type State

状态代表传递给自定义格式器的打印机状态. 它提供对io.Writer接口的访问以及有关操作数的格式说明符的标志和选项的信息.

type State interface {
    // Write is the function to call to emit formatted output to be printed.
    Write(b []byte) (n int, err error)
    // Width returns the value of the width option and whether it has been set.
    Width() (wid int, ok bool)
    // Precision returns the value of the precision option and whether it has been set.
    Precision() (prec int, ok bool)

    // Flag reports whether the flag c, a character, has been set.
    Flag(c int) bool
}

type Stringer

Stringer由具有String方法的任何值实现,该方法定义该值的"本机"格式. String方法用于将作为操作数传递的值打印为可接受字符串的任何格式,或打印至未格式化的打印机(如Print).

type Stringer interface {
    String() string
}

Example

Gopher (2)

by  ICOPY.SITE