Golang学习聽-聽fmt聽包
--------------------
//聽Print聽将参数列表聽a聽中的各个参数转换为字符串并写入到标准输出中。
//聽非字符串参数之间会添加空格，返回写入的字节数。
func聽Print(a聽...interface{})聽(n聽int,聽err聽error)
//聽Println聽功能类似聽Print，只不过最后会添加一个换行符。
//聽所有参数之间会添加空格，返回写入的字节数。
func聽Println(a聽...interface{})聽(n聽int,聽err聽error)
//聽Printf聽将参数列表聽a聽填写到格式字符串聽format聽的占位符中。
//聽填写后的结果写入到标准输出中，返回写入的字节数。
func聽Printf(format聽string,聽a聽...interface{})聽(n聽int,聽err聽error)聽
--------------------
//聽功能同上面三个函数，只不过将转换结果写入到聽w聽中。
func聽Fprint(w聽io.Writer,聽a聽...interface{})聽(n聽int,聽err聽error)
func聽Fprintln(w聽io.Writer,聽a聽...interface{})聽(n聽int,聽err聽error)
func聽Fprintf(w聽io.Writer,聽format聽string,聽a聽...interface{})聽(n聽int,err聽error)
--------------------
//聽功能同上面三个函数，只不过将转换结果以字符串形式返回。
func聽Sprint(a聽...interface{})聽string
func聽Sprintln(a聽...interface{})聽string
func聽Sprintf(format聽string,聽a聽...interface{})聽string
--------------------
//聽功能同聽Sprintf，只不过结果字符串被包装成了聽error聽类型。
func聽Errorf(format聽string,聽a聽...interface{})聽error
--------------------
//聽示例
func聽main()聽{聽
聽 聽fmt.Print("a",聽"b",聽1,聽2,聽3,聽"c",聽"d",聽"\n") 聽 //ab1聽2聽3cd聽
聽 聽fmt.Println("a",聽"b",聽1,聽2,聽3,聽"c",聽"d") 聽//聽a聽b聽1聽2聽3聽c聽d
聽 聽fmt.Printf("ab聽%d聽%d聽%d聽cd\n",聽1,聽2,聽3) 聽 //聽ab聽1聽2聽3聽cd
聽 聽if聽err聽:=聽percent(30,聽70,聽90,聽160);聽err聽!=聽nil聽{ 聽 聽 聽 聽 聽 聽 聽聽
聽聽聽聽聽聽聽聽fmt.Println(err)
聽 聽 }
聽 聽 //30%
聽聽聽聽//70%
聽 聽 //90%
聽聽聽聽//数值聽160聽超出范围(100)
}
func聽percent(i聽...int)聽error聽{
聽聽聽聽for聽_,聽n聽:=聽range聽i聽{
聽聽聽聽聽聽聽聽if聽n聽>聽100聽{
聽聽聽聽聽聽聽聽聽聽聽聽return聽fmt.Errorf("数值聽%d聽超出范围（100）",聽n)聽
聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽fmt.Print(n,聽"%\n")
聽聽聽聽}
聽聽聽聽return聽nil
}
--------------------
//聽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
}
//聽Stringer聽由自定义类型实现，用于实现该类型的自定义格式化过程。
//聽当格式化器需要输出该类型的字符串格式时就会调用其聽String聽方法。
type聽Stringer聽interface聽{
聽聽聽聽String()聽string
}
//聽Stringer聽由自定义类型实现，用于实现该类型的自定义格式化过程。
//聽当格式化器需要输出该类型的聽Go聽语法字符串（%#v）时就会调用其聽String聽方法。
type聽GoStringer聽interface聽{
聽聽聽聽GoString()聽string
}
--------------------
//聽示例
type聽Ustr聽string
func聽(us聽Ustr)聽String()聽string聽{
聽聽聽聽return聽strings.ToUpper(string(us))聽
}
func聽(us聽Ustr)聽GoString()聽string聽{ 聽聽聽聽return`"`聽+聽strings.ToUpper(string(us))聽+聽`"`
}
func聽(u聽Ustr)聽Format(f聽fmt.State,聽c聽rune)聽{ 聽聽聽聽
聽聽聽聽write聽:=聽func(s聽string)聽{聽
聽聽聽聽聽聽聽聽f.Write([]byte(s))聽
聽聽聽聽}
聽聽聽聽switch聽c聽{
聽聽聽聽聽聽聽聽case'm',聽'M':
聽聽聽聽聽聽聽聽聽聽聽write("旗标：[")聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽
聽聽聽聽聽聽聽聽聽聽聽聽for聽s聽:=聽"+-聽0#";聽len(s)聽>聽0;聽s聽=聽s[1:]聽{聽聽聽聽
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽if聽f.Flag(int(s[0]))聽{
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽write(s[:1])聽
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽聽聽聽聽write("]")
聽聽聽聽聽聽聽聽聽聽聽聽if聽v,聽ok聽:=聽f.Width();聽ok聽{
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽write("聽|聽宽度："聽+聽strconv.FormatInt(int64(v),聽10))
聽聽聽聽聽聽聽聽聽聽聽聽}
聽 聽 聽 聽 聽 聽if聽v,聽ok聽:=聽f.Precision();聽ok聽{
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽write("聽|聽精度："聽+聽strconv.FormatInt(int64(v),聽10))
聽聽聽聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽case's',聽'v':聽
聽 聽 聽 聽 聽聽聽聽//聽如果使用聽Format聽函数，则必须自己处理所有格式，包括聽%#v
聽聽聽聽聽聽聽聽聽聽聽聽if聽c聽==聽'v'聽&&聽f.Flag('#')聽{
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽write(u.GoString())
聽聽聽聽聽聽聽聽聽聽聽聽}聽else聽{
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽write(u.String())聽
聽聽聽聽聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽default:聽
聽聽聽聽聽聽聽聽聽聽聽聽//聽如果使用聽Format聽函数，则必须自己处理默认输出
聽聽聽聽聽聽聽聽聽聽聽聽write("无效格式："聽+聽string(c))
聽聽聽聽}
}
func聽main()聽{聽
聽聽聽聽u:=Ustr("Hello聽World!") 聽 聽 聽//聽"-"聽标记和聽"0"聽标记不能同时在
聽聽聽聽fmt.printf("%-+聽0#8.5m\n",聽u) //聽旗标：[+-聽#]聽|聽宽度：8聽|聽精度：5
聽聽聽聽fmt.Printf("%+聽0#8.5M\n",聽u)聽聽//聽旗标：[+聽0#]聽|聽宽度：8聽|聽精度：5 聽 聽聽聽聽fmt.Println(u)聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽//聽HELLO聽WORLD! 聽 聽 聽 聽 聽 聽 聽 聽聽
聽 聽 fmt.Printf("%s\n",聽u)聽聽聽聽聽聽聽聽聽//聽HELLO聽WORLD! 聽 聽 聽聽
聽 聽 fmt.Printf("%#v\n",聽u)聽聽聽聽聽聽聽聽//聽"HELLO聽WORLD!" 聽 聽 聽
聽 聽 fmt.Printf("%d\n",聽u)聽聽聽聽聽聽聽聽聽//聽无效格式：d
}
--------------------
//聽Scan聽从标准输入中读取数据，并将数据用空白分割并解析后存入聽a聽提供
//聽的变量中（换行符会被当作空白处理），变量必须以指针传入。
//聽当读到聽EOF聽或所有变量都填写完毕则停止扫描。
//聽返回成功解析的参数数量。
func聽Scan(a聽...interface{})聽(n聽int,聽err聽error)
//聽Scanln聽和聽Scan聽类似，只不过遇到换行符就停止扫描。
func聽Scanln(a聽...interface{})聽(n聽int,聽err聽error)
//聽Scanf聽从标准输入中读取数据，并根据格式字符串聽format聽对数据进行解析，
//聽将解析结果存入参数聽a聽所提供的变量中，变量必须以指针传入。
//聽输入端的换行符必须和聽format聽中的换行符相对应（如果格式字符串中有换行
//聽符，则输入端必须输入相应的换行符）。
//聽占位符聽%c聽总是匹配下一个字符，包括空白，比如空格符、制表符、换行符。
//聽返回成功解析的参数数量。
func聽Scanf(format聽string,聽a聽...interface{})聽(n聽int,聽err聽error)
//聽功能同上面三个函数，只不过从聽r聽中读取数据。
func聽Fscan(r聽io.Reader,聽a聽...interface{})聽(n聽int,聽err聽error)
func聽Fscanln(r聽io.Reader,聽a聽...interface{})聽(n聽int,聽err聽error)
func聽Fscanf(r聽io.Reader,聽format聽string,聽a聽...interface{})聽(n聽int,聽err聽error)
//聽功能同上面三个函数，只不过从聽str聽中读取数据。
func聽Sscan(str聽string,聽a聽...interface{})聽(n聽int,聽err聽error)
func聽Sscanln(str聽string,聽a聽...interface{})聽(n聽int,聽err聽error)
func聽Sscanf(str聽string,聽format聽string,聽a聽...interface{})聽(n聽int,聽err聽error)
--------------------
//聽示例
//聽对于聽Scan聽而言，回车视为空白
func聽main()聽{聽
聽聽聽聽a,聽b,聽c聽:=聽"",聽0,聽false聽
聽聽聽聽fmt.Scan(&a,聽&b,聽&c)聽
聽聽 聽fmt.Println(a,聽b,聽c)
聽聽聽聽//聽在终端执行后，输入聽abc聽1聽回车聽true聽回车
聽聽聽聽//聽结果聽abc聽1聽true
}
//聽对于聽Scanln聽而言，回车结束扫描
func聽main()聽{聽
聽聽 聽a,聽b,聽c聽:=聽"",聽0,聽false聽
聽聽 聽fmt.Scanln(&a,聽&b,聽&c)聽
聽聽聽聽fmt.Println(a,聽b,聽c)
聽聽聽聽//聽在终端执行后，输入聽abc聽1聽true聽回车
聽聽聽聽//聽结果聽abc聽1聽true
}
//聽格式字符串可以指定宽度
func聽main()聽{聽
聽聽聽聽a,聽b,聽c聽:=聽"",聽0,聽false聽
聽聽聽聽fmt.Scanf("%4s%d%t",聽&a,聽&b,聽&c)聽
聽聽 聽fmt.Println(a,聽b,聽c)
聽聽聽聽//聽在终端执行后，输入聽1234567true聽回车
聽聽聽聽//聽结果聽1234聽567聽true
}
--------------------
//聽Scanner聽由自定义类型实现，用于实现该类型的自定义扫描过程。
//聽当扫描器需要解析该类型的数据时，会调用其聽Scan聽方法。
type聽Scanner聽interface聽{
聽聽聽聽//聽state聽用于获取占位符中的宽度信息，也用于从扫描器中读取数据进行解析。
聽聽聽聽//聽verb聽是占位符中的动词聽聽聽聽
聽聽聽聽Scan(state聽ScanState,聽verb聽rune)聽error
}
//聽由扫描器（Scan聽之类的函数）实现，用于给自定义扫描过程提供数据和信息。
type聽ScanState聽interface聽{
聽聽聽聽//聽ReadRune聽从扫描器中读取一个字符，如果用在聽Scanln聽类的扫描器中，
聽聽聽聽//聽则该方法会在读到第一个换行符之后或读到指定宽度之后返回聽EOF。
聽聽聽聽//聽返回“读取的字符”和“字符编码所占用的字节数”
聽聽聽聽ReadRune()聽(r聽rune,聽size聽int,聽err聽error)
聽聽聽聽//聽UnreadRune聽撤消最后一次的聽ReadRune聽操作，
聽聽聽聽//聽使下次的聽ReadRune聽操作得到与前一次聽ReadRune聽相同的结果。
聽聽聽聽UnreadRune()聽error
聽聽聽聽//聽SkipSpace聽为聽Scan聽方法提供跳过开头空白的能力。
聽聽聽聽//聽根据扫描器的不同（Scan聽或聽Scanln）决定是否跳过换行符。
聽聽聽聽SkipSpace()
聽聽聽聽//聽Token聽用于从扫描器中读取符合要求的字符串，
聽聽聽聽//聽Token聽从扫描器中读取连续的符合聽f(c)聽的字符聽c，准备解析。
聽聽聽聽//聽如果聽f聽为聽nil，则使用聽!unicode.IsSpace(c)聽代替聽f(c)。
聽聽聽聽//聽skipSpace：是否跳过开头的连续空白。返回读取到的数据。
聽聽聽聽//聽注意：token聽指向共享的数据，下次的聽Token聽操作可能会覆盖本次的结果。
聽聽聽聽Token(skipSpace聽bool,聽f聽func(rune)聽bool)聽(token聽[]byte,聽err聽error)
聽聽聽聽//聽Width聽返回占位符中的宽度值以及宽度值是否被设置
聽聽聽聽Width()聽(wid聽int,聽ok聽bool)
聽聽聽聽//聽因为上面实现了聽ReadRune聽方法，所以聽Read聽方法永远不应该被调用。
聽聽聽聽//聽一个好的聽ScanState聽应该让聽Read聽直接返回相应的错误信息。
聽聽聽聽Read(buf聽[]byte)聽(n聽int,聽err聽error)聽
}聽
--------------------
//聽示例
type聽Ustr聽string聽
func聽(u聽*Ustr)聽Scan聽(state聽fmt.ScanState,聽verb聽rune)聽(err聽error)聽{ 聽聽聽聽var聽s聽[]byte
聽聽聽聽switch聽verb聽{
聽聽聽聽聽聽聽聽case'S': 聽聽聽聽聽聽聽聽聽聽聽聽
聽聽聽聽聽聽聽聽聽聽聽聽s,聽err聽=聽state.Token(true,聽func(c聽rune)聽bool聽{聽
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽return'A'聽<=聽c聽&&聽c聽<=聽'Z'聽
聽聽聽聽聽聽聽聽聽聽聽聽})
聽聽聽聽聽聽聽聽聽聽聽聽if聽err聽!=聽nil聽{
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽return聽
聽聽聽聽聽聽聽聽聽聽 聽}
聽聽聽聽聽聽聽聽case's',聽'v': 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽
聽聽聽聽聽聽聽聽聽聽聽聽s,聽err聽=聽state.Token(true,聽func(c聽rune)聽bool聽{聽
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽return'a'聽<=聽c聽&&聽c聽<=聽'z'聽
聽聽聽聽聽聽聽聽聽聽聽聽})
聽聽聽聽聽聽聽聽聽聽聽聽if聽err聽!=聽nil聽{
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽return聽
聽聽聽聽聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽default:
聽聽聽聽聽聽聽聽聽聽聽聽return聽fmt.Errorf("无效格式：%c",聽verb)聽
聽聽聽聽}聽
聽聽聽聽*u聽=聽Ustr(s)
聽聽聽聽return聽nil
}
func聽main()聽{
聽聽聽聽var聽a,聽b,聽c,聽d,聽e聽Ustr 聽 聽 聽 聽聽聽聽
聽聽聽聽n,聽err聽:=聽fmt.Scanf("%3S%S%3s%2v%x",聽&a,聽&b,聽&c,聽&d,聽&e)聽聽聽聽
聽聽聽聽fmt.Println(a,聽b,聽c,聽d,聽e)聽
聽聽聽聽fmt.Println(n,聽err)
聽聽聽聽//聽在终端执行后，输入聽ABCDEFGabcdefg聽回车
聽聽聽聽//聽结果：
聽聽聽聽//聽ABC聽DEFG聽abc聽de
聽聽聽聽//聽4聽无效格式：x
}
有疑问加站长微信联系（非本文作者）
