fmt 包实现了类似C#语言 Console.Writeline 和 Console.ReadLine 的格式化I/O。主要分为输出内容和获取输入两部分。

输出#

标准库 fmt 提供了以下几种输出相关函数。

Print#

Print 系列函数会将内容输出到系统的标准输出，区别在于Print函数直接输出内容，Printf函数支持格式化输出字符串，Println 函数会在输出内容的结尾添加一个换行符。

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

示例：

func fmtPrint() {
	fmt.Print("在终端打印该信息")
	name := "wangpengliang"
	fmt.Printf("我是：%s\n", name)
	fmt.Println("在终端打印单独一行显示")
}

输出：

在终端打印该信息我是：wangpengliang
在终端打印单独一行显示

Fprint#

Fprint 系列函数会将内容输出到一个 io.Writer 接口类型的变量 w 中，通常用这个函数往文件中写入内容。

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

示例：

func fmtFprint() {
	// 向标准输出写入内容
	fmt.Fprintln(os.Stdout, "向标准输出写入内容")
	fileObj, err := os.OpenFile("./fprintTest.txt", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
	if err != nil {
		fmt.Println("打开文件出错，err:", err)
		return
	}
	name := "wangpengliang"
	// 向打开的文件句柄中写入内容
	fmt.Fprintf(fileObj, "往文件中写入信息：%s", name)
}

注意：只要满足 io.Writer 接口的类型都支持写入。

Sprint#

Sprint系列函数会把传入的数据生成并返回一个字符串。

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

示例：

func fmtSprint() {
	s := "wangpengliang"
	s1 := fmt.Sprint(s)

	s2 := fmt.Sprintf("name:%s,age:%d", "wangpengliang", 18)

	fmt.Println(s1, s2)
}

Errorf#

Errorf 函数根据 format 参数生成格式化字符串并返回一个包含该字符串的错误。

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

通常使用这种方式来自定义错误类型，例如：

err := fmt.Errorf("这是一个错误")

Go1.13 版本为 fmt.Errorf 函数新加了一个%w占位符用来生成一个可以包裹 Error 的 Wrapping Error 。

func errorof() {
	e := errors.New("原始错误e")
	w := fmt.Errorf("Wrap了一个错误%w", e)
	fmt.Println(w)
}

格式化占位符#

*printf 系列函数都支持 format 格式化参数，这里按照占位符将被替换的变量类型划分，方便查询和记忆。

%v，原样输出
%T，打印类型
%t，bool类型
%s，字符串
%f，浮点
%d，10进制的整数
%b，2进制的整数
%o，8进制
%x，%X，16进制
%x：0-9，a-f
%X：0-9，A-F
%c，打印字符
%p，打印内存地址

通用占位符#

占位符说明
%v值的默认格式表示
%+v类似%v，但输出结构体时会添加字段名
%#v值的Go语法表示
%T打印值的类型
%%百分号

示例：

func generalPlaceholder() {
	fmt.Printf("%v\n", 100)   // %v：默认格式输出
	fmt.Printf("%v\n", false) // %v：默认格式输出
	o := struct{ name string }{"wangpengliang"}
	fmt.Printf("%v\n", o)
	fmt.Printf("%+v\n", o) // %+v：类似%v，但输出结构体时会添加字段名
	fmt.Printf("%#v\n", o) // %#v：值的Go语法表示
	fmt.Printf("%T\n", o)  // %T：打印值的类型
	fmt.Printf("100%%\n")  // %%：百分号
}

输出：

100
false
{wangpengliang}
{name:wangpengliang}
struct { name string }{name:"wangpengliang"}
struct { name string }
100%

布尔型#

占位符说明
%ttrue或false

整型#

占位符说明
%b表示为二进制
%c该值对应的unicode码值
%d表示为十进制
%o表示为八进制
%x表示为十六进制，使用a-f
%X表示为十六进制，使用A-F
%U表示为Unicode格式：U+1234，等价于”U+%04X”
%q该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示

示例：

func intPlaceholderTest() {
	n := 65
	fmt.Printf("%b\n", n) // %b：二进制输出
	fmt.Printf("%c\n", n) // %c：输出对应的unicode编码
	fmt.Printf("%d\n", n) // %d:十进制输出
	fmt.Printf("%o\n", n) // %o:八进制输出
	fmt.Printf("%x\n", n) // %x:十六进制输出,使用a-f
	fmt.Printf("%X\n", n) // %X:十六进制输出，使用A-F
}

输出：

1000001
A  
65 
101
41 
41

浮点数与复数#

占位符说明
%b无小数部分、二进制指数的科学计数法，如-123456p-78
%e科学计数法，如-1234.456e+78
%E科学计数法，如-1234.456E+78
%f有小数部分但无指数部分，如123.456
%F等价于%f
%g根据实际情况采用%e或%f格式（以获得更简洁、准确的输出）
%G根据实际情况采用%E或%F格式（以获得更简洁、准确的输出）

示例：

func floatPlaceholder() {
	f := 12.34
	fmt.Printf("%b\n", f) // %b：无小数部分、二进制指数的科学计数法
	fmt.Printf("%e\n", f) // %e: 科学计数法,如-1234.456e+78
	fmt.Printf("%E\n", f) // %E: 科学计数法,如-1234.456E+78
	fmt.Printf("%f\n", f) // %f: 有小数部分但无指数部分，如123.456
	fmt.Printf("%g\n", f) // %g: 根据实际情况采用%e或%f格式（以获得更简洁、准确的输出）
	fmt.Printf("%G\n", f) // %G: 根据实际情况采用%E或%F格式（以获得更简洁、准确的输出）
}

输出：

6946802425218990p-49
1.234000e+01
1.234000E+01
12.340000   
12.34       
12.34

字符串和[]byte#

占位符说明
%s直接输出字符串或者[]byte
%q该值对应的双引号括起来的go语法字符串字面值，必要时会采用安全的转义表示
%x每个字节用两字符十六进制数表示（使用a-f)
%X每个字节用两字符十六进制数表示（使用A-F）

