fmt标准库

主要分为向外输出内容和获取输入内容两大部分

1. 输出

1.1 fmt.Print

print 有三个相关的函数：

func Print(a ...any) (n int, err error) {
 return Fprint(os.Stdout, a...)
}
func Println(a ...any) (n int, err error) {
 return Fprintln(os.Stdout, a...)
}
func Printf(format string, a ...any) (n int, err error) {
 return Fprintf(os.Stdout, format, a...)
}

可以看到，最终调用的都是Fprintf，os.Stdout代表标准输出，即控制台输出

示例：

package main

import (
 "fmt"
 "testing"
)

func TestPrint(t *testing.T) {
 fmt.Print("我是控制台打印，我不换行 可以自己控制换行")
}
func TestPrintln(t *testing.T) {
 fmt.Println("我是控制台打印，我换行")
}
func TestPrintf(t *testing.T) {
 fmt.Printf("我是控制台打印，%s \n", "这是格式化占位符信息,可以自己控制换行")
}

1.2 格式化占位符

1.2.1 通用占位符

type User struct {
 Id int64
}
func TestPrintf1(t *testing.T) {
 user := &User{Id: 1}
 fmt.Printf("%v\n", user)
 fmt.Printf("%+v\n", user)
 fmt.Printf("%#v\n", user)
 fmt.Printf("%T\n", user)
 fmt.Printf("%%\n")
}

1.2.2 布尔型

func TestPrintf2(t *testing.T) {
 fmt.Printf("%t\n", true)
}

1.2.3 整型

func TestPrintf3(t *testing.T) {
 n := 180
 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)
 fmt.Printf("%U\n", n)
 a := 96
 fmt.Printf("%q\n", a)
 fmt.Printf("%q\n", 0x4E2D)
}

1.2.4 浮点数与复数

func TestPrintf4(t *testing.T) {
 f := 18.54
 fmt.Printf("%b\n", f)
 fmt.Printf("%e\n", f)
 fmt.Printf("%E\n", f)
 fmt.Printf("%f\n", f)
 fmt.Printf("%F\n", f)
 fmt.Printf("%g\n", f)
 fmt.Printf("%G\n", f)
}

1.2.5 字符串和[]byte

func TestPrintf5(t *testing.T) {
 s := "我是字符串"
 b := []byte{65, 66, 67}
 fmt.Printf("%s\n", s)
 fmt.Printf("%s\n", b)
 fmt.Printf("%q\n", s)
 fmt.Printf("%x\n", s)
 fmt.Printf("%X\n", s)
}

1.2.6 指针

1.2.7 宽度标识符

%10.2

宽度通过一个紧跟在百分号后面的十进制数指定，如果未指定宽度，则表示值时除必需之外不作填充。

精度通过（可选的）宽度后跟点号后跟的十进制数指定。如果未指定精度，会使用默认精度；如果点号后没有跟数字，表示精度为0。

func TestPrintf6(t *testing.T) {
 n := 13.14
 fmt.Printf("%f\n", n)
 fmt.Printf("%10f\n", n)
 fmt.Printf("%10s\n", "我是字符串")
 fmt.Printf("%.2f\n", n)
 fmt.Printf("%10.2f\n", n)
 fmt.Printf("%10.f\n", n)
}

1.2.8 其他falg

func TestPrintf7(t *testing.T) {
 s := "我是字符串"
 fmt.Printf("%  d\n", 10)
 fmt.Printf("%s\n", s)
 fmt.Printf("%10s\n", s)
 fmt.Printf("%-10s\n", s)
 fmt.Printf("%10.2f\n", 10.14)
 fmt.Printf("%-10.2f\n", 10.14)
 fmt.Printf("%010s\n", s)
}

1.3 Fprint

将内容输出到一个io.Writer接口类型的变量w中。

func Fprint(w io.Writer, a ...any) (n int, err error) {
 p := newPrinter()
 p.doPrint(a)
 n, err = w.Write(p.buf)
 p.free()
 return
}
func Fprintf(w io.Writer, format string, a ...any) (n int, err error) {
 p := newPrinter()
 p.doPrintf(format, a)
 n, err = w.Write(p.buf)
 p.free()
 return
}
func Fprintln(w io.Writer, a ...any) (n int, err error) {
 p := newPrinter()
 p.doPrintln(a)
 n, err = w.Write(p.buf)
 p.free()
 return
}

n是写入的字节数量，err是返回的错误

一般用在写文件中。

func TestFPrint(t *testing.T) {
 fmt.Fprintln(os.Stdout, "向标准输出写入字符串")
}

