Go语言---fmt包

占位符

普通占位符

占位符                        说明                        举例                                        输出
%v        相应值的默认格式。                     Printf("%v", site),Printf("%+v", site)  {studygolang},{Name:studygolang}
        在打印结构体时,“加号”标记(%+v)会添加字段名
%#v        相应值的Go语法表示                    Printf("%#v", site)                    main.Website{Name:"studygolang"}
%T        相应值的类型的Go语法表示                Printf("%T", site)                     main.Website
%%        字面上的百分号,并非值的占位符          Printf("%%")                            %

布尔占位符

占位符                        说明                        举例                                        输出
%t        单词 true 或 false。                            Printf("%t", true)                         true

整数占位符

占位符                        说明                        举例                                    输出
%b        二进制表示                                    Printf("%b", 5)                        101
%c        相应Unicode码点所表示的字符                    Printf("%c", 0x4E2D)                中
%d        十进制表示                                    Printf("%d", 0x12)                    18
%o        八进制表示                                    Printf("%d", 10)                    12
%q        单引号围绕的字符字面值,由Go语法安全地转义        Printf("%q", 0x4E2D)                '中'
%x        十六进制表示,字母形式为小写 a-f                Printf("%x", 13)                    d
%X        十六进制表示,字母形式为大写 A-F                Printf("%x", 13)                    D
%U        Unicode格式:U+1234,等同于 "U+%04X"            Printf("%U", 0x4E2D)                U+4E2D

浮点数和复数的组成部分(实部和虚部)

占位符                        说明                                         举例                         输出
%b        无小数部分的,指数为二的幂的科学计数法,与 strconv.FormatFloat    
        的 'b' 转换格式一致。例如 -123456p-78
%e        科学计数法,例如 -1234.456e+78                            Printf("%e", 10.2)                  1.020000e+01
%E        科学计数法,例如 -1234.456E+78                            Printf("%e", 10.2)                  1.020000E+01
%f        有小数点而无指数,例如 123.456                             Printf("%f", 10.2)                  10.200000
%g        根据情况选择 %e 或 %f 以产生更紧凑的(无末尾的0)输出        Printf("%g", 10.20)                 10.2
%G        根据情况选择 %E 或 %f 以产生更紧凑的(无末尾的0)输出        Printf("%G", 10.20+2i)              (10.2+2i)

字符串与字节切片

占位符                        说明                                                举例                  输出
%s        输出字符串表示(string类型或[]byte)             Printf("%s", []byte("Go语言中文网"))        Go语言中文网
%q        双引号围绕的字符串,由Go语法安全地转义           Printf("%q", "Go语言中文网")                "Go语言中文网"
%x        十六进制,小写字母,每字节两个字符                Printf("%x", "golang")                    676f6c616e67
%X        十六进制,大写字母,每字节两个字符                Printf("%X", "golang")                    676F6C616E67

指针

占位符              说明                                  举例                                    输出
%p        十六进制表示,前缀 0x                                Printf("%p", &site)              0x4f57f0

宽度与精度的控制格式以Unicode码点为单位。(这点与C的 printf 不同,它以字节数为单位)二者或其中之一均可用字符 '*' 表示,此时它们的值会从下一个操作数中获取,该操作数的类型必须为 int。

对数值而言,宽度为该数值占用区域的最小宽度;精度为小数点之后的位数。 但对于 %g/%G 而言,精度为所有数字的总数。例如,对于123.45,格式 %6.2f 会打印123.45,而 %.4g 会打印123.5。%e 和 %f 的默认精度为6;但对于 %g 而言,它的默认精度为确定该值所必须的最小位数。

注意点:

为避免以下这类递归的情况:

type X string
func (x X) String() string { return Sprintf("<%s>", x) }
需要在递归前转换该值:
func (x X) String() string { return Sprintf("<%s>", string(x)) }

格式化输入输出函数

【格式化输出】

// 格式化输出:将 arg 列表中的 arg 转换为字符串输出

// 使用动词 v 格式化 arg 列表,非字符串元素之间添加空格
Print(arg列表)
// 使用动词 v 格式化 arg 列表,所有元素之间添加空格,结尾添加换行符
Println(arg列表)
// 使用格式字符串格式化 arg 列表
Printf(格式字符串, arg列表)

// Print 类函数会返回已处理的 arg 数量和遇到的错误信息。
【格式化输入】

// 格式化输入:从输入端读取字符串(以空白分隔的值的序列),
// 并解析为具体的值存入相应的 arg 中,arg 必须是变量地址。
// 字符串中的连续空白视为单个空白,换行符根据不同情况处理。
// \r\n 被当做 \n 处理。

// 以动词 v 解析字符串,换行视为空白
Scan(arg列表)
// 以动词 v 解析字符串,换行结束解析
Scanln(arg列表)
// 根据格式字符串中指定的格式解析字符串
// 格式字符串中的换行符必须和输入端的换行符相匹配。
Scanf(格式字符串, arg列表)    //根据类型相匹配,可指定宽度。

