1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

	fmt.Printf("%0*.*f \n", 7, 3, 3.454489123456)  //003.454 
	fmt.Printf("%0*.*f \n", 8, 3, 3.454489123456)  //0003.454
	fmt.Printf("%0*.*f \n", 9, 3, 3.454489123456)  //00003.454  
	fmt.Printf("%0*.*f \n", 10, 3, 3.454489123456) //000003.454  
	fmt.Printf("%0*.*f \n", 11, 3, 3.454489123456) //00000003.454
	fmt.Printf("%0*.*f \n", 12, 3, 3.454489123456) //000000003.454
	fmt.Printf("%0*.*f \n", 13, 3, 3.454489123456) //0000000003.454
	fmt.Printf("%0*.*f \n", 14, 3, 3.454489123456) //00000000003.454
	fmt.Printf("%0*.*f \n", 15, 3, 3.454489123456) //000000000003.454
	fmt.Printf("%0*.*f \n", 16, 3, 3.454489123456) //0000000000003.454

	fmt.Printf("%0*.*f \n", 7, 3, 3.454589123456)  //003.455
	fmt.Printf("%0*.*f \n", 8, 3, 3.454589123456)  //0003.455
	fmt.Printf("%0*.*f \n", 9, 3, 3.454589123456)  //00003.455
	fmt.Printf("%0*.*f \n", 10, 3, 3.454589123456) //000003.455
	fmt.Printf("%0*.*f \n", 11, 3, 3.454589123456) //0000003.455
	fmt.Printf("%0*.*f \n", 12, 3, 3.454589123456) //00000003.455
	fmt.Printf("%0*.*f \n", 13, 3, 3.454589123456) //000000003.455
	fmt.Printf("%0*.*f \n", 14, 3, 3.454589123456) //0000000003.455
	fmt.Printf("%0*.*f \n", 15, 3, 3.454589123456) //00000000003.455
	fmt.Printf("%0*.*f \n", 16, 3, 3.454589123456) //000000000003.455

	fmt.Printf("%0*.*f \n", 7, 3, 3.454689123456)  //003.455
	fmt.Printf("%0*.*f \n", 8, 3, 3.454689123456)  //0003.455
	fmt.Printf("%0*.*f \n", 9, 3, 3.454689123456)  //00003.455
	fmt.Printf("%0*.*f \n", 10, 3, 3.456489123456) //000003.456
	fmt.Printf("%0*.*f \n", 11, 3, 3.456489123456) //0000003.456
	fmt.Printf("%0*.*f \n", 12, 3, 3.456489123456) //00000003.456
	fmt.Printf("%0*.*f \n", 13, 3, 3.456489123456) //000000003.456
	fmt.Printf("%0*.*f \n", 14, 3, 3.456489123456) //0000000003.456
	fmt.Printf("%0*.*f \n", 15, 3, 3.456489123456) //00000000003.456
	fmt.Printf("%0*.*f \n", 16, 3, 3.456489123456) //000000000003.456

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

	fmt.Printf("%08.1f \n", 123.444) // 000123.4 
	fmt.Printf("%08.1f \n", 123.456) // 000123.5

	fmt.Printf("%0.1f \n", 123.444)  // 123.4
	fmt.Printf("%0.1f \n", 123.456)  // 123.5

	fmt.Printf("%08.2f \n", 123.444) // 00123.44
	fmt.Printf("%08.2f \n", 123.456) // 00123.46

	fmt.Printf("%0.2f \n", 123.444)  // 123.44
	fmt.Printf("%0.2f \n", 123.456)  // 123.46

	fmt.Printf("%08.1g \n", 123.444) // 0001e+02
	fmt.Printf("%08.1g \n", 123.456) // 0001e+02

	fmt.Printf("%0.1g \n", 123.444)  // 1e+02
	fmt.Printf("%0.1g \n", 123.456)  // 1e+02

	fmt.Printf("%08.2g \n", 123.444) // 01.2e+02
	fmt.Printf("%08.2g \n", 123.456) // 01.2e+02

	fmt.Printf("%08.3g \n", 123.444) // 00000123
	fmt.Printf("%08.3g \n", 123.456) // 00000123

	fmt.Printf("%08.4g \n", 123.444) // 000123.4
	fmt.Printf("%08.4g \n", 123.456) // 000123.5

	fmt.Printf("%08.5g \n", 123.444) // 00123.44
	fmt.Printf("%08.5g \n", 123.456) // 00123.46

	fmt.Printf("%09.5g \n", 123.444) // 000123.44
	fmt.Printf("%09.5g \n", 123.456) // 000123.46

	fmt.Printf("%010.6g \n", 123.444) // 000123.444 
	fmt.Printf("%010.6g \n", 123.456) // 000123.456 

	fmt.Printf("%011.6g \n", 123.444) // 0000123.444
	fmt.Printf("%011.6g \n", 123.456) // 0000123.456 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