//0表示8进制 644表示权限 os.FileMode(0777).String()进行打印
 //- rwx rwx rwx -表示普通文件
 //r表示可读
 //w表示可写
 //x表示可执行
 //第1位：文件属性，一般常用的是"-"，表示是普通文件；"d"表示是一个目录。
 //第2～4位：文件所有者的权限rwx (可读/可写/可执行)。
 //第5～7位：文件所属用户组的权限rwx (可读/可写/可执行)。
 //第8～10位：其他人的权限rwx (可读/可写/可执行)。
 //在golang中，可以使用os.FileMode(perm).String()来查看权限标识：
 //os.FileMode(0777).String() //返回 -rwxrwxrwx  111 111 111
 //os.FileMode(0666).String() //返回 -rw-rw-rw-  110 110 110
 //os.FileMode(0644).String() //返回 -rw-r--r-- 
 //0777表示：创建了一个普通文件，所有人拥有所有的读、写、执行权限
 //0666表示：创建了一个普通文件，所有人拥有对该文件的读、写权限，但是都不可执行
 //0644表示：创建了一个普通文件，文件所有者对该文件有读写权限，用户组和其他人只有读权限，都没有执行权限
 s := os.FileMode(0777).String()
 fmt.Println(s)

func TestFPrint1(t *testing.T) {
 file, _ := os.OpenFile("test.txt", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
 fmt.Fprintln(file, "追加写入")
 file.Close()
}

package main

import (
 "fmt"
 "net/http"
)

func main() {
 //输入
 http.ListenAndServe(":8088", &MyHandler{})
}

type MyHandler struct {
}

func (*MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 fmt.Fprintln(w, "我是http返回的信息")
}

1.4 Sprint

把传入的数据生成并返回一个字符串

func Sprint(a ...any) string {
 p := newPrinter()
 p.doPrint(a)
 s := string(p.buf)
 p.free()
 return s
}
func Sprintf(format string, a ...any) string {
 p := newPrinter()
 p.doPrintf(format, a)
 s := string(p.buf)
 p.free()
 return s
}
func Sprintln(a ...any) string {
 p := newPrinter()
 p.doPrintln(a)
 s := string(p.buf)
 p.free()
 return s
}

func TestSPrint(t *testing.T) {
 s1 := fmt.Sprint("张三")
 name := "张三"
 age := 18
 s2 := fmt.Sprintf("name:%s,age:%d", name, age)
 s3 := fmt.Sprintln("张三")
 fmt.Println(s1, s2, s3)
}

1.5 Errorf

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

func Errorf(format string, a ...any) error

func TestErrorf(t *testing.T) {
 err := fmt.Errorf("用户名格式不正确：%s", "@#￥哈哈")
 if err != nil {
  panic(err)
 }
}

2. 输入

2.1 fmt.Scan

定义：

func Scan(a ...any) (n int, err error) {
 return Fscan(os.Stdin, a...)
}

含义：

从标准输入扫描文本，读取由空白符分隔的值保存到传递给本函数的参数中，换行符视为空白符

返回值：

本函数返回成功扫描的数据个数(n)和遇到的任何错误(error)

func main() {
 //空格 换行输入都可以
 var (
  name    string
  age     int
  married bool
 )
 fmt.Scan(&name, &age, &married)
 fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)
}

2.2 fmt.Scanf

func Scanf(format string, a ...any) (n int, err error) {
 return Fscanf(os.Stdin, format, a...)
}

实际使用的是Fscanf

以format定义的格式来进行输入

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

2.3 fmt.Scanln

func Scanln(a ...any) (n int, err error) {
 return Fscanln(os.Stdin, a...)
}

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

遇到回车就结束扫描

2.4 fmt.Fsanf

func Fscanf(r io.Reader, format string, a ...any) (n int, err error) {
 s, old := newScanState(r, false, false)
 n, err = s.doScanf(format, a)
 s.free(old)
 return
}
func Fscan(r io.Reader, a ...any) (n int, err error) {
 s, old := newScanState(r, true, false)
 n, err = s.doScan(a)
 s.free(old)
 return
}
func Fscanln(r io.Reader, a ...any) (n int, err error) {
 s, old := newScanState(r, false, true)
 n, err = s.doScan(a)
 s.free(old)
 return
}

将内容从一个io.Reader接口类型的变量r中读取出来，将连续的以空格分隔的值存储到由格式确定的连续的参数中

• r io.Reader：此参数包含扫描的指定文本。

• format string:此参数包含用于接收元素的不同格式。

• a …any:此参数是每个元素的指定变量。

返回值：它返回成功解析的项目数和错误

func main() {
 var (
  name    string
  age     int
  married bool
 )
 r := strings.NewReader("10 false 张三")

 n, err := fmt.Fscanf(r, "%d %t %s", &age, &married, &name)
 if err != nil {
  fmt.Fprintf(os.Stderr, "Fscanf:%v\n", err)
 }

 fmt.Println(name, age, married)

 fmt.Println(n)
}