示例：

func stringPlaceholder() {
	s := "wangpengliang"
	fmt.Printf("%s\n", s) // %s：直接输出字符串或者[]byte
	fmt.Printf("%q\n", s) // %q: 该值对应的双引号括起来的go语法字符串字面值，必要时会采用安全的转义表示
	fmt.Printf("%x\n", s) // %x: 每个字节用两字符十六进制数表示（使用a-f)
	fmt.Printf("%X\n", s) // %X: 每个字节用两字符十六进制数表示（使用A-F)
}

输出：

wangpengliang
"wangpengliang"
77616e6770656e676c69616e67
77616E6770656E676C69616E67

指针#

占位符说明
%p表示为十六进制，并加上前导的0x

示例代码如下：

func pointerPlaceholder() {
	a := 10
	fmt.Printf("%p\n", &a)
	fmt.Printf("%#p\n", &a)
}

输出结果如下：

0xc000012088
c000012088

宽度标识符#

宽度通过一个紧跟在百分号后面的十进制数指定，如果未指定宽度，则表示值时除必需之外不作填充。精度通过（可选的）宽度后跟点号后跟的十进制数指定。如果未指定精度，会使用默认精度；如果点号后没有跟数字，表示精度为0。举例如下：

占位符说明
%f默认宽度，默认精度
%9f宽度9，默认精度
%.2f默认宽度，精度2
%9.2f宽度9，精度2
%9.f宽度9，精度0

示例：

func breadth() {
	n := 12.34
	fmt.Printf("%f\n", n)
	fmt.Printf("%9f\n", n)
	fmt.Printf("%.2f\n", n)
	fmt.Printf("%9.2f\n", n)
	fmt.Printf("%9.f\n", n)
}

输出：

12.340000
12.340000
12.34    
    12.34
       12

其他flag#

占位符说明
’+’总是输出数值的正负号；对%q（%+q）会生成全部是ASCII字符的输出（通过转义）
’ ‘对数值，正数前加空格而负数前加负号；对字符串采用%x或%X时（% x或% X）会给各打印的字节之间加空格
’-’在输出右边填充空白而不是默认的左边（即从默认的右对齐切换为左对齐）
’#’八进制数前加0（%#o），十六进制数前加0x（%#x）或0X（%#X），指针去掉前面的0x（%#p）对%q（%#q），对%U（%#U）会输出空格和单引号括起来的go字面值
‘0’使用0而不是空格填充，对于数值类型会把填充的0放在正负号后面

示例：

func otherPlaceholder() {
	s := "wangpengliang"
	fmt.Printf("%s\n", s)
	fmt.Printf("%5s\n", s)
	fmt.Printf("%-5s\n", s)
	fmt.Printf("%5.7s\n", s)
	fmt.Printf("%-5.7s\n", s)
	fmt.Printf("%5.2s\n", s)
	fmt.Printf("%05s\n", s)
}

输出：

wangpengliang
wangpengliang
wangpengliang
wangpen      
wangpen
   wa