package main

import (
	"fmt"
)

func main() {
	r := []rune("中国\x80")
	for _, v := range r {
		fmt.Printf("%q - %U\n", v, v)
	}
}

1
2

var i interface{} = 23
fmt.Printf("%v\n", i)

1
2

type X string
func (x X) String() string { return Sprintf("<%s>", x) }

1

func (x X) String() string { return Sprintf("<%s>", string(x)) }

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

package main

import (
	"fmt"
	"math"
	"time"
)

func main() {
	// 这是一组基本示例，展示了%v是默认格式，
    // 对于整数来说是十进制的，可以使用%d明确请求；
	// 输出结果与Println生成的输出相同。
	integer := 23
	// 这些每个都会输出"23"(不带引号)。
	fmt.Println(integer)
	fmt.Printf("%v\n", integer)
	fmt.Printf("%d\n", integer)

	// 特殊的%T谓词显示项目的类型，而不是其值。
	fmt.Printf("%T %T\n", integer, &integer)
	// 结果：int *int

	// Println(x)与Printf("％v \ n"，x)相同，
    // 因此在以下示例中只使用Printf。
	// 每个示例演示如何格式化特定类型的值，例如整数或字符串。
	// 我们以%v开头每个格式字符串以显示默认输出，
    // 然后跟随一个或多个自定义格式。

	// 布尔值使用%v或%t打印为"true"或"false"。
	truth := true
	fmt.Printf("%v %t\n", truth, truth)
	// 结果：true true

	// 整数使用%v和％d打印为十进制，
	// 使用%x以十六进制打印，使用%o以八进制打印，使用%b以二进制打印。
	answer := 42
	fmt.Printf("%v %d %x %o %b\n", answer, answer, answer, answer, answer)
	// 结果：42 42 2a 52 101010

	// 浮点数有多种格式：％v和％g以紧凑的形式打印，
	// 而％f打印带有小数点的十进制数，％e使用指数表示法。 
    // 这里使用的格式％6.2f显示如何设置宽度和精度以控制浮点值的外观。 
    // 在此实例中，6是所印文本的总宽度(请注意输出中的额外空格)，
    // 2是要显示的小数位数。
	pi := math.Pi
	fmt.Printf("%v %g %.2f (%6.2f) %e\n", pi, pi, pi, pi, pi)
	// 结果：3.141592653589793 3.141592653589793 3.14(3.14)

	// 复数格式化为带括号的浮点数对，虚部后跟'i'。
	point := 110.7 + 22.5i
	fmt.Printf("%v %g %.2f %.2e\n", point, point, point, point)
	// 结果: (110.7+22.5i) (110.7+22.5i) (110.70+22.50i) (1.11e+02+2.25e+01i)

	// Rune是整数，但当使用%c格式打印时，
    // 会显示具有该Unicode值的字符。
    // %q动词将它们显示为带引号的字符，
    // %U显示为十六进制Unicode码点，
    // %#U则显示为码点和带引号的可打印形式，
    // 如果rune是可打印的，则同时显示两者。
	smile := '😀'
	fmt.Printf("%v %d %c %q %U %#U\n", smile, smile, smile, smile, smile, smile)
	// 结果: 128512 128512 😀 '😀' U+1F600 U+1F600 '😀'

	// 字符串通过%v和%s原样格式化，
    // 通过%q格式化为带引号的字符串，通过%#q格式化为反引号字符串。
	placeholders := `foo "bar"`
	fmt.Printf("%v %s %q %#q\n", placeholders, placeholders, placeholders, placeholders)
	// 结果: foo "bar" foo "bar" "foo \"bar\"" `foo "bar"`

	// 格式化为%v的映射将以其默认格式显示键和值。 
    // %#v形式(#在这种情况下称为"标志")以Go源格式显示映射。 
    // 映射以一致的顺序打印，按键的值排序。
	isLegume := map[string]bool{
		"peanut":    true,
		"dachshund": false,
	}
	fmt.Printf("%v %#v\n", isLegume, isLegume)
	// 结果: map[dachshund:false peanut:true] map[string]bool{"dachshund":false, "peanut":true}

	// 格式化为%v的结构体将以其默认格式显示字段值。 
    // %+v形式按名称显示字段，而%#v格式化结构体的Go源格式。
	person := struct {
		Name string
		Age  int
	}{"Kim", 22}
	fmt.Printf("%v %+v %#v\n", person, person, person)
	// 结果: {Kim 22} {Name:Kim Age:22} struct { Name string; Age int }{Name:"Kim", Age:22}

	// 指针的默认格式显示前面加上取地址符号"&"。 
    // %p动词以十六进制打印指针值。
    // 这里我们使用了一个类型化的nil作为%p的参数，
    // 因为任何非nil指针的值都会从一次运行到另一次运行更改; 
    // 请自己运行被注释的Printf调用以查看。
	pointer := &person
	fmt.Printf("%v %p\n", pointer, (*int)(nil))
	// 结果: &{Kim 22} 0x0
	// fmt.Printf("%v %p\n", pointer, pointer)
	// 结果: &{Kim 22} 0x010203 // See comment above.

	// 数组和切片会将格式应用到每个元素。
	greats := [5]string{"Kitano", "Kobayashi", "Kurosawa", "Miyazaki", "Ozu"}
	fmt.Printf("%v %q\n", greats, greats)
	// 结果: [Kitano Kobayashi Kurosawa Miyazaki Ozu] ["Kitano" "Kobayashi" "Kurosawa" "Miyazaki" "Ozu"]

	kGreats := greats[:3]
	fmt.Printf("%v %q %#v\n", kGreats, kGreats, kGreats)
	// 结果: [Kitano Kobayashi Kurosawa] ["Kitano" "Kobayashi" "Kurosawa"] []string{"Kitano", "Kobayashi", "Kurosawa"}

	// 字节切片是特殊的。
    // 像%d这样的整数格式化指示符以那种格式打印每个元素。 
    // %s和%q格式将切片视为字符串。
    // %x指示符有一个特殊的格式，其中的空格标志将一个空格放在字节之间。
	cmd := []byte("a⌘")
	fmt.Printf("%v %d %s %q %x % x\n", cmd, cmd, cmd, cmd, cmd, cmd)
	// 结果: [97 226 140 152] [97 226 140 152] a⌘ "a⌘" 61e28c98 61 e2 8c 98

	// 实现了Stringer接口的类型与字符串一样打印。
    // 由于Stringers返回一个字符串，我们可以使用字符串特定的格式指示符(如%q)打印它们。
	now := time.Unix(123456789, 0).UTC() // time.Time实现了fmt.Stringer。
	fmt.Printf("%v %q\n", now, now)
	// 结果: 1973-11-29 21:33:09 +0000 UTC "1973-11-29 21:33:09 +0000 UTC"

}
Output:

