格式化打印和键盘输入

格式化打印

fmt 包使用类似于 C 语言的 printf 和 scanf 的函数来实现格式化 I/O。'verbs' 格式源自 C 语言，但更简单。

详见官网fmt包的API：https://pkg.go.dev/fmt

导入 fmt 包。

import "fmt"

常用函数

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

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

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

通用占位符

占位符	说明
%v	使用默认格式打印值。当打印结构体时，使用加号标志（%+v）可以在打印结果中包含字段名。
%#v	以 Go 语法的表示形式打印值。
%T	以 Go 语法的表示形式打印值的类型。
%%	表示一个字面上的百分号，不会消耗任何值。

通用占位符示例：

%v

package main

import "fmt"

func main() {
	// %v：使用默认格式打印值。
	num := 10
	str := "Hello, Go"
	fmt.Printf("%v\n", num) // 输出: 10
	fmt.Printf("%v\n", str) // 输出: Hello, Go
}

%+v

package main

import "fmt"

type Person struct {
	Name string
	Age  int
}

func main() {
	// %+v: 当打印结构体时，使用加号标志可以在打印结果中包含字段名。
	p := Person{
		Name: "John",
		Age:  30,
	}
	fmt.Printf("%+v\n", p) // 输出: {Name:John Age:30}
}

%#v

package main

import "fmt"

type Person struct {
	Name string
	Age  int
}

func main() {
	// %#v：以 Go 语法的表示形式打印值。
	p1 := Person{
		Name: "Tom",
		Age:  20,
	}
	fmt.Printf("%#v\n", p1) // 输出结果: main.Person{Name:"Tom", Age:20}
}

%T

package main

import "fmt"

func main() {
	// %T：以 Go 语法的表示形式打印值的类型。
	n1 := 100
	s1 := "Hello Golang"
	fmt.Printf("%T\n", n1) // 输出结果: int
	fmt.Printf("%T\n", s1) // 输出结果: string
}

%%

package main

import "fmt"

func main() {
	// %%：表示一个字面上的百分号，不会消耗任何值。
	fmt.Printf("The percentage is: %%\n") // 输出: The percentage is: %
}

布尔类型占位符

占位符	说明
%t	是一个用于布尔值的格式化打印占位符。它会将布尔值格式化为字符串形式，即打印出单词 "true" 或 "false"。

布尔类型占位符示例：

package main

import "fmt"

func main() {
	// %t：占位符用于格式化布尔值。它会将布尔值格式化为字符串形式，即打印出单词"true"或"false"。
	flag1 := true
	flag2 := false
	fmt.Printf("%t\n", flag1) // 输出结果: true
	fmt.Printf("%t\n", flag2) // 输出结果: false
}

整数类型占位符

占位符	说明
%b	以二进制（base 2）形式打印整数值。
%c	打印对应的 Unicode 代码点所表示的字符。
%d	以十进制（base 10）形式打印整数值。
%o	以八进制（base 8）形式打印整数值。
%O	以带有 0o 前缀的八进制（base 8）形式打印整数值。
%q	以带有单引号的字符字面值形式打印字符，使用 Go 语法进行安全转义。
%x	以十六进制（base 16）形式打印整数值，其中字母 a-f 为小写。
%X	以十六进制（base 16）形式打印整数值，其中字母 A-F 为大写。
%U	以 Unicode 格式打印整数值，格式为 U+1234，与 "U+%04X" 相同。

整数类型占位符示例：

%b

package main

import "fmt"

func main() {
	// %b：以二进制（base 2）形式打印整数值。
	num := 2
	fmt.Printf("%b\n", num)
}

%c

package main

import "fmt"

func main() {
	// %c：打印对应的 Unicode 代码点所表示的字符。
	ch1 := 'A'
	fmt.Printf("%c\n", ch1) // 输出结果：A
}

%d

package main

import "fmt"

func main() {
	// %d：以十进制（base 10）形式打印整数值。
	num := 123
	fmt.Printf("%d\n", num) // 输出结果：123
}

%o

package main

import "fmt"

func main() {
	// %o：以八进制（base 8）形式打印整数值。
	num := 18
	fmt.Printf("%o\n", num) // 输出结果：22
}

%O

package main

import "fmt"

func main() {
	// %O：以带有 0o 前缀的八进制（base 8）形式打印整数值。
	num := 22
	fmt.Printf("%O\n", num) // 输出结果：0o26
}