// Scan 类函数会返回已处理的 arg 数量和遇到的错误信息。
func Print(a ...interface{}) (n int, err error)     //标准输入输出   输入 os.Stdin   输出  os.Stdout
func Printf(format string, a ...interface{}) (n int, err error)  //返回值:是输入输出的字符的个数 和 eroor返回值,!= nil  产生错误
func Println(a ...interface{}) (n int, err error)
func Scan(a ...interface{}) (n int, err error)
func Scanf(format string, a ...interface{}) (n int, err error)
func Scanln(a ...interface{}) (n int, err error)
//输入输出到字符串中,而不是标准输入输出  sscan 输入的是str字符串代替  标准输入
func Sprint(a ...interface{}) string
func Sprintf(format string, a ...interface{}) string
func Sprintln(a ...interface{}) string
func Sscan(str string, a ...interface{}) (n int, err error)   //str中读取数据
func Sscanf(str string, format string, a ...interface{}) (n int, err error)
func Sscanln(str string, a ...interface{}) (n int, err error)
func Fprint(w io.Writer, a ...interface{}) (n int, err error)  //标准输入输出 文件类型  转换结果写入到 w 中
func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)
func Fprintln(w io.Writer, a ...interface{}) (n int, err error)
func Fscan(r io.Reader, a ...interface{}) (n int, err error)     //从 r 中读取数据。
func Fscanf(r io.Reader, format string, a ...interface{}) (n int, err error)
func Fscanln(r io.Reader, a ...interface{}) (n int, err error)
// 功能同 Sprintf,只不过结果字符串被包装成了 error 类型。
func Errorf(format string, a ...interface{}) error

接口类型

Stringer接口

// Stringer 由自定义类型实现,用于实现该类型的自定义格式化过程。
// 当格式化器需要输出该类型的字符串格式时就会调用其 String 方法。
type Stringer interface {
	String() string
}

程序示例:

package main

import (
	"fmt"
)

// Animal has a Name and an Age to represent an animal.
type Animal struct {
	Name string
	Age  uint
}

// String makes Animal satisfy the Stringer interface.
func (a Animal) String() string {
	return fmt.Sprintf("%v (%d)", a.Name, a.Age)
}

func main() {
	a := Animal{
		Name: "Gopher",
		Age:  2,
	}
	fmt.Println(a)
}                          //输出结果: Gopher (2)
type Person struct {
	Name string
	Age  int
	Sex  int
}

func (this *Person) String() string {
	buffer := bytes.NewBufferString("This is ")
	buffer.WriteString(this.Name + ", ")
	if this.Sex == 0 {
		buffer.WriteString("He ")
	} else {
		buffer.WriteString("She ")
	}
	buffer.WriteString("is ")
	buffer.WriteString(strconv.Itoa(this.Age))
	buffer.WriteString(" years old.")
	return buffer.String()
}

//由 main 函数作为程序入口点启动
func main(){
	p := &Person{"polaris", 28, 0}
	fmt.Println(p)
}                              //输出结果:   This is polaris, He is 28 years old.

GoStringer 接口

// Stringer 由自定义类型实现,用于实现该类型的自定义格式化过程。
// 当格式化器需要输出该类型的 Go 语法字符串(%#v)时就会调用其 String 方法。
type GoStringer interface {
	GoString() string
}       //该接口定义了类型的Go语法格式。用于打印(Printf)格式化占位符为%#v的值。
func (this *Person) GoString() string {    //接上述程序的第二个例程添加函数
    return "&Person{Name is "+this.Name+", Age is "+strconv.Itoa(this.Age)+", Sex is "+strconv.Itoa(this.Sex)+"}"
}

Formatter 接口

// Formatter 由自定义类型实现,用于实现该类型的自定义格式化过程。
// 当格式化器需要格式化该类型的变量时,会调用其 Format 方法。
type Formatter interface {
	// f 用于获取占位符的旗标、宽度、精度等信息,也用于输出格式化的结果
	// c 是占位符中的动词
	Format(f State, c rune)
}

// 由格式化器(Print 之类的函数)实现,用于给自定义格式化过程提供信息
type State interface {
	// Formatter 通过 Write 方法将格式化结果写入格式化器中,以便输出。
	Write(b []byte) (ret int, err error)
	// Formatter 通过 Width 方法获取占位符中的宽度信息及其是否被设置。
	Width() (wid int, ok bool)
	// Formatter 通过 Precision 方法获取占位符中的精度信息及其是否被设置。
	Precision() (prec int, ok bool)
	// Formatter 通过 Flag 方法获取占位符中的旗标[+- 0#]是否被设置。
	Flag(c int) bool
}

Formatter 接口由带有定制的格式化器的值所实现。 Format 的实现可调用 Sprintf 或 Fprintf(f) 等函数来生成其输出。通过实现Formatter接口可以做到自定义输出格式(自定义占位符)。实际上一般我们不需要自己实现Formatter接口,感兴趣的可以去官网看源码包。

参考博客:http://www.cnblogs.com/golove/p/3286303.html
    https://golang.org/pkg/fmt/#Formatter   官网链接

 https://books.studygolang.com/The-Golang-Standard-Library-by-Example/chapter01/01.3.html

阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/li_101357/article/details/80265651
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