go fmt包详解

fmt包实现了格式化I/O。主要分为向外输出内容和获取输入内容两大部分

一 向外输出

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

1.1 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)
1
2
3

举个简单的例子：

func main() {
	fmt.Print("lxx is NB")
	name := "lxx"
	fmt.Printf("我是：%s\n", name)
	fmt.Println("打印并换行")
}
1
2
3
4
5
6

执行上面的代码输出：

lxx is NB我是：lxx
打印并换行
1
2

1.2 格式化输出占位符

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

通用占位符

示例代码如下：

	fmt.Printf("名字是：%v\n","lxx")
	fmt.Printf("年龄是：%v\n",19)
	p:= struct {
		name string
		age int
	}{"lxx",19}
	fmt.Printf("结构体内容为：%v\n",p)
	fmt.Printf("结构体内容为(带字段名)：%+v\n",p) // 输出结构体是会带name
	fmt.Printf("结构体内容为(值的Go语法表示)：%#v\n",p) // 输出结构体是会带name


	fmt.Printf("切片内容为：%v\n",[]int{4,5,6})
	fmt.Printf("切片内容为(值的Go语法表示)：%#v\n",[]int{4,5,6})

	fmt.Printf("切片值的类型为：%T\n",[]int{4,5,6})
	fmt.Printf("字符串值的类型为：%T\n","lxx")

	fmt.Printf("打印百分百：100%%\n")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

输出结果如下：

名字是：lxx
年龄是：19
结构体内容为：{lxx 19}
结构体内容为(带字段名)：{name:lxx age:19}
结构体内容为(值的Go语法表示)：struct { name string; age int }{name:"lxx", age:19}
切片内容为：[4 5 6]
切片内容为(值的Go语法表示)：[]int{4, 5, 6}
切片值的类型为：[]int
字符串值的类型为：string
打印百分百：100%

1
2
3
4
5
6
7
8
9
10
11

布尔型

var limit bool = false;
fmt.Printf("limit=%t \n",limit)
1
2

整型

示例代码如下：

	n := 3333
	fmt.Printf("二进制表示：%b\n", n)
	fmt.Printf("unicode对应的字符：%c\n", n)
	fmt.Printf("十进制表示：%d\n", n)
	fmt.Printf("八进制表示：%o\n", 9)
	fmt.Printf("十六进制小写：%x\n", 123)
	fmt.Printf("十六进制大写：%X\n", 123)
	fmt.Printf("用引号引起来的字符字面值：%q\n", 65)
1
2
3
4
5
6
7
8

输出结果如下：

二进制表示：110100000101
unicode对应的字符：അ
十进制表示：3333
八进制表示：11
十六进制小写：7b
十六进制大写：7B
用引号引起来的字符字面值：'A'
1
2
3
4
5
6
7

浮点数与复数

示例代码如下：

	f := 3.14159
	fmt.Printf("无小数部分、二进制指数的科学计数法，(如-123456p-78):%b\n", f)
	fmt.Printf("科学计数法(-1234.456e+78)：%e\n", f)
	fmt.Printf("科学计数法(如-1234.456E+78)：%E\n", f)
	fmt.Printf("有小数部分但无指数部分:%f\n", f)
	fmt.Printf("有小数部分但无指数部分:%F\n", f)
	fmt.Printf("根据实际情况采用%%g或%%G格式（以获得更简洁、准确的输出）:%g\n", f)
	fmt.Printf("根据实际情况采用%%g或%%G格式（以获得更简洁、准确的输出）:%G\n", f)
1
2
3
4
5
6
7
8

输出结果如下：

无小数部分、二进制指数的科学计数法，(如-123456p-78):7074231776675438p-51
科学计数法(-1234.456e+78)：3.141590e+00
科学计数法(如-1234.456E+78)：3.141590E+00
有小数部分但无指数部分:3.141590
有小数部分但无指数部分:3.141590
根据实际情况采用%g或%G格式（以获得更简洁、准确的输出）:3.14159
根据实际情况采用%g或%G格式（以获得更简洁、准确的输出）:3.14159

1
2
3
4
5
6
7
8

字符串和[]byte

示例代码如下：

	name:="lxx"
	b:=[]byte{'l','x','x',65}
	fmt.Printf("字符串为：%s\n",name)
	fmt.Printf("切片为：%s\n",b)

	fmt.Printf("双引号括起来的go语法字符串字面值：%q\n",name)
	fmt.Printf("双引号括起来的go语法字符串字面值：%q\n",b)

	fmt.Printf("每个字节用两字符十六进制数表示：%x\n",name)
	fmt.Printf("每个字节用两字符十六进制数表示：%x\n",b)

	fmt.Printf("每个字节用两字符十六进制数表示（使用a-f）：%X\n",name)
	fmt.Printf("每个字节用两字符十六进制数表示（使用A-F）：%X\n",b)
1
2
3
4
5
6
7
8
9
10
11
12
13

输出结果如下：

字符串为：lxx
切片为：lxxA
双引号括起来的go语法字符串字面值："lxx"
双引号括起来的go语法字符串字面值："lxxA"
每个字节用两字符十六进制数表示：6c717a
每个字节用两字符十六进制数表示：6c717a41
每个字节用两字符十六进制数表示（使用a-f）：6c717a
每个字节用两字符十六进制数表示（使用A-F）：6C717A41
1
2
3
4
5
6
7
8

