fmt

fmt包实现了类似C语言printf和scanf的格式化I/O。主要分为向外输出内容和获取输入内容两大部分。

向外输出

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

Print

<font style="color:rgb(51, 51, 51);">Print</font>系列函数会将内容输出到系统的标准输出，区别在于<font style="color:rgb(51, 51, 51);">Print</font>函数直接输出内容，<font style="color:rgb(51, 51, 51);">Printf</font>函数支持格式化输出字符串，<font style="color:rgb(51, 51, 51);">Println</font>函数会在输出内容的结尾添加一个换行符。

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

Fprint

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

只要满足io.Writer接口的类型（存在Write方法）都支持写入。__例如：标准输入输出、文件、

  1. func Fprint(w io.Writer, a ...interface{}) (n int, err error)
  2. func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)
  3. func Fprintln(w io.Writer, a ...interface{}) (n int, err error)
  1. // 向标准输出写入内容
  2. fmt.Fprintln(os.Stdout, "向标准输出写入内容")
  3. fileObj, err := os.OpenFile("./xx.txt", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
  4. if err != nil {
  5.     fmt.Println("打开文件出错，err:", err)
  6.     return
  7. }
  8. name := "枯藤"
  9. // 向打开的文件句柄中写入内容
  10. fmt.Fprintf(fileObj, "往文件中写如信息：%s", name)

Sprint

<font style="color:rgb(51, 51, 51);">Sprint</font>系列函数会把传入的数据生成并返回一个字符串。

  1. func Sprint(a ...interface{}) string
  2. func Sprintf(format string, a ...interface{}) string
  3. func Sprintln(a ...interface{}) string
简单的示例代码如下： 
  1. s1 := fmt.Sprint("枯藤")
  2. name := "枯藤"
  3. age := 18
  4. s2 := fmt.Sprintf("name:%s,age:%d", name, age)
  5. s3 := fmt.Sprintln("枯藤")
  6. fmt.Println(s1, s2, s3)
  7. // 输出      枯藤 name:枯藤,age:18 枯藤

Errorf

Errorf函数根据format参数生成格式化字符串并返回一个包含该字符串的错误。通常使用这种方式来自定义错误类型。 
  1. func Errorf(format string, a ...interface{}) error
例如： 
  1. // 自定义错误类型
  2. err := fmt.Errorf("这是一个错误")
  3. fmt.Println(err)                            //    这是一个错误
  4. err := fmt.Errorf("这是一个错误%d",2)
  5. fmt.Println(err)                            //    这是一个错误2

格式化占位符

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

通用占位符

占位符 说明
%v 值的默认格式表示
%+v 类似%v，但输出结构体时会添加字段名
%#v 值的Go语法表示
%T 打印值的类型
%% 百分号 
  1. fmt.Printf("%v\n", 100)            // 100
  2. fmt.Printf("%v\n", false)        // false
  3. o := struct{ name string }{"枯藤"}        
  4. fmt.Printf("%v\n", o)                    // {枯藤}
  5. fmt.Printf("%#v\n", o)                    // struct { name string }{name:"枯藤"}
  6. fmt.Printf("%T\n", o)                    // struct { name string }
  7. fmt.Printf("100%%\n")                    // 100%

布尔型

占位符 说明
%t true或false

整型

占位符 说明
%b 表示为二进制
%c 该值对应的unicode码值
%d 表示为十进制
%o 表示为八进制
%x 表示为十六进制，使用a-f
%X 表示为十六进制，使用A-F
%U 表示为Unicode格式：U+1234，等价于”U+%04X”
%q 该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示 
  1. n := 65
  2. fmt.Printf("%b\n", n) //1000001
  3. fmt.Printf("%c\n", n) //A
  4. fmt.Printf("%d\n", n) //65
  5. fmt.Printf("%o\n", n) //101
  6. fmt.Printf("%x\n", n) //41
  7. fmt.Printf("%X\n", n) //41

浮点数与复数

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

字符串和[]byte

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

指针

占位符 说明
%p 表示为十六进制，并加上前导的0x
示例代码如下： 
  1. a := 18
  2. fmt.Printf("%p\n", &a) // 0xc000054058
  3. fmt.Printf("%#p\n", &a) // c000054058

宽度标识符

宽度通过一个紧跟在百分号后面的十进制数指定，如果未指定宽度，则表示值时除必需之外不作填充。精度通过（可选的）宽度后跟点号后跟的十进制数指定。如果未指定精度，会使用默认精度；如果点号后没有跟数字，表示精度为0。举例如下
占位符 说明
%f 默认宽度，默认精度
%9f 宽度9，默认精度
%.2f 默认宽度，精度2
%9.2f 宽度9，精度2
%9.f 宽度9，精度0 
  1. n := 88.88
  2. fmt.Printf("%f\n", n) // 
  3. fmt.Printf("%9f\n", n) // 
  4. fmt.Printf("%.2f\n", n) // 
  5. fmt.Printf("%9.2f\n", n) //
  6. fmt.Printf("%9.f\n", n) //
输出结果如下： 
  1. 88.880000
  2.     88.880000
  3.     88.88
  4.         88.88
  5.            89

其他falg

占位符 说明
‘+’ 总是输出数值的正负号；对%q（%+q）会生成全部是ASCII字符的输出（通过转义）；
‘ ‘ 对数值，正数前加空格而负数前加负号；对字符串采用%x或%X时（% x或% X）会给各打印的字节之间加空格
‘-‘ 在输出右边填充空白而不是默认的左边（即从默认的右对齐切换为左对齐）；
‘#’ 八进制数前加0（%#o），十六进制数前加0x（%#x）或0X（%#X），指针去掉前面的0x（%#p）对%q（%#q），对%U（%#U）会输出空格和单引号括起来的go字面值；
‘0’ 使用0而不是空格填充，对于数值类型会把填充的0放在正负号后面； 
  1. s := "枯藤"
  2. fmt.Printf("%s\n", s)
  3. fmt.Printf("%5s\n", s)
  4. fmt.Printf("%-5s\n", s)
  5. fmt.Printf("%5.7s\n", s)
  6. fmt.Printf("%-5.7s\n", s)
  7. fmt.Printf("%5.2s\n", s)
  8. fmt.Printf("%05s\n", s)
输出结果如下： 
  1. 枯藤
  2.        枯藤
  3.     枯藤
  4.        枯藤
  5.     枯藤
  6.        枯藤
  7.     000枯藤

获取输入

Go语言fmt包下有<font style="color:rgb(51, 51, 51);">fmt.Scan、fmt.Scanf、fmt.Scanln</font>三个函数，可以在程序运行过程中从标准输入获取用户的输入。

fmt.Scan

  • Scan从标准输入扫描文本，读取由空白符分隔的值保存到传递给本函数的参数中，换行符视为空白符。
  • 本函数返回成功扫描的数据个数和遇到的任何错误。如果读取的数据个数比提供的参数少，会返回一个错误报告原因。
函数定签名如下： 
  1. func Scan(a ...interface{}) (n int, err error)
  1. func main() {
  2.     var (
  3.         name    string
  4.         age     int
  5.         married bool
  6.     )
  7.     fmt.Scan(&name, &age, &married)
  8.     fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)
  9. }
  10. /*
  11. $ ./scan_demo 
  12.     枯藤 18 false
  13.     扫描结果 name:枯藤 age:18 married:false
  14. */

