关于golang的fmt模块的样例测试
本例来自 C:\Go\src\fmt\fmt_test.go
fmt来讲已经是讲的比较多的了，我就从另外一个角度来看看go源码中的一些测试，实际里面也有一些不确定性。官方的测试。当然测试细节也太繁琐了，只能用到在看了，我也不可能面面俱到了，但是从另外一个角度可以去看出fmt还是有很多小细节的。
| 说明符 | 类型 | 描述 | 样例 |
|---|---|---|---|
| %s | string | 字符串输出，默认右对齐 |
var str5 = "a" |
| %d | int | 十进制,默认右对齐 |
var daligntest int =5 |
%-Nd |
-表示左对齐，N表示字符宽度为N |
numbertest:=10 |
|
| %f | float | 浮点数 | 3.14 |
| %t | bool | 布尔值 | true/false |
| %p | pointer | 内存地址 | 0xc000010090 |
| %v | any |
%v默认格式输出,可以是任意值,适用于任意类型 |
var vf3 [3]float64 var i interface{} = 23 //interface泛型 |
| %#v | 用来查看初始化和数据具体情况 |
例子1: //依据上面的代码，我们可以建立新的变量,初始化代码 content := []byte("this is Go.") var names [3]string var vbool3 [3]bool //我们借助上面的代码，就可以声明为下面的方式 testbool:=[3]bool{false, false, false}
//定义一个数组，每个元素也是数组 fmt.Printf("10: %#v\n", [3]string{1: "kk"}) //[3]string{"", "kk", ""} |
|
| %T | any | 值的类型 |
var vbool bool |
| %b | number | 二进制数 | |
| %x | 十六进制数输出,请看下面的vtest函数 |
来自: C:\Go\src\fmt\fmt_test.go {"%2x", []byte{}, " "}, {"%#2x", []byte{}, " "}, {"% 02x", []byte{}, "00"}, {"%# 02x",[]byte{}, "00"}, {"%-2x", []byte{}, " "}, {"%-02x", []byte{}, " "}, {"%8x", []byte{0xab}, " ab"}, {"% 8x", []byte{0xab}, " ab"}, {"%#8x", []byte{0xab}, " 0xab"}, {"%# 8x", []byte{0xab}, " 0xab"}, {"%08x", []byte{0xab}, "000000ab"}, {"% 08x", []byte{0xab}, "000000ab"}, {"%#08x", []byte{0xab}, "00000xab"}, {"%# 08x",[]byte{0xab}, "00000xab"}, {"%10x", []byte{0xab, 0xcd}, " abcd"}, {"% 10x", []byte{0xab, 0xcd}, " ab cd"}, {"%#10x", []byte{0xab, 0xcd}, " 0xabcd"}, {"%# 10x",[]byte{0xab, 0xcd}, " 0xab 0xcd"}, {"%010x", []byte{0xab, 0xcd}, "000000abcd"}, {"% 010x",[]byte{0xab, 0xcd}, "00000ab cd"}, {"%#010x",[]byte{0xab, 0xcd}, "00000xabcd"}, {"%# 010x",[]byte{0xab, 0xcd},"00xab 0xcd"}, {"%-10X", []byte{0xab}, "AB "}, {"% -010X",[]byte{0xab}, "AB "}, {"%#-10X", []byte{0xab, 0xcd},"0XABCD "}, {"%# -010X",[]byte{0xab, 0xcd},"0XAB 0XCD "}, |
|
| %q | 转义、请看下面的escapedstrings函数 |
var ss=`"abc"` |
测试大部分来自 C:\Go\src\fmt\fmt_test.go，有些一看就明白的就不做标注了
package main import( "fmt" )
/* 1.%x 输出十六进制 */ func vtest(){ // Padding with byte slices. var fmtTests = []struct { fmt string val interface{} out string }{ //[]byte{}属于特殊情况 {"%2x", []byte{}, " "}, {"%#2x", []byte{}, " "}, //2表示占位2个字符宽度,#原始字面值显示 {"% 02x", []byte{}, "00"}, //占据2个字符宽度 {"%# 02x", []byte{}, "00"}, {"%-2x", []byte{}, " "}, //左对齐,2表示占据2个字符宽度 {"%-02x", []byte{}, " "}, {"%8x", []byte{0xab}, " ab"}, //8表示字符宽度为8，其他位置用空格填充 {"% 8x", []byte{0xab}, " ab"}, //%后面的空格表示字符之间用空格 {"% 10x", []byte{'a', 'b'}, " 61 62"}, //%右对齐，,10表示字符宽度,x表示16进制显示 {"%#8x", []byte{0xab}, " 0xab"}, {"%# 8x", []byte{0xab}, " 0xab"}, {"%08x", []byte{0xab}, "000000ab"}, {"% 08x", []byte{0xab}, "000000ab"}, //8表示8个字符宽度,0表示字符不足部分用0填充 {"%#08x", []byte{0xab}, "00000xab"}, //#表示原始字符形式显示,0表示字符不够8，则填充0，8表示8个字符宽度 {"%# 08x", []byte{0xab}, "00000xab"}, {"%10x", []byte{0xab, 0xcd}, " abcd"}, //一共10个字符 {"% 10x", []byte{0xab, 0xcd}, " ab cd"}, //10表示10个字符宽度，%后的空格表示字节之间按照空格隔开 {"%#10x", []byte{0xab, 0xcd}, " 0xabcd"}, //前面以空格填充 {"%# 10x", []byte{0xab, 0xcd}, " 0xab 0xcd"}, //字符中间以空格隔开,字符宽度一共为10 {"%010x", []byte{0xab, 0xcd}, "000000abcd"}, //字符之间无空格，字符宽度一共10个字符，空的用空格填充 {"% 010x", []byte{0xab, 0xcd}, "00000ab cd"}, {"%#010x", []byte{0xab, 0xcd}, "00000xabcd"}, {"%# 010x", []byte{0xab, 0xcd}, "00xab 0xcd"}, {"%-10X", []byte{0xab}, "AB "}, //左对齐,右边以空格填充,一共10个位置 {"% -010X", []byte{0xab}, "AB "}, {"%#-10X", []byte{0xab, 0xcd}, "0XABCD "}, {"%# -010X", []byte{0xab, 0xcd}, "0XAB 0XCD "}, //#按照原始字符显示，-左对齐,-前面的空格表示字节之间按照空格隔开，10表示10个字符宽度 } //%10.3s：输出字符串的前 3 个字符，总宽度为 10（右对齐）。 //%10s 是对齐 for _, tt := range fmtTests { fmt.Printf("%10s %v %10s \n", tt.fmt,tt.val, tt.out) } } /* 字符串格式化 1.%s 针对字符串和字节 */ func stringformatting百分号x(){ var fmtTests2 = []struct { fmt string val interface{} out string }{ {"%x", "", ""}, {"% x", "", ""}, {"%#x", "", ""}, {"%# x", "", ""}, {"%s", "abc", "abc"}, {"%q", "abc", `"abc"`}, //转义" " {"%x", "abc", "616263"}, //显示十六进制数 {"%x", "\xff\xf0\x0f\xff", "fff00fff"}, {"%X", "\xff\xf0\x0f\xff", "FFF00FFF"}, {"%x", "xyz", "78797a"}, {"%X", "xyz", "78797A"}, //z(十六进制A),输出字符大写(如果有字母) {"% x", "xyz", "78 79 7a"}, {"% X", "xyz", "78 79 7A"}, //% X，中间有隔空代表十六进制数会以空格隔开 {"%#x", "xyz", "0x78797a"}, //输出字符 0x为前缀的十六进制数 {"%#X", "xyz", "0X78797A"}, //输出字符 0X为之前的十六进制数(字母大写) {"%# x", "xyz", "0x78 0x79 0x7a"}, {"%# X", "xyz", "0X78 0X79 0X7A"}, } for _, tt2 := range fmtTests2 { fmt.Printf("%-20s %v %-30s \n", tt2.fmt,tt2.val, tt2.out) } } /* %q 安全的转义表示 */ func escapedstrings(){ var fmtTests = []struct { fmt string val interface{} out string }{ {"%q", "\a\b\f\n\r\t\v\"\\", `"\a\b\f\n\r\t\v\"\\"`}, {"%+q", "\a\b\f\n\r\t\v\"\\", `"\a\b\f\n\r\t\v\"\\"`}, {"%#q", "\a\b\f\n\r\t\v\"\\", `"\a\b\f\n\r\t\v\"\\"`}, {"%#+q", "\a\b\f\n\r\t\v\"\\", `"\a\b\f\n\r\t\v\"\\"`}, //#代表字面字符 {"%#8q", "\n", ` "\n"`}, {"%#+8q", "\r", ` "\r"`}, {"%#-8q", "\t", "` ` "}, {"%#+-8q", "\b", `"\b" `}, {"%q", "\n", `"\n"`}, {"%#q", "\n", `"\n"`}, {"%q", `\n`, `"\\n"`}, {"%#q", `\n`, "`\\n`"}, {"%q", "abc", `"abc"`}, {"%#q", "abc", "`abc`"}, {"%q", "", `""`}, {"%#q", "", "``"}, {"%q", "\"", `"\""`}, {"%#q", "\"", "`\"`"}, {"%q", "`", `"` + "`" + `"`}, {"%#q", "`", `"` + "`" + `"`}, //输出带引号的字符,这里要注意#的作用,以下分三种情况 {"%q", "日本語", `"日本語"`},
{"%10q", "⌘", ` "⌘"`}, // 输出10个宽度字符
{"% q", "☺", `"☺"`}, // The space modifier should have no effect.
{"%-10q", "⌘", `"⌘" `}, //-左对齐,10个字符宽度
{"%010q", "⌘", `0000000"⌘"`}, //0表示用0填充空格位置,10表示10个字符宽度,q表示输出转义
{"%q", "abc\xffdef", `"abc\xffdef"`},
{"%-010q", "⌘", `"⌘" `}, // 0 has no effect when - is present.
有#号情况 {"%#q", "日本語", "`日本語`"}, {"%#+q", "日本語", "`日本語`"}, //有#时，+号阻止转成unicode编码 {"%q", "☺", `"☺"`}, {"%#q", "☺", "`☺`"}, {"%#+q", "☺", "`☺`"},
{"%#q", "abc\xffdef", `"abc\xffdef"`},//#表示字面字符 {"%#+q", "abc\xffdef", `"abc\xffdef"`},
%+q里面的+号表示输出unicode编码
{"%+q", "☺", `"\u263a"`}, //+表示转成unicode编码 {"%+10q", "⌘", ` "\u2318"`}, //+代表转成unicode编码,10表示占10个字符宽度,""占据2个字符,前面留个2个空格字符 {"%+q", "日本語", `"\u65e5\u672c\u8a9e"`}, {"%+-10q", "⌘", `"\u2318" `}, //_表示转成unicode字符,-表示左对齐,10表示占据10个字符宽度 {"%+010q", "⌘", `00"\u2318"`}, {"%+-010q", "⌘", `"\u2318" `}, {"%+q", "abc\xffdef", `"abc\xffdef"`}, } for _, tt := range fmtTests { c:=fmt.Sprintf("%q", tt.val) fmt.Printf("%-10s %s %s \n", tt.fmt ,c,tt.out) } } func Runestest(){ var fmtTests = []struct { fmt string val interface{} out string }{ // Runes打印不了 {"%q", "\U0010ffff", `"\U0010ffff"`}, {"%+q", "\U0010ffff", `"\U0010ffff"`}, {"%#q", "\U0010ffff", "``"}, {"%#+q", "\U0010ffff", "``"}, // Runes不是有效值,%q 反义 {"%q", string(rune(0x110000)), `"�"`}, //输出带引号的字符串 {"%+q", string(rune(0x110000)), `"\ufffd"`}, {"%#q", string(rune(0x110000)), "`�`"}, {"%#+q", string(rune(0x110000)), "`�`"}, //rune字符举例 %c打印unicode字符 //%c表示输出unicode字符 {"%c", uint('x'), "x"}, {"%c", 0xe4, "ä"}, {"%c", 0x672c, "本"}, {"%c", '日', "日"}, {"%.0c", '⌘', "⌘"}, //.0表示截取1个 {"%3c", '⌘', " ⌘"}, //如果字符串是unicode字符，则不变,3表示占据宽度,不足3个字符，用空格填充 {"%-3c", '⌘', "⌘ "}, } for _, tt := range fmtTests { c:=fmt.Sprintf("%q",tt.val) fmt.Printf("%-10s %q %s \n", tt.fmt,c,tt.out) } } func widthtest(){ var fmtTests = []struct { fmt string val interface{} out string }{ {"%5s", "abc", " abc"}, //最大宽度5，不足部分空格填补 {"%5s", []byte("abc"), " abc"}, {"%2s", "\u263a", " ☺"}, //最大宽度2,不足部分空格填补 {"%2s", []byte("\u263a"), " ☺"}, {"%-5s", "abc", "abc "}, //左对齐,最大宽度5，不足部分空格填补 {"%-5s", []byte("abc"), "abc "}, //左对齐 {"%05s", "abc", "00abc"}, //右对齐，最大宽度5个字符，空格用0填充 {"%05s", []byte("abc"), "00abc"}, ////右对齐，空格用0填充 {"%5s", "abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz"}, //如果字符宽度超过5，则默认显示 {"%5s", []byte("abcdefghijklmnopqrstuvwxyz"), "abcdefghijklmnopqrstuvwxyz"}, //-符号表示左对齐 {"%08q", "abc", `000"abc"`}, //最大宽度8,不足部分用0填充，""算2个字符宽度 {"%-8q", "abc", `"abc" `}, //左对齐,宽度为8，空余部分留空 {"%-8q", []byte("abc"), `"abc" `}, // //右对齐,10个空格 {"%10v", nil, " <nil>"}, {"%-10v", nil, "<nil> "}, //<nil>算5个字符，空余5个，左对齐 //.的作用是截取几个字符、字节等 {"%.5s", "abcdefghijklmnopqrstuvwxyz", "abcde"}, {"%.0s", "日本語日本語", ""}, {"%.0s", []byte("日本語日本語"), ""}, //.0表示不截取，输出空 {"%.5s", "日本語日本語", "日本語日本"}, //.5表示截取5个rune字符 {"%.5s", []byte("日本語日本語"), "日本語日本"}, {"%.10s", "日本語日本語", "日本語日本語"}, //.10表示截取10个rune字符，但是不足10个，所以都截取 {"%.10s", []byte("日本語日本語"), "日本語日本語"}, {"%.6x", []byte("abcdefghijklmnopqrstuvwxyz"), "6162636465"}, //打印[]byte中的6个字节 {"%.5q", "abcdefghijklmnopqrstuvwxyz", `"abcde"`}, {"%.5q", []byte("abcdefghijklmnopqrstuvwxyz"), `"abcde"`}, {"%.5x", "abcdefghijklmnopqrstuvwxyz", "6162636465"}, {"%.4q", "日本語日本語", `"日本語日"`}, //打印字符串中的4个 {"%.1q", "日本語", `"日"`}, //截取1个rune字符串 {"%.1q", []byte("日本語"), `"日"`}, {"%.1x", "日本語", "e6"}, //截取日字第一个字节的内容 {"%.1X", []byte("日本語"), "E6"},//截取日字第一个字节的内容 {"%10.1q", "日本語日本語", ` "日"`}, {"%10.1q", []byte("日本語日本語"), ` "日"`}, //10代表显示10个字符宽度,.1表示截取1个rune字符 q显示十进制 {"%.10s", []byte("abcdefghijklmnopqrstuvwxyz"), "abcdefghij"}, //.10截取10个字符,这个在 C:\Go\src\fmt\fmt_test.go 中是错误的 {"%08q", []byte("abc"), `000"abc"`}, {"%.3q", []byte("日本語日本語"), `"日本語"`},//.3表示打印字节数组中的3个字符 } format := "%-10v %3v %2v \n" for _, tt := range fmtTests { c:= fmt.Sprintf(tt.fmt, tt.val) //Sprintf返回接收 fmt.Printf(format,tt.fmt,tt.val,c) } fmt.Printf("% x\n",[]byte("日本語日本語")) //输出十六进制数 e6 97 a5 e6 9c ac e8 aa 9e e6 97 a5 e6 9c ac e8 aa 9e //一个汉字一般占3个字节 fmt.Printf("%0.1x\n",[]byte("日本語日本語")) //"e6" //截取日字第一个字节的内容 fmt.Printf("% d\n",[]byte("日本語日本語")) //[ 230 151 165 230 156 172 232 170 158 230 151 165 230 156 172 232 170 158] //正确写法 fmt.Printf("% .3q\n",[]byte("日本語日本語")) //"日本語" //下面是错误写法 //fmt.Printf("%.3 q\n",[]byte("日本語日本語")) fmt.Printf("%.5q",[]byte("a日本b語日本語")) //"a日本b語" fmt.Printf("%.3q",[]byte("日本語日本語")) //"日本語" } func Ttest(){ /* {"%T", byte(0), "uint8"}, {"%T", reflect.ValueOf(nil), "reflect.Value"}, {"%T", (4 - 3i), "complex128"}, {"%T", renamedComplex128(4 - 3i), "fmt_test.renamedComplex128"}, {"%T", intVar, "int"}, {"%6T", &intVar, " *int"}, //占据6个字符，右对齐输出 {"%10T", nil, " <nil>"}, //占据10个字符，右对齐输出 {"%-10T", nil, "<nil> "}, //左对齐输出 */ } //#p指针测试 func testpoint(){ var intVar int=0 var fmtTests = []struct { fmt string val interface{} out string }{ // %p with pointers {"%p", (*int)(nil), "0x0"}, {"%#p", (*int)(nil), "0"}, {"%v", nil, "<nil>"}, //按照原始值输出 {"%#v", nil, "<nil>"}, {"%8.2p", (*int)(nil), " 0x00"}, {"%p", nil, "%!p(<nil>)"}, // nil on its own has no type ... {"%#p", nil, "%!p(<nil>)"}, // ... and hence is not a pointer type. {"%v", (*int)(nil), "<nil>"}, {"%#v", (*int)(nil), "(*int)(nil)"}, {"%8.2v", (*int)(nil), " <nil>"}, {"%p", &intVar, "0xPTR"}, //%p 0xc00000a0a8 0xc00000a0a8 {"%#p", &intVar, "PTR"}, // pointers with specified base {"%b", &intVar, "PTR_b"}, {"%d", &intVar, "PTR_d"}, {"%o", &intVar, "PTR_o"}, {"%x", &intVar, "PTR_x"}, {"%X", &intVar, "PTR_X"}, {"%-20.16p", &intVar, "0xPTR "}, // %p on non-pointers {"%p", make(chan int), "0xPTR"}, {"%p", make(map[int]int), "0xPTR"}, {"%p", func() {}, "0xPTR"}, {"%p", 27, "%!p(int=27)"}, // not a pointer at all // %v on pointers {"%v", &intVar, "0xPTR"}, {"%#v", &intVar, "(*int)(0xPTR)"}, {"%-20.16v", &intVar, "0xPTR "}, // erroneous things {"", nil, "%!(EXTRA <nil>)"}, {"", 2, "%!(EXTRA int=2)"}, {"no args", "hello", "no args%!(EXTRA string=hello)"}, {"%s %", "hello", "hello %!(NOVERB)"}, {"%s %.2", "hello", "hello %!(NOVERB)"}, {"%017091901790959340919092959340919017929593813360", 0, "%!(NOVERB)%!(EXTRA int=0)"}, {"%184467440737095516170v", 0, "%!(NOVERB)%!(EXTRA int=0)"}, // Extra argument errors should format without flags set. {"%010.2", "12345", "%!(NOVERB)%!(EXTRA string=12345)"}, } format := "%-10v %3v %2v \n" for _, tt := range fmtTests { c:= fmt.Sprintf(tt.fmt, tt.val) //Sprintf返回接收 fmt.Printf(format,tt.fmt,tt.val,c) } } func Utest(){ var fmtTests = []struct { fmt string val interface{} out string }{ // unicode format {"%U", 0, "U+0000"}, {"%U", -1, "U+FFFFFFFFFFFFFFFF"}, {"%U", '\n', `U+000A`}, {"%#U", '\n', `U+000A`}, {"%+U", 'x', `U+0078`}, // %+U中的+号应该不会有结果 {"%# U", 'x', `U+0078 'x'`}, // %# U里面的空格应该不会有结果 {"%U", '\u263a', `U+263A`}, {"%#U", '\u263a', `U+263A '☺'`}, {"%U", '\U0001D6C2', `U+1D6C2`}, {"%#U", '\U0001D6C2', `U+1D6C2 '𝛂'`}, {"%#14.6U", '⌘', " U+002318 '⌘'"}, //默认右对齐 {"%#-14.6U", '⌘', "U+002318 '⌘' "}, //-左对齐,.6表示输出6位数字 002318 {"%#014.6U", '⌘', " U+002318 '⌘'"}, {"%#-014.6U", '⌘', "U+002318 '⌘' "}, //表示左对齐,14个字符,.6表示unicode字符输出6位(打印4个非0数字) //fmt.Printf("%.6U\n",'⌘') //U+002318 {"%#.2U", 'x', `U+0078 'x'`}, //实际没有作用,只有.6有作用 } format := "%-10v %3v %2v \n" for _, tt := range fmtTests { c:= fmt.Sprintf(tt.fmt, tt.val) //Sprintf返回接收 fmt.Printf(format,tt.fmt,tt.val,c) } //比较一下他们的输出 //输出unicode码和原始字符 fmt.Printf("%#-14.6U\n",'⌘') //U+002318 '⌘' //去掉.6,不输出00 fmt.Printf("%#-14U\n",'⌘') //U+2318 '⌘' //不输出原始字符,输出unicode code point ,取6个字符，不算U+ fmt.Printf("%.6U\n",'⌘') //U+002318 fmt.Printf("%#.3U\n",'x') //U+0078 'x' fmt.Printf("%#.2U\n",'x') //U+0078 'x' fmt.Printf("%#.6U\n",'x') //U+000078 'x' //fmt.Printf("%#-14.6U","⌘") //如果是双引号就得不到想要的结果，因为不rune } func floattest(){ var fmtTests = []struct { fmt string val interface{} out string }{ // floats {"%+.3e", 0.0, "+0.000e+00"},
{"%+.2e", 0.0, "+0.00e+00"} //fmt.Printf("%+.2e\n", 0.0) //+0.00e+00 {"%+.3e", 1.0, "+1.000e+00"},
{"%+.2e", 1.0, "+1.00e+00"} //fmt.Printf("%+.2e\n", 1.0) //+0.00e+00 {"%+.3x", 0.0, "+0x0.000p+00"}, {"%+.3x", 1.0, "+0x1.000p+00"}, {"%+.3f", -1.0, "-1.000"}, {"%+.3F", -1.0, "-1.000"}, {"%+.3F", float32(-1.0), "-1.000"}, {"%+07.2f", 1.0, "+001.00"}, {"%+07.2f", -1.0, "-001.00"}, {"%-07.2f", 1.0, "1.00 "}, {"%-07.2f", -1.0, "-1.00 "}, {"%+-07.2f", 1.0, "+1.00 "}, {"%+-07.2f", -1.0, "-1.00 "}, {"%-+07.2f", 1.0, "+1.00 "}, {"%-+07.2f", -1.0, "-1.00 "}, {"%+10.2f", +1.0, " +1.00"}, {"%+10.2f", -1.0, " -1.00"}, {"% .3E", -1.0, "-1.000E+00"}, {"% .3e", 1.0, " 1.000e+00"}, {"% .3X", -1.0, "-0X1.000P+00"}, {"% .3x", 1.0, " 0x1.000p+00"}, {"%+.3g", 0.0, "+0"}, {"%+.3g", 1.0, "+1"}, {"%+.3g", -1.0, "-1"}, {"% .3g", -1.0, "-1"}, {"% .3g", 1.0, " 1"}, {"%b", float32(1.0), "8388608p-23"}, {"%b", 1.0, "4503599627370496p-52"}, // Test sharp flag used with floats. {"%#g", 1e-323, "1.00000e-323"}, {"%#g", -1.0, "-1.00000"}, {"%#g", 1.1, "1.10000"}, {"%#g", 123456.0, "123456."}, {"%#g", 1234567.0, "1.234567e+06"}, {"%#g", 1230000.0, "1.23000e+06"}, {"%#g", 1000000.0, "1.00000e+06"}, {"%#.0f", 1.0, "1."}, {"%#.0e", 1.0, "1.e+00"}, {"%#.0x", 1.0, "0x1.p+00"}, {"%#.0g", 1.0, "1."}, {"%#.0g", 1100000.0, "1.e+06"}, {"%#.4f", 1.0, "1.0000"}, {"%#.4e", 1.0, "1.0000e+00"}, {"%#.4x", 1.0, "0x1.0000p+00"}, {"%#.4g", 1.0, "1.000"}, {"%#.4g", 100000.0, "1.000e+05"}, {"%#.4g", 1.234, "1.234"}, {"%#.4g", 0.1234, "0.1234"}, {"%#.4g", 1.23, "1.230"}, {"%#.4g", 0.123, "0.1230"}, {"%#.4g", 1.2, "1.200"}, {"%#.4g", 0.12, "0.1200"}, {"%#.4g", 10.2, "10.20"}, {"%#.4g", 0.0, "0.000"}, {"%#.4g", 0.012, "0.01200"}, {"%#.0f", 123.0, "123."}, {"%#.0e", 123.0, "1.e+02"}, {"%#.0x", 123.0, "0x1.p+07"}, {"%#.0g", 123.0, "1.e+02"}, {"%#.4f", 123.0, "123.0000"}, {"%#.4e", 123.0, "1.2300e+02"}, {"%#.4x", 123.0, "0x1.ec00p+06"}, {"%#.4g", 123.0, "123.0"}, {"%#.4g", 123000.0, "1.230e+05"}, {"%#9.4g", 1.0, " 1.000"}, {"%#b", 1.0, "4503599627370496p-52"}, // Precision has no effect for binary float format. {"%.4b", float32(1.0), "8388608p-23"}, {"%.4b", -1.0, "-4503599627370496p-52"}, // complex values {"%.f", 0i, "(0+0i)"}, {"% .f", 0i, "( 0+0i)"}, {"%+.f", 0i, "(+0+0i)"}, {"% +.f", 0i, "(+0+0i)"}, {"%+.3e", 0i, "(+0.000e+00+0.000e+00i)"}, {"%+.3x", 0i, "(+0x0.000p+00+0x0.000p+00i)"}, {"%+.3f", 0i, "(+0.000+0.000i)"}, {"%+.3g", 0i, "(+0+0i)"}, {"%+.3e", 1 + 2i, "(+1.000e+00+2.000e+00i)"}, {"%+.3x", 1 + 2i, "(+0x1.000p+00+0x1.000p+01i)"}, {"%+.3f", 1 + 2i, "(+1.000+2.000i)"}, {"%+.3g", 1 + 2i, "(+1+2i)"}, {"%.3e", 0i, "(0.000e+00+0.000e+00i)"}, {"%.3x", 0i, "(0x0.000p+00+0x0.000p+00i)"}, {"%.3f", 0i, "(0.000+0.000i)"}, {"%.3F", 0i, "(0.000+0.000i)"}, {"%.3F", complex64(0i), "(0.000+0.000i)"}, {"%.3g", 0i, "(0+0i)"}, {"%.3e", 1 + 2i, "(1.000e+00+2.000e+00i)"}, {"%.3x", 1 + 2i, "(0x1.000p+00+0x1.000p+01i)"}, {"%.3f", 1 + 2i, "(1.000+2.000i)"}, {"%.3g", 1 + 2i, "(1+2i)"}, {"%.3e", -1 - 2i, "(-1.000e+00-2.000e+00i)"}, {"%.3x", -1 - 2i, "(-0x1.000p+00-0x1.000p+01i)"}, {"%.3f", -1 - 2i, "(-1.000-2.000i)"}, {"%.3g", -1 - 2i, "(-1-2i)"}, {"% .3E", -1 - 2i, "(-1.000E+00-2.000E+00i)"}, {"% .3X", -1 - 2i, "(-0X1.000P+00-0X1.000P+01i)"}, {"%+.3g", 1 + 2i, "(+1+2i)"}, {"%+.3g", complex64(1 + 2i), "(+1+2i)"}, {"%#g", 1 + 2i, "(1.00000+2.00000i)"}, {"%#g", 123456 + 789012i, "(123456.+789012.i)"}, {"%#g", 1e-10i, "(0.00000+1.00000e-10i)"}, {"%#g", -1e10 - 1.11e100i, "(-1.00000e+10-1.11000e+100i)"}, {"%#.0f", 1.23 + 1.0i, "(1.+1.i)"}, {"%#.0e", 1.23 + 1.0i, "(1.e+00+1.e+00i)"}, {"%#.0x", 1.23 + 1.0i, "(0x1.p+00+0x1.p+00i)"}, {"%#.0g", 1.23 + 1.0i, "(1.+1.i)"}, {"%#.0g", 0 + 100000i, "(0.+1.e+05i)"}, {"%#.0g", 1230000 + 0i, "(1.e+06+0.i)"}, {"%#.4f", 1 + 1.23i, "(1.0000+1.2300i)"}, {"%#.4e", 123 + 1i, "(1.2300e+02+1.0000e+00i)"}, {"%#.4x", 123 + 1i, "(0x1.ec00p+06+0x1.0000p+00i)"}, {"%#.4g", 123 + 1.23i, "(123.0+1.230i)"}, {"%#12.5g", 0 + 100000i, "( 0.0000 +1.0000e+05i)"}, {"%#12.5g", 1230000 - 0i, "( 1.2300e+06 +0.0000i)"}, {"%b", 1 + 2i, "(4503599627370496p-52+4503599627370496p-51i)"}, {"%b", complex64(1 + 2i), "(8388608p-23+8388608p-22i)"}, } format := "%-10v %3v %2v \n" for _, tt := range fmtTests { c:= fmt.Sprintf(tt.fmt, tt.val) //Sprintf返回接收 fmt.Printf(format,tt.fmt,tt.val,c) } } //%b输出二进制 func bytetest(){ var fmtTests = []struct { fmt string val interface{} out string }{ // byte arrays and slices with %b,%c,%d,%o,%U and %v {"%b", [3]byte{65, 66, 67}, "[1000001 1000010 1000011]"}, //输出二进制数 {"%c", [3]byte{65, 66, 67}, "[A B C]"}, //输出unicode字符 {"%d", [3]byte{65, 66, 67}, "[65 66 67]"}, //输出十进制 {"%o", [3]byte{65, 66, 67}, "[101 102 103]"},//输出8进制 {"%U", [3]byte{65, 66, 67}, "[U+0041 U+0042 U+0043]"}, //输出 {"%v", [3]byte{65, 66, 67}, "[65 66 67]"}, //显示原始字符 {"%v", [1]byte{123}, "[123]"}, {"%012v", []byte{}, "[]"}, {"%#012v", []byte{}, "[]byte{}"}, {"%6v", []byte{1, 11, 111}, "[ 1 11 111]"}, {"%06v", []byte{1, 11, 111}, "[000001 000011 000111]"}, //输出6位一组，字符不够6位填充0 {"%-6v", []byte{1, 11, 111}, "[1 11 111 ]"}, //-表示左对齐 {"%-06v", []byte{1, 11, 111}, "[1 11 111 ]"}, {"%#v", []byte{1, 11, 111}, "[]byte{0x1, 0xb, 0x6f}"}, {"%#6v", []byte{1, 11, 111}, "[]byte{ 0x1, 0xb, 0x6f}"}, //输出16进制,默认右对齐,每个字节6位输出 {"%#06v", []byte{1, 11, 111}, "[]byte{0x000001, 0x00000b, 0x00006f}"}, {"%#-6v", []byte{1, 11, 111}, "[]byte{0x1 , 0xb , 0x6f }"}, {"%#-06v", []byte{1, 11, 111}, "[]byte{0x1 , 0xb , 0x6f }"}, // f.space should and f.plus should not have an effect with %v. {"% v", []byte{1, 11, 111}, "[ 1 11 111]"}, {"%+v", [3]byte{1, 11, 111}, "[1 11 111]"}, {"%# -6v", []byte{1, 11, 111}, "[]byte{ 0x1 , 0xb , 0x6f }"}, {"%#+-6v", [3]byte{1, 11, 111}, "[3]uint8{0x1 , 0xb , 0x6f }"}, // f.space and f.plus should have an effect with %d. {"% d", []byte{1, 11, 111}, "[ 1 11 111]"}, {"%+d", [3]byte{1, 11, 111}, "[+1 +11 +111]"}, {"%# -6d", []byte{1, 11, 111}, "[ 1 11 111 ]"}, {"%#+-6d", [3]byte{1, 11, 111}, "[+1 +11 +111 ]"}, // floates with %v {"%v", 1.2345678, "1.2345678"}, {"%v", float32(1.2345678), "1.2345678"}, // complexes with %v {"%v", 1 + 2i, "(1+2i)"}, {"%v", complex64(1 + 2i), "(1+2i)"}, // structs {"%v", A{1, 2, "a", []int{1, 2}}, `{1 2 a [1 2]}`}, {"%+v", A{1, 2, "a", []int{1, 2}}, `{i:1 j:2 s:a x:[1 2]}`}, // +v on structs with Stringable items {"%+v", B{1, 2}, `{I:<1> j:2}`}, {"%+v", C{1, B{2, 3}}, `{i:1 B:{I:<2> j:3}}`}, // other formats on Stringable items {"%s", I(23), `<23>`}, {"%q", I(23), `"<23>"`}, {"%x", I(23), `3c32333e`}, {"%#x", I(23), `0x3c32333e`}, {"%# x", I(23), `0x3c 0x32 0x33 0x3e`}, // Stringer applies only to string formats. {"%d", I(23), `23`}, // Stringer applies to the extracted value. {"%s", reflect.ValueOf(I(23)), `<23>`}, // go syntax {"%#v", A{1, 2, "a", []int{1, 2}}, `fmt_test.A{i:1, j:0x2, s:"a", x:[]int{1, 2}}`}, {"%#v", new(byte), "(*uint8)(0xPTR)"}, {"%#v", TestFmtInterface, "(func(*testing.T))(0xPTR)"}, {"%#v", make(chan int), "(chan int)(0xPTR)"}, {"%#v", uint64(1<<64 - 1), "0xffffffffffffffff"}, {"%#v", 1000000000, "1000000000"}, {"%#v", map[string]int{"a": 1}, `map[string]int{"a":1}`}, {"%#v", map[string]B{"a": {1, 2}}, `map[string]fmt_test.B{"a":fmt_test.B{I:1, j:2}}`}, {"%#v", []string{"a", "b"}, `[]string{"a", "b"}`}, {"%#v", SI{}, `fmt_test.SI{I:interface {}(nil)}`}, {"%#v", []int(nil), `[]int(nil)`}, {"%#v", []int{}, `[]int{}`}, {"%#v", array, `[5]int{1, 2, 3, 4, 5}`}, {"%#v", &array, `&[5]int{1, 2, 3, 4, 5}`}, {"%#v", iarray, `[4]interface {}{1, "hello", 2.5, interface {}(nil)}`}, {"%#v", &iarray, `&[4]interface {}{1, "hello", 2.5, interface {}(nil)}`}, {"%#v", map[int]byte(nil), `map[int]uint8(nil)`}, {"%#v", map[int]byte{}, `map[int]uint8{}`}, {"%#v", "foo", `"foo"`}, {"%#v", barray, `[5]fmt_test.renamedUint8{0x1, 0x2, 0x3, 0x4, 0x5}`}, {"%#v", bslice, `[]fmt_test.renamedUint8{0x1, 0x2, 0x3, 0x4, 0x5}`}, {"%#v", []int32(nil), "[]int32(nil)"}, {"%#v", 1.2345678, "1.2345678"}, {"%#v", float32(1.2345678), "1.2345678"}, // Whole number floats are printed without decimals. See Issue 27634. {"%#v", 1.0, "1"}, {"%#v", 1000000.0, "1e+06"}, {"%#v", float32(1.0), "1"}, {"%#v", float32(1000000.0), "1e+06"}, // Only print []byte and []uint8 as type []byte if they appear at the top level. {"%#v", []byte(nil), "[]byte(nil)"}, {"%#v", []uint8(nil), "[]byte(nil)"}, {"%#v", []byte{}, "[]byte{}"}, {"%#v", []uint8{}, "[]byte{}"}, {"%#v", reflect.ValueOf([]byte{}), "[]uint8{}"}, {"%#v", reflect.ValueOf([]uint8{}), "[]uint8{}"}, {"%#v", &[]byte{}, "&[]uint8{}"}, {"%#v", &[]byte{}, "&[]uint8{}"}, {"%#v", [3]byte{}, "[3]uint8{0x0, 0x0, 0x0}"}, {"%#v", [3]uint8{}, "[3]uint8{0x0, 0x0, 0x0}"}, // slices with other formats {"%#x", []int{1, 2, 15}, `[0x1 0x2 0xf]`}, {"%x", []int{1, 2, 15}, `[1 2 f]`}, {"%d", []int{1, 2, 15}, `[1 2 15]`}, {"%d", []byte{1, 2, 15}, `[1 2 15]`}, {"%q", []string{"a", "b"}, `["a" "b"]`}, {"% 02x", []byte{1}, "01"}, {"% 02x", []byte{1, 2, 3}, "01 02 03"}, // Padding with byte slices. 如果想测试，加下||，在两边，这样就比较明显看到效果 {"|%2x|", []byte{}, " "}, //| | {"%#2x", []byte{}, " "}, {"% 02x", []byte{}, "00"}, {"%# 02x", []byte{}, "00"}, {"%-2x", []byte{}, " "}, {"%-02x", []byte{}, " "}, {"%8x", []byte{0xab}, " ab"}, {"% 8x", []byte{0xab}, " ab"}, {"%#8x", []byte{0xab}, " 0xab"}, {"%# 8x", []byte{0xab}, " 0xab"}, {"%08x", []byte{0xab}, "000000ab"}, {"% 08x", []byte{0xab}, "000000ab"}, {"%#08x", []byte{0xab}, "00000xab"}, {"%# 08x", []byte{0xab}, "00000xab"}, {"%10x", []byte{0xab, 0xcd}, " abcd"}, {"% 10x", []byte{0xab, 0xcd}, " ab cd"}, {"%#10x", []byte{0xab, 0xcd}, " 0xabcd"}, {"%# 10x", []byte{0xab, 0xcd}, " 0xab 0xcd"}, {"%010x", []byte{0xab, 0xcd}, "000000abcd"}, {"% 010x", []byte{0xab, 0xcd}, "00000ab cd"}, {"%#010x", []byte{0xab, 0xcd}, "00000xabcd"}, {"%# 010x", []byte{0xab, 0xcd}, "00xab 0xcd"}, {"%-10X", []byte{0xab}, "AB "}, {"% -010X", []byte{0xab}, "AB "}, {"%#-10X", []byte{0xab, 0xcd}, "0XABCD "}, {"%# -010X", []byte{0xab, 0xcd}, "0XAB 0XCD "}, // Same for strings {"%2x", "", " "}, {"%#2x", "", " "}, {"% 02x", "", "00"}, {"%# 02x", "", "00"}, {"%-2x", "", " "}, {"%-02x", "", " "}, {"%8x", "\xab", " ab"}, {"% 8x", "\xab", " ab"}, {"%#8x", "\xab", " 0xab"}, {"%# 8x", "\xab", " 0xab"}, {"%08x", "\xab", "000000ab"}, {"% 08x", "\xab", "000000ab"}, {"%#08x", "\xab", "00000xab"}, {"%# 08x", "\xab", "00000xab"}, {"%10x", "\xab\xcd", " abcd"}, {"% 10x", "\xab\xcd", " ab cd"}, {"%#10x", "\xab\xcd", " 0xabcd"}, {"%# 10x", "\xab\xcd", " 0xab 0xcd"}, {"%010x", "\xab\xcd", "000000abcd"}, {"% 010x", "\xab\xcd", "00000ab cd"}, {"%#010x", "\xab\xcd", "00000xabcd"}, {"%# 010x", "\xab\xcd", "00xab 0xcd"}, {"%-10X", "\xab", "AB "}, {"% -010X", "\xab", "AB "}, {"%#-10X", "\xab\xcd", "0XABCD "}, {"%# -010X", "\xab\xcd", "0XAB 0XCD "}, } format := "%-10v %3v %2v \n" for _, tt := range fmtTests { c:= fmt.Sprintf(tt.fmt, tt.val) //Sprintf返回接收 fmt.Printf(format,tt.fmt,tt.val,c) } } func main(){ Utest() //testpoint() //widthtest() //escapedstrings() //Runestest() //stringformatting百分号x() //vtest() //数组int() }
浙公网安备 33010602011771号