%q

package main

import "fmt"

func main() {
	// %q：以带有单引号的字符字面值形式打印字符，使用 Go 语法进行安全转义。
	ch := 'C'
	fmt.Printf("%q\n", ch) // 输出结果：'C'
}

%x

package main

import "fmt"

func main() {
	// %x：以十六进制（base 16）形式打印整数值，其中字母 a-f 为小写。
	num := 42
	fmt.Printf("%x\n", num) // 输出结果：2a
}

%X

package main

import "fmt"

func main() {
	// %X：以十六进制（base 16）形式打印整数值，其中字母 A-F 为大写。
	num := 42
	fmt.Printf("%X\n", num) // 输出结果：2A
}

%U

package main

import "fmt"

func main() {
	// %U：以 Unicode 格式打印整数值，格式为 U+1234，与 "U+%04X" 相同。
	ch := 'D'
	fmt.Printf("%U\n", ch) // 输出结果：U+0044
}

浮点(复数)类型占位符

占位符	说明
%b	按照 strconv.FormatFloat 中 'b' 格式的方式，以指数为 2 的幂的科学计数法打印浮点数，例如 -123456p-78。
%e	科学计数法表示，例如 -1.234456e+78。
%E	科学计数法表示，使用大写字母 E，例如 -1.234456E+78。
%f	十进制小数表示，例如 123.456。
%F	%f 的同义词。
%g	对于较大的指数使用 %e，否则使用 %f。精度在下面进行讨论。
%G	对于较大的指数使用 %E，否则使用 %F。
%x	以十六进制表示，带有十进制的指数部分，例如 -0x1.23abcp+20。
%X	大写字母的十六进制表示，例如 -0X1.23ABCP+20。

浮点类型和复数类型的占位符示例：

%b

package main

import "fmt"

func main() {
	// %b：按照 strconv.FormatFloat 中 'b' 格式的方式，以指数为 2 的幂的科学计数法打印浮点数，例如 -123456p-78。
	f := -123456.789
	fmt.Printf("%b\n", f) // 输出: -8483885939586761p-36
}

%e

package main

import "fmt"

func main() {
	// %e: 科学计数法表示，例如 -1.234456e+78。
	f := -1.234456789
	fmt.Printf("%e\n", f) // 输出: -1.234457e+00
}

%E

package main

import "fmt"

func main() {
	// %E: 科学计数法表示，使用大写字母 E，例如 -1.234456E+78。
	f := -1.234456789
	fmt.Printf("%E\n", f) // 输出: -1.234457E+00
}

%f

package main

import "fmt"

func main() {
	// %f: 十进制小数表示，例如 123.456。
	f := 123.456
	fmt.Printf("%f\n", f) // 输出: 123.456000
}

%F

package main

import "fmt"

func main() {
	// %F: %f 的同义词。
	f := 123.456
	fmt.Printf("%F\n", f) // 输出: 123.456000
}

%g

package main

import "fmt"

func main() {
	// %g: 对于较大的指数使用 %e，否则使用 %f。精度在下面进行讨论。
	f := 123.456789
	fmt.Printf("%g\n", f) // 输出: 123.456789
}

%G

package main

import "fmt"

func main() {
	// %G: 对于较大的指数使用 %E，否则使用 %F。
	f := 123.456789
	fmt.Printf("%G\n", f) // 输出: 123.456789
}

%x

package main

import "fmt"

func main() {
	// %x: 以十六进制表示，带有十进制的指数部分，例如 -0x1.23abcp+20。
	f := -123.456789
	fmt.Printf("%x\n", f) // 输出: -0x1.edd3c07ee0b0bp+06
}

%X

package main

import "fmt"

func main() {
	// %X: 大写字母的十六进制表示，例如 -0X1.23ABCP+20。
	f := -123.456789
	fmt.Printf("%X\n", f) // 输出: -0X1.EDD3C07EE0B0BP+06
}

字符串(字节切片)占位符

占位符	说明
%s	以字节切片或字符串的形式打印未解释的字节。
%q	以带有双引号的字符串形式打印字符串，并使用 Go 语法进行安全转义。
%x	以十六进制（base 16）形式打印字节切片或字符串，其中每个字节用两个小写字母表示。
%X	以十六进制（base 16）形式打印字节切片或字符串，其中每个字节用两个大写字母表示。