fmt.Scanf

函数签名如下： 
  1. func Scanf(format string, a ...interface{}) (n int, err error)
  • Scanf从标准输入扫描文本，根据format参数指定的格式去读取由空白符分隔的值保存到传递给本函数的参数中。
  • 本函数返回成功扫描的数据个数和遇到的任何错误。 
  1. func main() {
  2.     var (
  3.         name    string
  4.         age     int
  5.         married bool
  6.     )
  7.     fmt.Scanf("1:%s 2:%d 3:%t", &name, &age, &married)
  8.     fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)
  9. }
将上面的代码编译后在终端执行，在终端按照指定的格式依次输入枯藤、18和false。 
  1. $ ./scan_demo 
  2. 1:枯藤 2:18 3:false
  3. 扫描结果 name:枯藤 age:18 married:false
fmt.Scanf不同于fmt.Scan简单的以空格作为输入数据的分隔符，fmt.Scanf为输入数据**指定了具体的输入内容格式**，只有按照格式输入数据才会被扫描并存入对应变量。 例如，我们还是按照上个示例中以空格分隔的方式输入，fmt.Scanf就不能正确扫描到输入的数据。 
  1. $ ./scan_demo 
  2. 枯藤 18 false
  3. 扫描结果 name: age:0 married:false

fmt.Scanln

