fmt库
1. 获取输入
（1）fmt.Scan（常用）
Scan的函数定义： func Scan(a ...interface{}) (n int, err error)
********Scan的返回值一般没啥用，通常不接收。注意：参数为变量地址********
Scan函数返回成功扫描的数据个数和遇到的任何错误。如果读取的数据个数比提供的参数少，会返回一个错误报告原因
********Scan 函数用 空格 和 回车 当作每个输入参数之间的间隔符 ，当回车时，若输入参数的个数不够，仍可以继续输入********
package main
import "fmt"
func main() {
var (
name string
age int
married bool
)
fmt.Print("请输入：")
cnt, res := fmt.Scan(&name, &age, &married) // 直接写成 fmt.Scan(&name, &age, &married) 就行，一般不用接收返回值
fmt.Println("cnt,res", cnt, res)
fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)
}
（2）fmt.Scanln（常用）
同上面的fmt.Scan用法一致，只有一点不同，就是fmt.Scanln方法，在输入参数时，只能以空格作为不同参数之间的间隔符，回车会直接结束输入
Scanln的函数定义： func Scanln(a ...interface{}) (n int, err error)
（3）fmt.Scanf
- 格式化输入，必须与定义的输入内容格式一致，才能被接收
- 在输入参数时，只能以空格作为不同参数之间的间隔符，回车会直接结束输入
package main
import "fmt"
func main() {
var (
name string
age int
married bool
)
fmt.Print("请输入：")
fmt.Scanf("1:%s 2:%d 3:%t", &name, &age, &married)
fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)
}
/*
示例输入： 1:小王子 2:28 3:false
必须按照：1:参数1 2:参数2 3:参数3 来进行输入，且参数类型不能错误，可以漏输右边的部分，不能漏输左边的部分
1:参数1 // 参数1可以被接收到
1:参数1 2:参数2 // 参数1 参数2可以被接收到
2:参数2 // 参数2 不能被接收
*/
2. print、println、printf 输出
- 有
fmt.print、fmt.println、fmt.printf 三种
print就是普通的输出println 会在输出内容的结尾添加一个换行符，即可以自动换行printf 为格式化输出字符串，能识别各种占位符
函数定义：
func Print(a ...interface{}) (n int, err error)
func Println(a ...interface{}) (n int, err error)
func Printf(format string, a ...interface{}) (n int, err error)
简单示例：
package main
import "fmt"
func main() {
fmt.Print("在终端打印该信息。")
name := "沙河小王子"
fmt.Printf("我是：%s\n", name)
fmt.Println("在终端打印单独一行显示")
}
/*
在终端打印该信息。我是：沙河小王子
在终端打印单独一行显示
*/
3. Sprint（了解即可）
Sprint系列函数会把传入的数据生成并返回一个字符串
函数定义：
func Sprint(a ...interface{}) string
func Sprintf(format string, a ...interface{}) string
func Sprintln(a ...interface{}) string
简单示例：
package main
import "fmt"
func main() {
s1 := fmt.Sprint("沙河小王子")
name := "沙河小王子"
age := 18
s2 := fmt.Sprintf("name:%s,age:%d", name, age)
s3 := fmt.Sprintln("沙河小王子") // s3末尾因为Sprintln函数而多了一个换行符
fmt.Println("1111")
fmt.Print(s1, s2, s3) // 这里我们没有换行，而下面的打印结果显示，换行打印了2222
fmt.Println("2222")
}
/*
1111
沙河小王子name:沙河小王子,age:18沙河小王子
2222
*/
4. Errorf（了解即可）
Errorf函数根据format参数生成格式化字符串并返回一个包含该字符串的错误
函数定义： func Errorf(format string, a ...interface{}) error
通常使用这种方式来自定义错误类型，例如：
err := fmt.Errorf("这是一个错误")
5. 格式化占位符
- 掌握常用的几个即可
%% %d %s %p %T %.nf (n为保留的小数个数)，其他当作了解
（1）通用占位符
| 占位符 |
说明 |
| %v |
值的默认格式表示，将值格式化为一个更紧凑的表示形式 |
| %+v |
类似%v，但输出结构体时会添加字段名 |
| %#v |
值的Go语法表示 |
| %T |
打印值的类型 |
| %% |
百分号 |
（2）布尔型占位符
（3）整型占位符
| 占位符 |
说明 |
| %b |
表示为二进制 |
| %c |
该值对应的unicode码值 |
| %d |
表示为十进制 |
| %o |
表示为八进制 |
| %x |
表示为十六进制，使用a-f |
| %X |
表示为十六进制，使用A-F |
| %U |
表示为Unicode格式：U+1234，等价于”U+%04X” |
| %q |
该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示 |
package main
import "fmt"
func main() {
n := 65
fmt.Printf("%b\n", n)
fmt.Printf("%c\n", n)
fmt.Printf("%d\n", n)
fmt.Printf("%o\n", n)
fmt.Printf("%x\n", n)
fmt.Printf("%X\n", n)
}
/*
1000001
A
65
101
41
41
*/
（4）浮点数与复数占位符
| 占位符 |
说明 |
| %b |
无小数部分、二进制指数的科学计数法，如-123456p-78 |
| %e |
科学计数法，如-1234.456e+78 |
| %E |
科学计数法，如-1234.456E+78 |
| %f |
有小数部分但无指数部分，如123.456 |
| %F |
等价于%f |
| %g |
根据实际情况采用%e或%f格式（以获得更简洁、准确的输出） |
| %G |
根据实际情况采用%E或%F格式（以获得更简洁、准确的输出） |
package main
import "fmt"
func main() {
f := 12.34
fmt.Printf("%b\n", f)
fmt.Printf("%e\n", f)
fmt.Printf("%E\n", f)
fmt.Printf("%f\n", f)
fmt.Printf("%g\n", f)
fmt.Printf("%G\n", f)
}
/*
6946802425218990p-49
1.234000e+01
1.234000E+01
12.340000
12.34
12.34
*/
（5）字符串和[]byte占位符
| 占位符 |
说明 |
| %s |
直接输出字符串或者[]byte |
| %q |
该值对应的双引号括起来的go语法字符串字面值，必要时会采用安全的转义表示 |
| %x |
每个字节用两字符十六进制数表示（使用a-f） |
| %X |
每个字节用两字符十六进制数表示（使用A-F） |
package main
import "fmt"
func main() {
s := "王子"
fmt.Printf("%s\n", s)
fmt.Printf("%q\n", s)
fmt.Printf("%x\n", s)
fmt.Printf("%X\n", s)
}
/*
王子
"王子"
e78e8be5ad90
E78E8BE5AD90
*/
（6）指针占位符
| 占位符 |
说明 |
| %p |
表示为十六进制，并加上前导的0x |
| %#p |
表示为十六进制，不加上前导的0x |
package main
import "fmt"
func main() {
a := 10
fmt.Printf("%p\n", &a)
fmt.Printf("%#p\n", &a)
}
// 0xc00000a0d8
// c00000a0d8
（7）宽度标识符
- 宽度通过一个紧跟在百分号后面的十进制数指定，如果未指定宽度，则表示值时除必需之外不作填充。精度通过（可选的）宽度后跟点号后跟的十进制数指定。如果未指定精度，会使用默认精度；如果点号后没有跟数字，表示精度为0。举例如下
- 宽度可以理解为整型部分的长度，精度可以理解为小数的长度
| 占位符 |
说明 |
| %f |
默认宽度，默认精度 |
| %9f |
宽度9，默认精度 |
| %.2f |
默认宽度，精度2 |
| %9.2f |
宽度9，精度2 |
| %9.f |
宽度9，精度0 |
package main
import "fmt"
func main() {
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
*/
（8）其他
| 占位符 |
说明 |
| ’+’ |
总是输出数值的正负号；对%q（%+q）会生成全部是ASCII字符的输出（通过转义） |
| ’ ‘ |
对数值，正数前加空格而负数前加负号；对字符串采用%x或%X时（% x或% X）会给各打印的字节之间加空格 |
| ’-’ |
在输出右边填充空白而不是默认的左边（即从默认的右对齐切换为左对齐） |
| ’#’ |
八进制数前加0（%#o），十六进制数前加0x（%#x）或0X（%#X），指针去掉前面的0x（%#p）对%q（%#q），对%U（%#U）会输出空格和单引号括起来的go字面值 |
| ‘0’ |
使用0而不是空格填充，对于数值类型会把填充的0放在正负号后面 |
package main
import "fmt"
func main() {
s := "王子"
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)
}
/*
王子
王子
王子
王子
王子
王子
000王子
*/
浙公网安备 33010602011771号