指针

示例代码如下：

	a := 99
	fmt.Printf("%p\n", &a)
	fmt.Printf("%#p\n", &a)
1
2
3

输出结果如下：

0xc000018078
c000018078
1
2

宽度标识符

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

示例代码如下：

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)
1
2
3
4
5
6

输出结果如下：

默认宽度，默认精度:3.141593
宽度9，默认精度: 3.141593
默认宽度，精度2:3.14
宽度9，精度2:     3.14
宽度9，精度0:        3

1
2
3
4
5
6

其他flag

举个例子：

	s := "小王子"
	fmt.Printf("正常字符串输出：%s\n", s)
	fmt.Printf("宽度是5，右对齐：%5s\n", s)
	fmt.Printf("宽度是5，左对齐：%-5s\n", s)
	fmt.Printf("总长度为3,截取2个，右对齐：%3.2s\n", s)
	fmt.Printf("总长度为3,截取2个，左对齐：%-3.2s\n", s)
	fmt.Printf("宽度为5，只要2个字符：%5.2s\n", s)
	fmt.Printf("宽度为5，不够用0补齐：%05s\n", s)
1
2
3
4
5
6
7
8

输出结果如下：

正常字符串输出：小王子
宽度是5，右对齐：  小王子
宽度是5，左对齐：小王子  
总长度为3,截取2个，右对齐： 刘清
总长度为3,截取2个，左对齐：刘清 
宽度为5，只要2个字符：   刘清
宽度为5，不够用0补齐：00小王子
1
2
3
4
5
6
7

1.3 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)
1
2
3

举个例子：

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

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

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

1.4 Sprint

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

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

简单的示例代码如下：

	s1 := fmt.Sprint("lxx")
	name := "lxx"
	age := 18
	s2 := fmt.Sprintf("姓名:%s,年龄:%d", name, age)
	s3 := fmt.Sprintln("lxx is nb")
	fmt.Println(s1, s2, s3)
1
2
3
4
5
6

lxx 姓名:lxx,年龄:18 lxx is nb
1

1.5 Errorf

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

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

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

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

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

e := errors.New("原始错误e")
w := fmt.Errorf("Wrap了一个错误%w", e)
1
2

	err := fmt.Errorf("这是一个错误")
	fmt.Printf("类型是：%T，值是：%v",err,err)
	fmt.Println("-----")
	e := errors.New("原始错误e")
	w := fmt.Errorf("Wrap了一个错误：%w", e)
	fmt.Println(w)
1
2
3
4
5
6

类型是：*errors.errorString，值是：这是一个错误-----
Wrap了一个错误：原始错误e

1
2
3

二 获取输入

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

2.1 fmt.Scan

函数定签名如下：

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

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

具体代码示例如下：

	var (
		name string
		age  int
	)
	fmt.Scan(&name, &age)
	fmt.Printf("输入的值为： 姓名:%s 年龄:%d \n", name, age)
1
2
3
4
5
6

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

lxx 19
// 或者
lxx
19
1
2
3
4

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

2.2 fmt.Scanf

函数签名如下：

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

• Scanf从标准输入扫描文本，根据format参数指定的格式去读取由空白符分隔的值保存到传递给本函数的参数中。
• 本函数返回成功扫描的数据个数和遇到的任何错误。

代码示例如下：

var (
		name string
		age  int
	)
	fmt.Scanf("name:%s age:%d", &name, &age) // 在控制台按照该格式输入
	fmt.Printf("扫描结果： 姓名:%s 年龄:%d \n", name, age)
1
2
3
4
5
6

将上面的代码编译后在终端执行，在终端按照指定的格式依次输入小王子、28和false。

// 控制台按如下格式输入
name:lxx age:19
扫描结果： 姓名:lxx 年龄:19 
1
2
3

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

例如，我们还是按照上个示例中以空格分隔的方式输入，fmt.Scanf就不能正确扫描到输入的数据。

lxx 19
扫描结果： 姓名: 年龄:0 
1
2

2.3 fmt.Scanln

函数签名如下：

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

• Scanln类似Scan，它在遇到换行时才停止扫描。最后一个数据后面必须有换行或者到达结束位置。
• 本函数返回成功扫描的数据个数和遇到的任何错误。

具体代码示例如下：

var (
		name    string
		age     int
	)
fmt.Scanln(&name, &age)
fmt.Printf("扫描结果 姓名:%s 年龄:%d \n", name, age)
1
2
3
4
5
6

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

//输入：   小王子 19  敲回车
扫描结果 姓名:小王子 年龄:19 
1
2

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

2.4 bufio.NewReader

有时候我们想完整获取输入的内容，而输入的内容可能包含空格，这种情况下可以使用bufio包来实现。示例代码如下：

reader := bufio.NewReader(os.Stdin) // 从标准输入生成读对象
fmt.Print("请输入内容：")
text, _ := reader.ReadString('\n') // 读到换行
text = strings.TrimSpace(text) // 去掉空白
fmt.Printf("%#v\n", text)
1
2
3
4
5

请输入内容：输入的内容
"输入的内容"

1
2
3

2.5 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)
1
2
3

2.6 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)
1
2
3

var name string="lxx"
var newName string=""
fmt.Sscan(name,&newName) // 相当于把name的值赋值给newName
fmt.Println(name)
fmt.Println(newName)
1
2
3
4
5