函数签名如下： 
  1. func Scanln(a ...interface{}) (n int, err error)
  • Scanln类似Scan，它在遇到换行时才停止扫描。最后一个数据后面必须有换行或者到达结束位置。
  • 本函数返回成功扫描的数据个数和遇到的任何错误。 
  1. func main() {
  2.     var (
  3.             name    string
  4.             age     int
  5.             married bool
  6.         )
  7.     fmt.Scanln(&name, &age, &married)
  8.     fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)
  9. }
将上面的代码编译后在终端执行，在终端依次输入枯藤、18和false使用空格分隔。 
  1. $ ./scan_demo 
  2. 枯藤 18 false
  3. 扫描结果 name:枯藤 age:18 married:false
fmt.Scanln遇到回车就结束扫描了，这个比较常用。

bufio.NewReader

有时候我们想完整获取输入的内容，而**输入的内容可能包含空格，这种情况下可以使用bufio包来实现，遇到换行时停止扫描**。示例代码如下： 
  1. func main() {
  2.     reader := bufio.NewReader(os.Stdin) // 从标准输入生成读对象,读到所有
  3.     fmt.Print("请输入内容：")
  4.     text, _ := reader.ReadString('\n') // 读到换行
  5.     fmt.Printf("%#v\n", text)         
  6.      text = strings.TrimSpace(text)    // 去掉字符串前后的空格
  7.     fmt.Printf("%#v\n", text)             
  8. }
  9. /*
  10. 请输入内容：sdfsfsf\r\n \r \n asdf\0sdf
  11. "sdfsfsf\\r\\n \\r \\n asdf\\0sdf\r\n"
  12. "sdfsfsf\\r\\n \\r \\n asdf\\0sdf"
  13. */

Fscan系列

这几个函数功能分别类似于<font style="color:rgb(51, 51, 51);">fmt.Scan、fmt.Scanf、fmt.Scanln</font>三个函数，只不过它们不是从标准输入中读取数据而是从io.Reader中读取数据。 
  1. func Fscan(r io.Reader, a ...interface{}) (n int, err error)
  2. func Fscanln(r io.Reader, a ...interface{}) (n int, err error)
  3. func Fscanf(r io.Reader, format string, a ...interface{}) (n int, err error)

Sscan系列

这几个函数功能分别类似于fmt.Scan、fmt.Scanf、fmt.Scanln三个函数，只不过它们不是从标准输入中读取数据而是从指定字符串中读取数据。 
  1. func Sscan(str string, a ...interface{}) (n int, err error)
  2. func Sscanln(str string, a ...interface{}) (n int, err error)
  3. func Sscanf(str string, format string, a ...interface{}) (n int, err error)

IO操作

输入输出的底层原理

  • 终端其实是一个文件，相关实例如下：
    • **os.Stdin**：标准输入的文件实例，类型为*File
    • **os.Stdout**：标准输出的文件实例，类型为*File
    • **os.Stderr**：标准错误输出的文件实例，类型为*File
以文件的方式操作终端: 
  1. package main
  3. import "os"
  5. func main() {
  6.     var buf [16]byte
  7.     os.Stdin.Read(buf[:])
  8.     os.Stdin.WriteString(string(buf[:]))
  9. }

文件操作相关API

  1. func Create(name string) (file *File, err Error)
  2. // 根据提供的文件名创建新的文件，返回一个文件对象，默认权限是0666
  3. func NewFile(fd uintptr, name string) *File
  4. // 根据文件描述符创建相应的文件，返回一个文件对象
  5. func Open(name string) (file *File, err Error)
  6. // 只读方式打开一个名称为name的文件
  7. func OpenFile(name string, flag int, perm uint32) (file *File, err Error)
  8. // 打开名称为name的文件，flag是打开的方式，只读、读写等，perm是权限
  9. func (file *File) Write(b []byte) (n int, err Error)
  10. // 写入byte类型的信息到文件
  11. func (file *File) WriteAt(b []byte, off int64) (n int, err Error)
  12. // 在指定位置开始写入byte类型的信息
  13. func (file *File) WriteString(s string) (ret int, err Error)
  14. // 写入string信息到文件
  15. func (file *File) Read(b []byte) (n int, err Error)
  16. // 读取数据到b中
  17. func (file *File) ReadAt(b []byte, off int64) (n int, err Error)
  18. // 从off开始读取数据到b中
  19. func Remove(name string) Error
  20. // 删除文件名为name的文件

