简介

fmt包实现了类似C语言printf和scanf的格式化I/O。格式化动作(’verb’)源自C语言但更简单。

占位符：// 通用verbs

%v 　值的默认格式

%+v 　类似%v,但输出结构体时会添加字段名

%#v 　　 Go语法表示值

%T 　　 Go语法表示类型

%% 　 百分号表示

// 浮点数

%t 　 true或false

// 整数

%b 表示二进制

%c 该值对应的unicode吗值

%d 表示十进制

%o 表示八进制

%q 该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示

%x 表示为十六进制，使用a-f

%X 表示为十六进制，使用A-F

%U 表示为Unicode格式：U+1234，等价于”U+%04X”

// 浮点数与复数

%b 无小数部分、二进制指数的科学计数法，如-123456p-78；参见strconv.FormatFloat

%e 科学计数法，例如 -1234.456e+78

%E 科学计数法，例如 -1234.456E+78

%f 有小数点而无指数，例如 123.456

%F 等价于%f

%g 根据实际情况采用%e或%f格式(以获得更简洁、准确的输出)

%G 根据实际情况采用%E或%F格式(以获得更简洁、准确的输出

// string与[]byte

%s 输出字符串表示(string类型或[]byte)

%q 双引号围绕的字符串，由Go语法安全地转义

%x 十六进制，小写字母，每字节两个字符 (使用a-f)

%X 十六进制，大写字母，每字节两个字符 (使用A-F)

// Slice

%p 切片第一个元素的指针

// point

%p 十六进制内存地址,前缀ox

运行的代码

package main

import (

"fmt"

)

type Sample struct {

num int

str string

}

func main() {

s := Sample{num: 1, str: "a"}

// 值的默认格式

fmt.Printf("%v\n", s) // {1 a}

// 类似%v,但输出结构体时会添加字段名

fmt.Printf("%+v\n", s) // {num:1 str:a}

// Go语法表示值

fmt.Printf("%#v\n", s) // main.Sample{num:1, str:"a"}

// Go语法表示类型

fmt.Printf("%T\n", s) // main.Sample

// 百分号表示

fmt.Printf("%v%%\n", s.num) // 1%

// true或false

fmt.Printf("%t\n", true) //true

// 二进制

fmt.Printf("%b\n", 8) //1000

// 该值对应的unicode码值

fmt.Printf("%c\n", 0x4E2D) //中

// 十进制

fmt.Printf("%d\n", 0x11) //17

// 八进制

fmt.Printf("%o\n", 20) //24

// 该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示

fmt.Printf("%q\n", 0x4E2D) //'中'

// 为十六进制，使用a-f

fmt.Printf("%x\n", 15) //f

// 十六进制，使用A-F

fmt.Printf("%X\n", 15) //F

// 表示为Unicode格式：U+1234，等价于”U+%04X”

fmt.Printf("%U\n", 0x4E2D) //U+4E2D

fmt.Printf("%b\n", 10.45) //5882827013252710p-49

fmt.Printf("%e\n", 10.45) //1.045000E+01

fmt.Printf("%E\n", 10.45) //1.045000E+01

fmt.Printf("%f\n", 10.45) //10.450000

fmt.Printf("%F\n", 10.45) //10.450000

fmt.Printf("%g\n", 10.45) //10.45

fmt.Printf("%G\n", 10.45) //10.45

fmt.Printf("%s\n", []byte("go开发")) //go开发

fmt.Printf("%s\n", "go开发") //go开发

fmt.Printf("%q\n", "go开发") //"go开发"

fmt.Printf("%x\n", "go开发") //676fe5bc80e58f91

fmt.Printf("%X\n", "go开发") //676FE5BC80E58F91

str := "go开发"

fmt.Printf("%p\n", &str) //0xc42000e1e0

}

fmt.Printf

Printf根据format参数生成格式化的字符串并写入标准输出os.stdout。返回写入的字节数和遇到的任何错误。

fmt.Fprintf

Fprintf根据format参数生成格式化的字符串并写入w。返回写入的字节数和遇到的任何错误。

fmt.Sprintf

Sprintf根据format参数生成格式化的字符串并返回该字符串。

fmt.Print

Print采用默认格式将其参数格式化并写入标准输出。如果两个相邻的参数都不是字符串，会在它们的输出之间添加空格。返回写入的字节数和遇到的任何错误。

ftm.Fprint

Fprint采用默认格式将其参数格式化并写入w。如果两个相邻的参数都不是字符串，会在它们的输出之间添加空格。返回写入的字节数和遇到的任何错误。

ftm.Sprint

Sprint采用默认格式将其参数格式化，串联所有输出生成并返回一个字符串。如果两个相邻的参数都不是字符串，会在它们的输出之间添加空格。

ftm.Println

Println采用默认格式将其参数格式化并写入标准输出。总是会在相邻参数的输出之间添加空格并在输出结束后添加换行符。返回写入的字节数和遇到的任何错误。

ftm.Fprintln

Fprintln采用默认格式将其参数格式化并写入w。总是会在相邻参数的输出之间添加空格并在输出结束后添加换行符。返回写入的字节数和遇到的任何错误。

ftm.Sprintln

Sprintln采用默认格式将其参数格式化，串联所有输出生成并返回一个字符串。总是会在相邻参数的输出之间添加空格并在输出结束后添加换行符。

ftm.Errorf

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

package main

import (

"bufio"

"fmt"

"log"

"os"

)

func main() {

fmt.Printf("测试方法：%s\n", "Printf")

writer := bufio.NewWriter(os.Stdout)

fmt.Fprintf(writer, "测试方法：%s\n", "Fprintf") //等价于直接使用Printf，因为指定将值输出到标准输出

writer.Flush()

file, err := os.Create("testFmt.txt")

if err != nil {

log.Fatal(err)

}

defer file.Close()

writer1 := bufio.NewWriter(file)

_, err = fmt.Fprintf(writer1, "测试方法：%s\n", "Fprintf")

if err != nil {

log.Fatal(err)

}

prompt := "测试方法：%s\n"

prompt = fmt.Sprintf(prompt, "Sprintf", 4)

//串联输入的字符串参数，如果并不是都是字符串，则用空格将其分隔

fmt.Println(prompt)

fmt.Print(prompt, "\n") //两者的区别在于Println会自动换行，而Print不会

//串联所有输出生成并返回一个字符串。如果两个相邻的参数都不是字符串，会在它们的输出之间添加空格

prompt1 := fmt.Sprint("测试", "Sprint", ", 方法 ", 5, "fmt")

fmt.Println(prompt1)

fmt.Fprintln(writer1, "测试", "Fprintln", ", 方法 ", 6, "fmt")

writer1.Flush()

prompt2 := fmt.Sprintln("测试", "Sprintln", ", 方法 ", 7, " fmt")

fmt.Println(prompt2)

err = fmt.Errorf("测试方法： %s ", "Errorf")

if err != nil {

log.Fatal(err)

}

}