• Go 之 fmt 格式化输入输出

    向外输出

    Print

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

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. )
    6.  
    7. func main() {
    8. 	// Print、Printf、Println
    9. 	fmt.Print("在终端打印该信息。") // 内容输出到标准输出
    10. 	name := "Looking"
    11. 	fmt.Printf("我是：%s\n", name) // 支持格式化输出
    12. 	fmt.Println("在终端打印单独一行显示")
    13. }
    1. 在终端打印该信息。我是：Looking
    2. 在终端打印单独一行显示

    Fprint

    Fprint系列函数（Fprint、Fprintf、Fprintln）与 Print 系列函数（Print、Printf、Println）类似，只不过会将内容输出到一个io.Writer接口类型的变量w中，我们通常用这个函数往文件中写入内容。只要满足io.Writer接口的类型都支持写入。

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"os"
    6. )
    7.  
    8. func main() {
    9. 	// Fprint、Fprintf、Fprintln
    10. 	name := "Looking"
    11. 	fmt.Fprint(os.Stdout, "向标准输出写入内容且不换行！")
    12. 	fmt.Fprintln(os.Stdout, "向标准输出写入内容且换行！")
    13. 	fileObj, err := os.Create("./test.txt")
    14. 	if err != nil {
    15. 		fmt.Println("打开文件出错，err:", err)
    16. 		return
    17. 	}
    18.  
    19. 	fmt.Fprintf(fileObj, "往文件中写如信息：%s", name) // 往文件对象输出
    20. 	// 文件: test.txt
    21. 	// 内容：往文件中写如信息：Looking
    22. }
    向标准输出写入内容且不换行！向标准输出写入内容且换行！

    Sprint

    Sprint系列函数（Sprint、Sprintf、Sprintln）与 Print 系列函数（Print、Printf、Println）类似，只不过不会直接输出，而是会把传入的数据生成并返回一个字符串。

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. )
    6.  
    7. func main() {
    8. 	// Sprint、Sprintf、Sprintln
    9. 	name := "Looking"
    10. 	s1 := fmt.Sprint(name) // 返回字符串，字符串末尾不会自动添加换行符
    11. 	fmt.Print(s1)
    12. 	s2 := fmt.Sprintln(name) // 返回字符串，字符串末尾会自动添加换行符
    13. 	fmt.Print(s2)
    14. 	age := 18
    15. 	s3 := fmt.Sprintf("name:%s, age:%d", name, age) // 返回格式化后字符串
    16. 	fmt.Print(s3)
    17. }
    1. LookingLooking
    2. name:Looking, age:18

    Errorf

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

    1. package main
    2.  
    3. import (
    4. 	"errors"
    5. 	"fmt"
    6. )
    7.  
    8. func main() {
    9. 	// Errorf
    10. 	e := errors.New("原始错误e")
    11. 	w := fmt.Errorf("Wrap了一个错误:%w", e) // Wrap了一个错误:原始错误e
    12. 	fmt.Println(w.Error())
    13. }

    获取输入

    Scan

    Scan从标准输入扫描文本。

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. )
    6.  
    7. func main() {
    8. 	var (
    9. 		name    string
    10. 		age     int
    11. 		married bool
    12. 	)
    13. 	fmt.Scan(&name, &age, &married) // 读取由空白符分隔的值保存到传递给本函数的参数中，换行符视为空白符。
    14. 	fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)
    15. 	// 输入：Looking 29 true
    16. 	// 输出：扫描结果 name:Looking age:29 married:true
    17. 	fmt.Scanf("1:%s 2:%d 3:%t", &name, &age, &married) // 根据format参数指定的格式去读取值保存到传递给本函数的参数中。
    18. 	fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)
    19. 	// 输入：1:Looking 2:29 3:true
    20. 	// 输出：扫描结果 name:Looking age:29 married:true
    21. 	fmt.Scanln(&name, &age, &married) // Scanln类似Scan，它在遇到换行时才停止扫描。
    22. 	fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)
    23. 	// 输入：Looking 29 true
    24. 	// 输出：扫描结果 name:Looking age:29 married:true
    25. }

    Fscan

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

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"os"
    6. )
    7.  
    8. func main() {
    9. 	var (
    10. 		name    string
    11. 		age     int
    12. 		married bool
    13. 	)
    14. 	fileObj, err := os.OpenFile("./test.txt", os.O_RDONLY, 0644)
    15. 	if err != nil {
    16. 		fmt.Println("打开文件出错，err:", err)
    17. 		return
    18. 	}
    19. 	fmt.Fscan(fileObj, &name, &age, &married)
    20. 	fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)
    21. 	// test.txt：Looking 29 true
    22. 	// 输出：扫描结果 name:Looking age:29 married:true
    23. 	fmt.Fscanf(fileObj, "1:%s 2:%d 3:%t", &name, &age, &married)
    24. 	fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)
    25. 	// test.txt：1:Looking 2:29 3:true
    26. 	// 输出：扫描结果 name:Looking age:29 married:true
    27. 	fmt.Fscanln(fileObj, &name, &age, &married)
    28. 	fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)
    29. 	// test.txt：Looking 29 true
    30. 	// 输出：扫描结果 name:Looking age:29 married:true
    31. }

    Sscan

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

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. )
    6.  
    7. func main() {
    8. 	var (
    9. 		name    string
    10. 		age     int
    11. 		married bool
    12. 	)
    13.  
    14. 	fmt.Sscan("Looking 29 true", &name, &age, &married)
    15. 	fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)
    16. 	// 输入：Looking 29 true
    17. 	// 输出：扫描结果 name:Looking age:29 married:true
    18. 	fmt.Sscanf("1:Looking 2:29 3:true", "1:%s 2:%d 3:%t", &name, &age, &married)
    19. 	fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)
    20. 	// 输入：1:Looking 2:29 3:true
    21. 	// 输出：扫描结果 name:Looking age:29 married:true
    22. 	fmt.Sscanln("Looking 29 true", &name, &age, &married)
    23. 	fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)
    24. 	// 输入：Looking 29 true
    25. 	// 输出：扫描结果 name:Looking age:29 married:true
    26. }

    NewReader

    完整获取输入的内容并裁剪首尾空格

    1. package main
    2.  
    3. import (
    4. 	"bufio"
    5. 	"fmt"
    6. 	"os"
    7. 	"strings"
    8. )
    9.  
    10. func main() {
    11. 	reader := bufio.NewReader(os.Stdin) // 从标准输入生成读对象
    12. 	fmt.Print("请输入内容：")
    13. 	text, _ := reader.ReadString('\n') // 读到换行，分隔符后面的内容被忽略
    14. 	text = strings.TrimSpace(text) // 字符串头尾的空格会被移除
    15. 	fmt.Printf("%#v\n", text)
    16. }
    1. 请输入内容：  hello world   
    2. "hello world"

    格式化输出

    常用占位符

     常用格式化字符转义表

    1. verb            描述
    2.  
    3. %+v    添加字段名(如结构体)
    4. %#v　  相应值的Go语法表示 
    5. %T     相应值的类型的Go语法表示 
    6. %%     字面上的百分号，并非值的占位符　
    7. %t     true 或 false
    8. %b     二进制表示 
    9. %c     相应Unicode码点所表示的字符 
    10. %d     十进制表示 
    11. %o     八进制表示 
    12. %x     十六进制表示，字母形式为小写 a-f 
    13. %X     十六进制表示，字母形式为大写 A-F 
    14. %U     Unicode格式：U+1234，等同于 "U+%04X"
    15. %b     无小数部分的，指数为二的幂的科学计数法
    16. %e     科学计数法，例如 -1234.456e+78 
    17. %E     科学计数法，例如 -1234.456E+78 
    18. %f     有小数点而无指数，例如 123.456 
    19. %g     根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的0）输出 
    20. %G     根据情况选择 %E 或 %f 以产生更紧凑的（无末尾的0）输出
    21. %s     字符串或切片的无解译字节 
    22. %q     双引号围绕的字符串，由Go语法安全地转义 
    23. %p     十六进制表示，前缀 0x (用于指针)

    通用占位符

    占位符说明
    %v值的默认格式表示
    %+v类似%v，但输出结构体时会添加字段名
    %#v值的Go语法表示
    %T打印值的类型
    %%百分号
    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. )
    6.  
    7. func main() {
    8. 	fmt.Printf("%v\n", 100)   // 100
    9. 	fmt.Printf("%v\n", false) // false
    10. 	o := struct {
    11. 		name string
    12. 	}{"Looking"}
    13. 	fmt.Printf("%v\n", o)  // 打印值，{Looking}
    14. 	fmt.Printf("%#v\n", o) // 打印值，struct { name string }{name:"Looking"}
    15. 	fmt.Printf("%+v\n", o) // 打印值，输出结构体会添加字段名称 {name:Looking}
    16. 	fmt.Printf("%T\n", o)  // 打印值的类型，struct { name string }
    17. 	fmt.Printf("100%%\n")  // 100%
    18. }

    布尔型占位符

    占位符说明
    %ttrue或false
    1. package main
    2.  
    3. import "fmt"
    4.  
    5. func main() {
    6. 	b := true
    7. 	fmt.Printf("%t\n", b) // true
    8. }

    浮点数与复数

    占位符说明
    %b无小数部分、二进制指数的科学计数法，如-123456p-78
    %e科学计数法，如-1234.456e+78
    %E科学计数法，如-1234.456E+78
    %f有小数部分但无指数部分，如123.456
    %F等价于%f
    %g根据实际情况采用%e或%f格式（以获得更简洁、准确的输出）
    %G根据实际情况采用%E或%F格式（以获得更简洁、准确的输出）
    1. package main
    2.  
    3. import "fmt"
    4.  
    5. func main() {
    6. 	f := 12.34
    7. 	fmt.Printf("%b\n", f) // 6946802425218990p-49
    8. 	fmt.Printf("%e\n", f) // 1.234000e+01
    9. 	fmt.Printf("%E\n", f) // 1.234000E+01
    10. 	fmt.Printf("%f\n", f) // 12.340000
    11. 	fmt.Printf("%g\n", f) // 12.34
    12. 	fmt.Printf("%G\n", f) // 12.34
    13. }

     字符串和[]byte

    占位符说明
    %s直接输出字符串或者[]byte
    %q该值对应的双引号括起来的go语法字符串字面值，必要时会采用安全的转义表示
    %x每个字节用两字符十六进制数表示（使用a-f ）
    %X每个字节用两字符十六进制数表示（使用A-F）
    1. package main
    2.  
    3. import "fmt"
    4.  
    5. func main() {
    6. 	s := "Looking"
    7. 	fmt.Printf("%s\n", s) // Looking
    8. 	fmt.Printf("%q\n", s) // "Looking"
    9. 	fmt.Printf("%x\n", s) // 4c6f6f6b696e67
    10. 	fmt.Printf("%X\n", s) // 4C6F6F6B696E67
    11. }

    指针占位符

    占位符说明
    %p表示为十六进制，并加上前导的0x
    1. package main
    2.  
    3. import "fmt"
    4.  
    5. func main() {
    6. 	a := 10
    7. 	fmt.Printf("%p\n", &a)  // 0xc0000aa058
    8. 	fmt.Printf("%#p\n", &a) // c0000aa058
    9. }

    宽度标识符

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

    占位符说明
    %f默认宽度，默认精度
    %9f宽度9，默认精度
    %.2f默认宽度，精度2
    %9.2f宽度9，精度2
    %9.f宽度9，精度0
    1. package main
    2.  
    3. import "fmt"
    4.  
    5. func main() {
    6. 	n := 12.34
    7. 	fmt.Printf("%f\n", n)    // 12.340000
    8. 	fmt.Printf("%9f\n", n)   // 12.340000
    9. 	fmt.Printf("%.2f\n", n)  // 12.34
    10. 	fmt.Printf("%9.2f\n", n) //     12.34
    11. 	fmt.Printf("%9.f\n", n)  //        12
    12. }

    其他占位符

    占位符说明
    '+'总是输出数值的正负号；对%q（%+q）会生成全部是ASCII字符的输出（通过转义）；
    ' '对数值，正数前加空格而负数前加负号；对字符串采用%x或%X时（% x或% X）会给各打印的字节之间加空格
    '-'在输出右边填充空白而不是默认的左边（即从默认的右对齐切换为左对齐）；
    '#'八进制数前加0（%#o），十六进制数前加0x（%#x）或0X（%#X），指针去掉前面的0x（%#p）对%q（%#q），对%U（%#U）会输出空格和单引号括起来的go字面值；
    '0'使用0而不是空格填充，对于数值类型会把填充的0放在正负号后面；
    1. package main
    2.  
    3. import "fmt"
    4.  
    5. func main() {
    6. 	s := "Looking"
    7. 	fmt.Printf("%s\n", s)      // 字符串输出
    8. 	fmt.Printf("%10s\n", s)    // 宽度10，右对齐
    9. 	fmt.Printf("%-10s\n", s)   // 宽度10，左对齐
    10. 	fmt.Printf("%10.5s\n", s)  // 宽度10，右对齐，截取前5位
    11. 	fmt.Printf("%-10.5s\n", s) // 宽度10，左对齐，截取前5位
    12. 	fmt.Printf("%10.2s\n", s)  // 宽度10，右对齐，截取前2位
    13. 	fmt.Printf("%010s\n", s)   // 宽度10，右对齐，左边使用0填充
    14. }
    1. Looking
    2.    Looking
    3. Looking   
    4.      Looki
    5. Looki     
    6.         Lo
    7. 000Looking

    基本数据类型与字符串转换 

    Atoi/Itoa

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"strconv"
    6. )
    7.  
    8. func main() {
    9. 	i := 123
    10. 	s := strconv.Itoa(i)
    11. 	fmt.Printf("type:%T value:%#v\n", s, s) // type:string value:"123"
    12.  
    13. 	a, _ := strconv.Atoi("1234")
    14. 	fmt.Printf("type:%T value:%#v\n", a, a) // type:int value:1234
    15. }

    字符串解析（Parse系列函数）

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"strconv"
    6. )
    7.  
    8. func main() {
    9. 	b, _ := strconv.ParseBool("1")
    10. 	fmt.Printf("type:%T value:%#v\n", b, b) // type:string value:"123"
    11.  
    12. 	i, _ := strconv.ParseInt("1A", 16, 32)   // base: 将字符串按照 base 进制进行解析
    13. 	fmt.Printf("type:%T value:%#v\n", i, i)  // type:int64 value:26
    14. 	fmt.Println(strconv.FormatInt(26, 2))    // 11010
    15. 	i2, _ := strconv.ParseInt("1A", 16, 4)   // bitSize: 若超过最大位数，显示能表示的最大值，有符号整形的符号位额外占一位。
    16. 	fmt.Printf("type:%T value:%v\n", i2, i2) // type:int64 value:7   解析结果为26，二进制形式长度加符号位限定为4位，结果显示为7（符号位额外占一位）
    17.  
    18. 	i3, _ := strconv.ParseUint("1A", 16, 4)  // bitSize: 若超过最大位数，显示能表示的最大值。
    19. 	fmt.Printf("type:%T value:%v\n", i3, i3) // type:uint64 value:15 解析结果为26，二进制形式长度为5位，超过限定的4，结果显示为15
    20.  
    21. 	f, _ := strconv.ParseFloat("3.1415926", 32) // bitSize 指定精度的浮点数，可以为 32 或 64.
    22. 	f2, _ := strconv.ParseFloat("3.1415926", 64)
    23. 	fmt.Printf("type:%T value:%#v\n", f, f)   // type:float64 value:3.141592502593994
    24. 	fmt.Printf("type:%T value:%#v\n", f2, f2) // type:float64 value:3.1415926
    25. }

    字符串转换（Format系列函数）

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"strconv"
    6. )
    7.  
    8. func main() {
    9. 	s1 := strconv.FormatBool(true)
    10. 	fmt.Printf("type:%T value:%#v\n", s1, s1) // type:string value:"true"
    11. 	s2 := strconv.FormatFloat(3.1415, 'E', -1, 64)
    12. 	fmt.Printf("type:%T value:%#v\n", s2, s2) // type:string value:"3.1415E+00"
    13. 	s3 := strconv.FormatInt(-123, 16)
    14. 	fmt.Printf("type:%T value:%#v\n", s3, s3) // type:string value:"-7b"
    15. 	s4 := strconv.FormatUint(123, 2)
    16. 	fmt.Printf("type:%T value:%#v\n", s4, s4) // type:string value:"1111011"
    17. 	s5 := strconv.FormatUint(123, 8)
    18. 	fmt.Printf("type:%T value:%#v\n", s5, s5) // type:string value:"173"
    19. 	s6 := strconv.FormatUint(123, 10)
    20. 	fmt.Printf("type:%T value:%#v\n", s6, s6) // type:string value:"123"
    21. 	s7 := strconv.FormatUint(123, 16)
    22. 	fmt.Printf("type:%T value:%#v\n", s7, s7) // type:string value:"7b"
    23. 	fmt.Println(strconv.IsPrint('好'))         // true
    24. }

    字符串追加（Append系列函数）

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"strconv"
    6. )
    7.  
    8. func main() {
    9. 	a := []byte("hello:")
    10. 	fmt.Println(string(a)) // hello:
    11. 	a = strconv.AppendBool(a, true)
    12. 	fmt.Println(string(a)) // hello:true
    13. 	a = strconv.AppendFloat(a, 3.14159, 'f', 4, 32) // f:以浮点数形式 e:科学记数法表示数字 g:自适应展示
    14. 	fmt.Println(string(a)) // hello:true3.1416
    15. 	a = strconv.AppendInt(a, 26, 2) // 将整形转换成2进制字符串追加
    16. 	fmt.Println(string(a)) // hello:true3.141611010
    17. 	a = strconv.AppendUint(a, 26, 16) // 将无符号整形转换成16进制字符串追加
    18. 	fmt.Println(string(a)) // hello:true3.1416110101a
    19. 	a = strconv.AppendQuote(a, "你") // 带引号的字符串追加
    20. 	fmt.Println(string(a)) // hello:true3.1416110101a"你"
    21. 	a = strconv.AppendQuoteRune(a, '好') // 带引号的字符追加
    22. 	fmt.Println(string(a)) // hello:true3.1416110101a"你"'好'
    23. }

    字符串和字节数组相互转换

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. )
    6.  
    7. func main() {
    8. 	a := "hello "
    9. 	b := []byte{' ', 'w', 'o', 'r', 'l', 'd'}
    10. 	fmt.Println([]byte(a)) // [104 101 108 108 111 32]
    11. 	fmt.Println(string(b)) //  world
    12. }
  • 相关阅读:
    电子学会2023年6月青少年软件编程（图形化）等级考试试卷（二级）真题，含答案解析
    web3.0、比特币、区块链、元宇宙，以及那些待收割的韭菜们！
    Python colorama 设置控制台、命令行输出彩色文字
    【Docker】docker构建java项目
    CUDA-矩阵乘2
    ConstraintLayout使用 笔记总结
    SpringBoot 整合ORM
    centos7安装部署kvm,照做就行
    异步FIFO中格雷码的SDC约束
    我用Axure制作了一款火影小游戏 | PM老猫
  • 原文地址：https://blog.csdn.net/TomorrowAndTuture/article/details/133680818