字符串和字节切片的占位符示例：

%s

package main

import "fmt"

func main() {
	// %s: 以字节切片或字符串的形式打印未解释的字节。
	name := "MagicGopher"
	fmt.Printf("%s\n", name) // 输出结果: MagicGopher
}

%q

package main

import "fmt"

func main() {
	// %q: 以带有双引号的字符串形式打印字符串，并使用 Go 语法进行安全转义。
	name := "MagicGopher"
	fmt.Printf("%q\n", name) // 输出结果: "MagicGopher"
}

%x

package main

import "fmt"

func main() {
	// %x: 以十六进制（base 16）形式打印字节切片或字符串，其中每个字节用两个小写字母表示。
	data := []byte{0x48, 0x65, 0x6c, 0x6c, 0x6f}
	fmt.Printf("%x\n", data) // 输出结果: 48656c6c6f
}

%X

package main

import "fmt"

func main() {
	// %X: 以十六进制（base 16）形式打印字节切片或字符串，其中每个字节用两个大写字母表示。
	data := []byte{0x48, 0x65, 0x6c, 0x6c, 0x6f}
	fmt.Printf("%X\n", data) // 输出结果: 48656C6C6F
}

切片类型占位符

占位符	说明
%p	以 16 为基数表示法的第 0 个元素的地址，前导 0x

切片类型示例：

package main

import "fmt"

func main() {
	// %p: 以 16 为基数表示法的第 0 个元素的地址，前导 0x
	numbers := []int{1, 2, 3, 4, 5}

	fmt.Printf("Slice address: %p\n", numbers) // Slice address: 0x140000162d0【这里是切片的内存地址，是会发生变化的】
}

指针类型占位符

占位符	说明
%p	以 16 为基数表示法的第 0 个元素的地址，前导 0x %b、%d、%o、%x 和 %X 动词也可以与指针一起使用，将该值完全格式化为整数。

指针类型示例：

package main

import "fmt"

func main() {
	// %p: 以 16 为基数表示法的第 0 个元素的地址，前导 0x
	value := 42
	pointer := &value

	fmt.Printf("Value: %p\n", pointer) // Value: 0x14000110018【这里是value变量的内存地址，是会发生变化的】
}

键盘输入

fmt包读取键盘输入

常用函数

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

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

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

Scan函数

package main

import (
	"fmt"
	"os"
)

func main() {
	// 定义两个变量
	var name string
	var age int

    // _（下划线）通常用作匿名变量，它的作用是忽略对应的值。
	fmt.Print("请输入姓名: ")
	_, err := fmt.Scan(&name)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(1)
	}

	fmt.Print("请输入年龄: ")
	_, err = fmt.Scan(&age)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(1)
	}
	// 打印输出
	fmt.Println("Name:", name)
	fmt.Println("Age:", age)
}

Scanf函数

package main

import "fmt"

func main() {
	// 定义两个变量
	var name string
	var age int

	// 输入姓名和年龄
	// _（下划线）通常用作匿名变量，它的作用是忽略对应的值。
	fmt.Printf("输入姓名和年龄: ")
	_, err := fmt.Scanf("%s %d", &name, &age)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
    // 打印输出
	fmt.Println("Name:", name)
	fmt.Println("Age:", age)
}

Scanln函数

package main

import "fmt"

func main() {
	// 定义两个变量
	var name string
	var age int

	// 输入姓名和年龄
	// _（下划线）通常用作匿名变量，它的作用是忽略对应的值。
	fmt.Print("输入姓名和年龄: ")
	_, err := fmt.Scanln(&name, &age)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	// 打印输出
	fmt.Println("Name:", name)
	fmt.Println("Age:", age)
}

bufio包读取

bufio 包实现缓冲 I/O。 它包装一个 io.Reader 或 io.Writer 对象，创建另一个对象（Reader 或 Writer），该对象也实现该接口，但为文本 I/O 提供缓冲和一些帮助。

详见官网bufio包的API：https://pkg.go.dev/bufio

先创建Reader实例。

然后就能使用读取相关方法了。

示例：

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	// 使用bufio包获取键盘输入内容
	reader := bufio.NewReader(os.Stdin)

	// 读取输入
	fmt.Print("请输入姓名: ")
	name, err := reader.ReadString('\n')
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	// 打印输出
	fmt.Println("Name:", name)
}