23
23
23
int *int
true true
42 42 2a 52 101010
3.141592653589793 3.141592653589793 3.14 (  3.14) 3.141593e+00
(110.7+22.5i) (110.7+22.5i) (110.70+22.50i) (1.11e+02+2.25e+01i)
128512 128512 😀 '😀' U+1F600 U+1F600 '😀'
foo "bar" foo "bar" "foo \"bar\"" `foo "bar"`
map[dachshund:false peanut:true] map[string]bool{"dachshund":false, "peanut":true}
{Kim 22} {Name:Kim Age:22} struct { Name string; Age int }{Name:"Kim", Age:22}
&{Kim 22} 0x0
[Kitano Kobayashi Kurosawa Miyazaki Ozu] ["Kitano" "Kobayashi" "Kurosawa" "Miyazaki" "Ozu"]
[Kitano Kobayashi Kurosawa] ["Kitano" "Kobayashi" "Kurosawa"] []string{"Kitano", "Kobayashi", "Kurosawa"}
[97 226 140 152] [97 226 140 152] a⌘ "a⌘" 61e28c98 61 e2 8c 98
1973-11-29 21:33:09 +0000 UTC "1973-11-29 21:33:09 +0000 UTC"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

package main

import (
	"fmt"
	"math"
)

func main() {
	a, b := 3.0, 4.0
	h := math.Hypot(a, b)

	// Print函数在非字符串类型参数之间插入空格。
    // 它不会在输出中添加换行符，因此我们需要显式添加一个换行符。
	fmt.Print("The vector (", a, b, ") has length ", h, ".\n")

	// Println函数始终在其参数之间插入空格，
    // 因此它不能用于在此情况下生成与Print相同的输出；
    // 它的输出带有额外的空格。
	// 此外，Println函数始终在输出中添加换行符。
	fmt.Println("The vector (", a, b, ") has length", h, ".")

	// Printf函数提供完全的控制，但使用起来更加复杂。
	// 它不会在输出中添加换行符，
    // 因此我们需要在格式说明符字符串的末尾显式添加一个换行符。
	fmt.Printf("The vector (%g %g) has length %g.\n", a, b, h)

}
Output:

The vector (3 4) has length 5.
The vector ( 3 4 ) has length 5 .
The vector (3 4) has length 5.

1

func Append(b []byte, a ...any) []byte

1

func Appendf(b []byte, format string, a ...any) []byte

1

func Appendln(b []byte, a ...any) []byte

1

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package main

import (
	"fmt"
)

func main() {
	const name, id = "bueller", 17
	err := fmt.Errorf("user %q (id %d) not found", name, id)
	fmt.Println(err.Error())

}
Output:

user "bueller" (id 17) not found

1

func FormatString(state State, verb rune) string

1

func Fprint(w io.Writer, a ...any) (n int, err error)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package main

import (
	"fmt"
	"os"
)

func main() {
	const name, age = "Kim", 22
	n, err := fmt.Fprint(os.Stdout, name, " is ", age, " years old.\n")

	// The n and err return values from Fprint are
	// those returned by the underlying io.Writer.
	if err != nil {
		fmt.Fprintf(os.Stderr, "Fprint: %v\n", err)
	}
	fmt.Print(n, " bytes written.\n")

}
Output:

Kim is 22 years old.
21 bytes written.

1

func Fprintf(w io.Writer, format string, a ...any) (n int, err error)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package main

import (
	"fmt"
	"os"
)

func main() {
	const name, age = "Kim", 22
	n, err := fmt.Fprintf(os.Stdout, "%s is %d years old.\n", name, age)

	// The n and err return values from Fprintf are
	// those returned by the underlying io.Writer.
	if err != nil {
		fmt.Fprintf(os.Stderr, "Fprintf: %v\n", err)
	}
	fmt.Printf("%d bytes written.\n", n)

}
Output:

Kim is 22 years old.
21 bytes written.

1

func Fprintln(w io.Writer, a ...any) (n int, err error)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package main

import (
	"fmt"
	"os"
)

func main() {
	const name, age = "Kim", 22
	n, err := fmt.Fprintln(os.Stdout, name, "is", age, "years old.")

	// The n and err return values from Fprintln are
	// those returned by the underlying io.Writer.
	if err != nil {
		fmt.Fprintf(os.Stderr, "Fprintln: %v\n", err)
	}
	fmt.Println(n, "bytes written.")

}
Output:

Kim is 22 years old.
21 bytes written.

1

func Fscan(r io.Reader, a ...any) (n int, err error)

1

func Fscanf(r io.Reader, format string, a ...any) (n int, err error)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package main

import (
	"fmt"
	"os"
	"strings"
)

func main() {
	var (
		i int
		b bool
		s string
	)
	r := strings.NewReader("5 true gophers")
	n, err := fmt.Fscanf(r, "%d %t %s", &i, &b, &s)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Fscanf: %v\n", err)
	}
	fmt.Println(i, b, s)
	fmt.Println(n)
}
Output:

5 true gophers
3

1

func Fscanln(r io.Reader, a ...any) (n int, err error)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package main

import (
	"fmt"
	"io"
	"strings"
)

func main() {
	s := `dmr 1771 1.61803398875
	ken 271828 3.14159`
	r := strings.NewReader(s)
	var a string
	var b int
	var c float64
	for {
		n, err := fmt.Fscanln(r, &a, &b, &c)
		if err == io.EOF {
			break
		}
		if err != nil {
			panic(err)
		}
		fmt.Printf("%d: %s, %d, %f\n", n, a, b, c)
	}
}
Output:

3: dmr, 1771, 1.618034
3: ken, 271828, 3.141590

1

func Print(a ...any) (n int, err error)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package main

import (
	"fmt"
)

func main() {
	const name, age = "Kim", 22
	fmt.Print(name, " is ", age, " years old.\n")

	// It is conventional not to worry about any
	// error returned by Print.

}
Output:

Kim is 22 years old.

1

func Printf(format string, a ...any) (n int, err error)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package main

import (
	"fmt"
)

func main() {
	const name, age = "Kim", 22
	fmt.Printf("%s is %d years old.\n", name, age)

	// It is conventional not to worry about any
	// error returned by Printf.

}
Output:

Kim is 22 years old.

1

func Println(a ...any) (n int, err error)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package main

import (
	"fmt"
)

func main() {
	const name, age = "Kim", 22
	fmt.Println(name, "is", age, "years old.")

	// It is conventional not to worry about any
	// error returned by Println.

}
Output:

Kim is 22 years old.

1

func Scan(a ...any) (n int, err error)

1

func Scanf(format string, a ...any) (n int, err error)

1

func Scanln(a ...any) (n int, err error)

1

func Sprint(a ...any) string

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package main

import (
	"fmt"
	"io"
	"os"
)

func main() {
	const name, age = "Kim", 22
	s := fmt.Sprint(name, " is ", age, " years old.\n")

	io.WriteString(os.Stdout, s) // Ignoring error for simplicity.

}
Output:

Kim is 22 years old.

1

func Sprintf(format string, a ...any) string

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package main

import (
	"fmt"
	"io"
	"os"
)

func main() {
	const name, age = "Kim", 22
	s := fmt.Sprintf("%s is %d years old.\n", name, age)

	io.WriteString(os.Stdout, s) // Ignoring error for simplicity.

}
Output:

Kim is 22 years old.

1

func Sprintln(a ...any) string

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package main

import (
	"fmt"
	"io"
	"os"
)

func main() {
	const name, age = "Kim", 22
	s := fmt.Sprintln(name, "is", age, "years old.")

	io.WriteString(os.Stdout, s) // Ignoring error for simplicity.

}
Output:

Kim is 22 years old.

1

func Sscan(str string, a ...any) (n int, err error)

1

func Sscanf(str string, format string, a ...any) (n int, err error)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package main

import (
	"fmt"
)

func main() {
	var name string
	var age int
	n, err := fmt.Sscanf("Kim is 22 years old", "%s is %d years old", &name, &age)
	if err != nil {
		panic(err)
	}
	fmt.Printf("%d: %s, %d\n", n, name, age)

}
Output:

2: Kim, 22

1