wangpengliang

获取输入#

Go语言fmt包下有fmt.Scan、fmt.Scanf、fmt.Scanln三个函数，可以在程序运行过程中从标准输入获取用户的输入。

fmt.Scan#

函数签名如下：

func Scan(a ...interface{}) (n int, err error)
  • Scan从标准输入扫描文本，读取由空白符分隔的值保存到传递给本函数的参数中，换行符视为空白符
  • 本函数返回成功扫描的数据个数和遇到的任何错误。如果读取的数据个数比提供的参数少，会返回一个错误报告原因

示例：

func fmtScan() {
	fmt.Println("please input you name")
	var input string
	fmt.Scanln(&input) //读取键盘输入，通过操作地址赋值给input.阻塞式
	fmt.Println("you name is：" + input)

	fmt.Println("please input you name,age,sex")
	var (
		name string
		age  int
		sex  bool
	)
	fmt.Scan(&name, &age, &sex)
	fmt.Printf("扫描结果 name:%s age:%d sex:%t \n", name, age, sex)
}
please input you name
wangpengliang
you name is：wangpengliang   
please input you name,age,sex
wangpengliang 18 true
扫描结果 name:wangpengliang age:18 sex:true

fmt.Scan 从标准输入中扫描用户输入的数据，将以空白符分隔的数据分别存入指定的参数。

fmt.Scanf#

函数签名如下：

func Scanf(format string, a ...interface{}) (n int, err error)
  • Scanf从标准输入扫描文本，根据 format 参数指定的格式去读取由空白符分隔的值保存到传递给本函数的参数中
  • 本函数返回成功扫描的数据个数和遇到的任何错误

示例：

func fmtScanf() {
	var (
		name string
		age  int
		sex  bool
	)
	fmt.Scanf("1:%s 2:%d 3:%t", &name, &age, &sex)
	fmt.Printf("扫描结果 name:%s age:%d sex:%t \n", name, age, sex)
}

将上面的代码编译后在终端执行，在终端按照指定的格式依次输入1:wpl 2:18 3:true。

PS D:\GoProject\src\golang.basic> go run .\fmtTest.go
1:wpl 2:18 3:true
扫描结果 name:wpl age:18 sex:true

fmt.Scanf 不同于 fmt.Scan 简单的以空格作为输入数据的分隔符，fmt.Scanf 为输入数据指定了具体的输入内容格式，只有按照格式输入数据才会被扫描并存入对应变量。

fmt.Scanln#

函数签名如下：

func Scanln(a ...interface{}) (n int, err error)
  • Scanln类似Scan，它在遇到换行时才停止扫描。最后一个数据后面必须有换行或者到达结束位置
  • 本函数返回成功扫描的数据个数和遇到的任何错误

示例：

func fmtScanlnfTest() {
	var (
		name string
		age  int
		sex  bool
	)
	fmt.Scanln(&name, &age, &sex)
	fmt.Printf("扫描结果 name:%s age:%d sex:%t \n", name, age, sex)
}

将上面的代码编译后在终端执行，在终端依次输入1、2和false使用空格分隔。

PS D:\GoProject\src\golang.basic> go run .\fmtTest.go
1 2 false
扫描结果 name:1 age:2 sex:false

fmt.Scanln 遇到回车就结束扫描了，这个比较常用。

bufio.NewReader#

有时候需要完整获取输入的内容，而输入的内容可能包含空格，这种情况下可以使用 bufio 包来实现。比如：

func bufioTest() {
	reader := bufio.NewReader(os.Stdin) // 从标准输入生成读对象
	fmt.Print("请输入内容：")
	text, _ := reader.ReadString('\n') // 读到换行
	text = strings.TrimSpace(text)
	fmt.Printf("%#v\n", text)
}
请输入内容：1 2 3 43 435
"1 2 3 43 435"

Fscan 系列#

这几个函数功能分别类似于 fmt.Scan、fmt.Scanf、fmt.Scanln三个函数，只不过它们不是从标准输入中读取数据而是从 io.Reader 中读取数据。

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

Sscan 系列#

这几个函数功能分别类似于 fmt.Scan 、 fmt.Scanf 、fmt.Scanln 三个函数，只不过它们不是从标准输入中读取数据而是从指定字符串中读取数据。

func Sscan(str string, a ...interface{}) (n int, err error)
func Sscanln(str string, a ...interface{}) (n int, err error)
func Sscanf(str string, format string, a ...interface{}) (n int, err error)
Backward Flag Log Forward