打开和关闭文件

os.Open()函数能够打开一个文件，返回一个*File和一个err。对得到的文件实例调用close()方法能够关闭文件。

  1. package main
  3. import (
  4.     "fmt"
  5.     "os"
  6. )
  8. func main() {
  9.     // 只读方式打开当前目录下的main.go文件
  10.     file, err := os.Open("./main.go")
  11.     if err != nil {
  12.         fmt.Println("open file failed!, err:", err)
  13.         return
  14.     }
  15.     // 关闭文件
  16.     file.Close()
  17. }

写文件

  1. package main
  3. import (
  4.     "fmt"
  5.     "os"
  6. )
  8. func main() {
  9.     // 新建文件
  10.     file, err := os.Create("./xxx.txt")
  11.     if err != nil {
  12.         fmt.Println(err)
  13.         return
  14.     }
  15.     defer file.Close()
  16.     for i := 0; i < 5; i++ {
  17.         file.WriteString("ab\n")
  18.         file.Write([]byte("cd\n"))
  19.     }
  20. }

读文件

文件读取可以用file.Read()和file.ReadAt()，读到文件末尾会返回io.EOF的错误; 
  1. package main
  3. import (
  4.     "fmt"
  5.     "io"
  6.     "os"
  7. )
  9. func main() {
  10.     // 打开文件
  11.     file, err := os.Open("./xx.txt")
  12.     if err != nil {
  13.         fmt.Println("open file err :", err)
  14.         return
  15.     }
  16.     defer file.Close()
  17.     // 定义接收文件读取的字节数组
  18.     var buf []byte = make([]byte, 100)
  19.     var content []byte
  20.     var i = 0 // 用于计数循环多少次
  21.     for {
  22.         n, err := file.Read(buf)
  23.         fmt.Println(i)   // 循环的次数，发现读到最后的io.EOF时会先将最后一个包的数据返回，下次再单独读io.EOF
  24.         if err == io.EOF {
  25.             // 读取结束
  26.             break
  27.         }
  28.         if err != nil {
  29.             fmt.Println("read file err ", err)
  30.             return
  31.         }
  32.         content = append(content, buf[:n]...)
  33.         fmt.Println(i, n)
  34.         fmt.Println(string(buf[:n]))
  35.         i++
  36.     }
  37. }
  38. /*    文件内容
  39. 往文件中写如信息：枯藤往文件中写如信息：枯藤往文件中写如信息：枯藤gua
  40. fsdfsdfdsfsdf----------af454651435465465
  41. /*
  43. 0
  44. 0 100
  45. 往文件中写如信息：枯藤往文件中写如信息：枯藤往文件中写如信息：枯藤g
  46. 1
  47. 1 44
  48. ua
  49. fsdfsdfdsfsdf----------af454651435465465        
  50. 2
  52. */

拷贝文件

  1. package main
  3. import (
  4.     "fmt"
  5.     "io"
  6.     "os"
  7. )
  10. func main(){
  11.     srcfile, err := os.Open("./xx.txt")
  12.     if err != nil {
  13.         fmt.Println(err)
  14.         return
  15.     }
  16.     dstfile, err := os.Create("./copy.txt")
  17.     if err != nil {
  18.         fmt.Println(err)
  19.         return
  20.     }
  21.     var buf = make([]byte, 100)
  22.     for{
  23.         n, err := srcfile.Read(buf)
  24.         if err == io.EOF {
  25.             fmt.Println("read over!!")
  26.             break
  27.         }
  28.         fmt.Println(n)
  29.         dstfile.Write(buf[:n])   // 注意这里，要有n，要不最后会写入脏文件
  32.     }
  34.     srcfile.Close()
  35.     dstfile.Close()
  37. }

