01GO基础-004Go 语言基础语法3

fmt.Printf 是 Go 语言中一个功能强大的输出格式化函数，主要用于格式化字符串并将结果输出到标准输出（通常是控制台）。
fmt.Printf 按照指定的格式化字符串对后续变量进行格式化，语法如下：
`fmt.Printf(格式化样式, 参数列表…)`
**格式化样式**：字符串形式，格式化符号以 % 开头， %s 字符串格式，%d 十进制的整数格式。
**参数列表**：多个参数以逗号分隔，个数必须与格式化样式中的个数一一对应，否则运行时会报错。

实例
```go
package main

import (
   "fmt"
   "strings"
)

func main() {
  name := "John Doe"
  age := 27

// 以小写形式打印字符串
  fmt.Printf("hello, %s\n", strings.ToLower(name))

// 以大写形式打印字符串
  fmt.Printf("hello, %s\n", strings.ToUpper(name))

// 以十进制数打印年龄
  fmt.Printf("%s is %d years old\n", name, age)

// 年龄打印为带两位小数的浮点数
  fmt.Printf("%s is %.2f years old\n", name, age)
}
```
输出结果为：
hello, John Doe
hello, JOHN DOE
John Doe is 27 years old
John Doe is %!f(int=27) years old

## Go 字符串格式化符号:
格式化符号	描述	示例
通用格式		
%v	以默认格式输出变量	fmt.Printf("%v", 42)
%+v	对结构体加字段名的方式输出	fmt.Printf("%+v", struct{A int}{A: 42})
%#v	以 Go 语法格式化输出	fmt.Printf("%#v", map[string]int{"a": 1})
%T	输出值的类型	fmt.Printf("%T", 42)
%%	输出百分号	fmt.Printf("%%")
布尔值		
%t	输出 true 或 false	fmt.Printf("%t", true)
整数		
%b	二进制表示	fmt.Printf("%b", 5)
%c	Unicode 对应字符	fmt.Printf("%c", 65)
%d	十进制表示	fmt.Printf("%d", 42)
%o	八进制表示	fmt.Printf("%o", 10)
%x	十六进制表示（小写字母）	fmt.Printf("%x", 15)
%X	十六进制表示（大写字母）	fmt.Printf("%X", 15)
%U	Unicode 格式输出	fmt.Printf("%U", 65)
浮点数		
%f	十进制浮点数	fmt.Printf("%f", 3.14)
%e	科学计数法（小写 e）	fmt.Printf("%e", 3.14)
%E	科学计数法（大写 E）	fmt.Printf("%E", 3.14)
%g	自动选择 %f 或 %e 的简洁表示	fmt.Printf("%g", 3.14)
字符串与字节		
%s	普通字符串	fmt.Printf("%s", "Go")
%q	带双引号的字符串或字符	fmt.Printf("%q", "Go")
%x	每个字节用两字符十六进制表示	fmt.Printf("%x", "abc")
%X	十六进制（大写）表示	fmt.Printf("%X", "abc")
指针		
%p	指针地址	fmt.Printf("%p", &x)
格式化字符串由常规文本和格式化占位符组成。

格式化占位符以 % 开头，后接一个或多个字符，指明格式化类型。

格式化占位符的结构为：
`%[flags][width][.precision]verb`
flags：用于控制格式化输出的标志（可选）。
-：左对齐。
+：始终显示数值的符号。
0：用零填充。
 #：为二进制、八进制、十六进制等加上前缀。
空格：正数前加空格，负数前加 -。
width：输出宽度（可选）。
.precision：浮点数小数点后的位数（可选）。
verb：用于指定数据的格式化方式。
### 1. 格式化整数
fmt.Printf("十进制: %d, 二进制: %b, 八进制: %o, 十六进制: %x\n", 42, 42, 42, 42)
// 输出：十进制: 42, 二进制: 101010, 八进制: 52, 十六进制: 2a
### 2. 格式化浮点数
fmt.Printf("普通: %f, 科学计数法: %e, 自动: %g\n", 123.456, 123.456, 123.456)
// 输出：普通: 123.456000, 科学计数法: 1.234560e+02, 自动: 123.456
### 3. 格式化字符串
fmt.Printf("普通字符串: %s, 带引号: %q, 十六进制: %x\n", "Go", "Go", "Go")
// 输出：普通字符串: Go, 带引号: "Go", 十六进制: 476f
### 4. 使用宽度和对齐
fmt.Printf("|%10s|%-10s|\n", "right", "left")
// 输出：|     right|left      |
### 5. 格式化结构体
type User struct {
    Name string
    Age  int
}
user := User{Name: "Alice", Age: 30}
fmt.Printf("默认: %v\n带字段名: %+v\nGo语法: %#v\n", user, user, user)
// 输出：
// 默认: {Alice 30}
// 带字段名: {Name:Alice Age:30}
// Go语法: main.User{Name:"Alice", Age:30}
### 6. 格式化布尔值
fmt.Printf("布尔值: %t, %t\n", true, false)
// 输出：布尔值: true, false

实例
```go
package main

import (
    "fmt"
    "os"
)

type point struct {
    x, y int
}

func main() {

p := point{1, 2}
    fmt.Printf("%v\n", p)

fmt.Printf("%+v\n", p)

fmt.Printf("%#v\n", p)

fmt.Printf("%T\n", p)

fmt.Printf("%t\n", true)

fmt.Printf("%d\n", 123)

fmt.Printf("%b\n", 14)

fmt.Printf("%c\n", 33)

fmt.Printf("%x\n", 456)

fmt.Printf("%f\n", 78.9)

fmt.Printf("%e\n", 123400000.0)
    fmt.Printf("%E\n", 123400000.0)

fmt.Printf("%s\n", "\"string\"")

fmt.Printf("%q\n", "\"string\"")

fmt.Printf("%x\n", "hex this")

fmt.Printf("%p\n", &p)

fmt.Printf("|%6d|%6d|\n", 12, 345)

fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45)

fmt.Printf("|%-6.2f|%-6.2f|\n", 1.2, 3.45)

fmt.Printf("|%6s|%6s|\n", "foo", "b")

fmt.Printf("|%-6s|%-6s|\n", "foo", "b")

s := fmt.Sprintf("a %s", "string")
    fmt.Println(s)

fmt.Fprintf(os.Stderr, "an %s\n", "error")
}
```
输出结果为：
{1 2}
{x:1 y:2}
main.point{x:1, y:2}
main.point
true
123
1110
!
1c8
78.900000
1.234000e+08
1.234000E+08
"string"
"\"string\""
6865782074686973
0xc0000b4010
|    12|   345|
|  1.20|  3.45|
|1.20  |3.45  |
|   foo|     b|
|foo   |b     |
a string
an error