func Sscanln(str string, a ...any) (n int, err error)

1
2
3

type Formatter interface {
	Format(f State, verb rune)
}

1
2
3

type GoStringer interface {
	GoString() string
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

package main

import (
	"fmt"
)

// Address has a City, State and a Country.
type Address struct {
	City    string
	State   string
	Country string
}

// Person has a Name, Age and Address.
type Person struct {
	Name string
	Age  uint
	Addr *Address
}

// GoString makes Person satisfy the GoStringer interface.
// The return value is valid Go code that can be used to reproduce the Person struct.
func (p Person) GoString() string {
	if p.Addr != nil {
		return fmt.Sprintf("Person{Name: %q, Age: %d, Addr: &Address{City: %q, State: %q, Country: %q}}", p.Name, int(p.Age), p.Addr.City, p.Addr.State, p.Addr.Country)
	}
	return fmt.Sprintf("Person{Name: %q, Age: %d}", p.Name, int(p.Age))
}

func main() {
	p1 := Person{
		Name: "Warren",
		Age:  31,
		Addr: &Address{
			City:    "Denver",
			State:   "CO",
			Country: "U.S.A.",
		},
	}
	// If GoString() wasn't implemented, the output of `fmt.Printf("%#v", p1)` would be similar to
	// Person{Name:"Warren", Age:0x1f, Addr:(*main.Address)(0x10448240)}
	fmt.Printf("%#v\n", p1)

	p2 := Person{
		Name: "Theia",
		Age:  4,
	}
	// If GoString() wasn't implemented, the output of `fmt.Printf("%#v", p2)` would be similar to
	// Person{Name:"Theia", Age:0x4, Addr:(*main.Address)(nil)}
	fmt.Printf("%#v\n", p2)

}
Output:

Person{Name: "Warren", Age: 31, Addr: &Address{City: "Denver", State: "CO", Country: "U.S.A."}}
Person{Name: "Theia", Age: 4}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

type ScanState interface {
	// ReadRune从输入中读取下一个符文(Unicode码点)。
	// 如果在Scanln、Fscanln或Sscanln期间调用，
    // ReadRune()将在返回第一个'\n'或读取超出指定宽度后返回EOF。
	ReadRune() (r rune, size int, err error)
	// UnreadRune导致下一次调用ReadRune返回相同的符文。
	UnreadRune() error
	// SkipSpace跳过输入中的空格。
    // 换行符将根据执行的操作适当处理；有关更多信息，请参见包文档。
	SkipSpace()
	// Token跳过输入中的空格(如果skipSpace为真)，
    // 然后返回满足f(c)的Unicode码点c的运行。
    // 如果f为nil，则使用！unicode.IsSpace(c)；
    // 也就是说，标记将包含非空格字符。
    // 换行符将根据执行的操作适当处理；有关更多信息，请参见包文档。
    // 返回的切片指向可以被下一次对Token的调用、
    // 使用ScanState作为输入的扫描函数的调用或调用调用扫描方法时
    // 可能被覆盖的共享数据。
	Token(skipSpace bool, f func(rune) bool) (token []byte, err error)
	// Width返回宽度选项的值以及它是否已设置。
    // 单位是Unicode码点。
	Width() (wid int, ok bool)
	// 因为ReadRune是由接口实现的，
    // 所以扫描程序永远不应调用Read，
    // 而ScanState的有效实现可能选择始终从Read中返回错误。
	Read(buf []byte) (n int, err error)
}

1
2
3

type Scanner interface {
	Scan(state ScanState, verb rune) error
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

type State interface {
	// Write是调用以将格式化输出发射到打印机的函数。
	Write(b []byte) (n int, err error)
	// Width返回宽度选项的值以及是否已设置。
	Width() (wid int, ok bool)
	// Precision返回精度选项的值以及是否已设置。
	Precision() (prec int, ok bool)

	// Flag报告标志c，一个字符，是否已设置。
	Flag(c int) bool
}

1
2
3

type Stringer interface {
	String() string
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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)
}
Output:

Gopher (2)