bufio（按行读取）

  • bufio包实现了带缓冲区的读写，是对文件读写的封装
  • bufio缓冲写数据
模式 含义
os.O_WRONLY 只写
os.O_CREATE 创建文件
os.O_RDONLY 只读
os.O_RDWR 读写
os.O_TRUNC 清空
os.O_APPEND 追加
  • bufio读数据 
  1. package main
  4. import (
  5.     "bufio"
  6.     "fmt"
  7.     "io"
  8.     "os"
  9. )
  12. func wr() {
  13.     // 参数2：打开模式，所有模式d都在上面
  14.     // 参数3是权限控制
  15.     // w写 r读 x执行   w  2   r  4   x  1
  16.     file, err := os.OpenFile("./xxx.txt", os.O_CREATE|os.O_WRONLY, 0666)
  17.     if err != nil {
  18.         return
  19.     }
  20.     defer file.Close()
  21.     // 获取writer对象
  22.     writer := bufio.NewWriter(file)
  23.     for i := 0; i < 10; i++ {
  24.         writer.WriteString("hello\n")
  25.     }
  26.     // 刷新缓冲区，强制写出
  27.     writer.Flush()
  28. }
  31. func re() {
  32.     file, err := os.Open("./xxx.txt")
  33.     if err != nil {
  34.         return
  35.     }
  36.     defer file.Close()
  37.     reader := bufio.NewReader(file)
  38.     i := 0
  39.     for {
  40.         line, _, err := reader.ReadLine()
  41.         fmt.Println(i)
  42.         if err == io.EOF {
  43.             break
  44.         }
  45.         if err != nil {
  46.             return
  47.         }
  48.         fmt.Println(string(line))
  49.         i++
  50.     }
  51. }
  53. func main() {
  54.     re()
  55. }
  56. /*   re
  57. 0
  58. hello
  59. 1    
  60. hello
  61. 2
  62. hello
  63. 3
  64. hello
  65. 4
  66. hello
  67. 5
  68. hello
  69. 6
  70. hello
  71. 7
  72. hello
  73. 8
  74. hello
  75. 9
  76. hello
  77. 10
  78. */

ioutil工具包（整个文件读入）

  • 工具包写文件
  • 工具包读取文件 
  1. package main
  4. import (
  5.    "fmt"
  6.    "io/ioutil"
  7. )
  10. func wr() {
  11.    err := ioutil.WriteFile("./yyy.txt", []byte("www.5lmh.com"), 0666)
  12.    if err != nil {
  13.       fmt.Println(err)
  14.       return
  15.    }
  16. }
  19. func re() {
  20.    content, err := ioutil.ReadFile("./yyy.txt")
  21.    if err != nil {
  22.       fmt.Println(err)
  23.       return
  24.    }
  25.    fmt.Println(string(content))
  26. }
  29. func main() {
  30.    re()
  31. }
  33. /*  读取整个文件
  34. www.5lmh.com
  35. */

例子

实现一个cat命令

使用文件操作相关知识，模拟实现linux平台cat命令的功能。 
  1. package main
  3. import (
  4.     "bufio"
  5.     "flag"
  6.     "fmt"
  7.     "io"
  8.     "os"
  9. )
  11. // cat命令实现
  12. func cat(r *bufio.Reader) {
  13.     for {
  14.         buf, err := r.ReadBytes('\n') //注意是字符
  15.         if err == io.EOF {
  16.             break
  17.         }
  18.         fmt.Fprintf(os.Stdout, "%s", buf)
  19.     }
  20. }
  22. func main() {
  23.     flag.Parse() // 解析命令行参数
  24.     if flag.NArg() == 0 {
  25.         // 如果没有参数默认从标准输入读取内容
  26.         cat(bufio.NewReader(os.Stdin))
  27.     }
  28.     // 依次读取每个指定文件的内容并打印到终端
  29.     for i := 0; i < flag.NArg(); i++ {
  30.         f, err := os.Open(flag.Arg(i))
  31.         if err != nil {
  32.             fmt.Fprintf(os.Stdout, "reading from %s failed, err:%v\n", flag.Arg(i), err)
  33.             continue
  34.         }
  35.         cat(bufio.NewReader(f))
  36.     }
  37. }