golang fmt包的使用方法

Go语言的fmt包是用于格式化输入和输出的标准库。它提供了各种函数来格式化字符串、打印输出和读取输入。以下是fmt包的一些常见使用方法：

1. 格式化打印：
   • fmt.Print：打印输出不带格式的文本。
   • fmt.Println：打印输出带换行的文本。
   • fmt.Printf：根据格式化字符串打印输出文本。

import "fmt"

func main() {
    name := "Alice"
    age := 28
    fmt.Print("Name: ", name, " Age: ", age)    // 输出：Name: Alice Age: 28
    fmt.Println("Hello, World!")                // 输出：Hello, World!
    fmt.Printf("Name: %s Age: %d\n", name, age)  // 输出：Name: Alice Age: 28
}

2. 格式化字符串：
   • %v：默认格式输出变量的值。
   • %T：输出变量的类型。
   • %d、%f、%s、%t 等：分别用于输出整数、浮点数、字符串和布尔值。

import "fmt"

func main() {
    num := 42
    pi := 3.1416
    message := "Hello, Go!"
    isTrue := true

    fmt.Printf("Number: %v\n", num)       // 输出：Number: 42
    fmt.Printf("Pi: %f\n", pi)            // 输出：Pi: 3.141600
    fmt.Printf("Message: %s\n", message)  // 输出：Message: Hello, Go!
    fmt.Printf("isTrue: %t\n", isTrue)    // 输出：isTrue: true

    fmt.Printf("Number: %d\n", num)       // 输出：Number: 42
    fmt.Printf("Pi: %.2f\n", pi)          // 输出：Pi: 3.14
}

3. 输入读取：
   • fmt.Scan：读取输入并将值存储到提供的变量中。
   • fmt.Scanf：根据格式化字符串读取输入并将值存储到提供的变量中。

import "fmt"

func main() {
    var name string
    var age int

    fmt.Print("Enter your name: ")
    fmt.Scan(&name)
    fmt.Print("Enter your age: ")
    fmt.Scan(&age)

    fmt.Printf("Name: %s Age: %d\n", name, age)
}

当然！以下是一些更多的fmt包的例子，展示了一些常见的用法：

1. 格式化输出结构体：

import "fmt"

type Person struct {
    Name string
    Age  int
}

func main() {
    person := Person{
        Name: "Alice",
        Age:  28,
    }

    fmt.Printf("Person: %+v\n", person)  // 输出：Person: {Name:Alice Age:28}
    fmt.Printf("Name: %s\n", person.Name) // 输出：Name: Alice
    fmt.Printf("Age: %d\n", person.Age)   // 输出：Age: 28
}

2. 格式化输出切片：

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5}

    fmt.Printf("Numbers: %v\n", numbers) // 输出：Numbers: [1 2 3 4 5]
}

3. 格式化输出错误信息：

import "fmt"

func main() {
    err := fmt.Errorf("Something went wrong")
    fmt.Printf("Error: %v\n", err) // 输出：Error: Something went wrong
}

4. 格式化宽度和对齐：

import "fmt"

func main() {
    name := "Alice"
    age := 28

    fmt.Printf("Name: %-10s Age: %03d\n", name, age)
    // 输出：Name: Alice      Age: 028

    pi := 3.14159
    fmt.Printf("Pi: %.2f\n", pi)  // 输出：Pi: 3.14
}

5. 使用Sprintf将格式化的字符串保存到变量中：

import "fmt"

func main() {
    name := "Alice"
    age := 28

    info := fmt.Sprintf("Name: %s Age: %d", name, age)
    fmt.Println(info)  // 输出：Name: Alice Age: 28
}

当涉及更多的fmt包的使用方法时，以下是一些常见的场景和示例：

1. 格式化输出布尔值：

import "fmt"

func main() {
    isTrue := true
    isFalse := false

    fmt.Printf("Is True: %t\n", isTrue)   // 输出：Is True: true
    fmt.Printf("Is False: %t\n", isFalse) // 输出：Is False: false
}

2. 格式化输出指针值：

import "fmt"

func main() {
    value := 42

    fmt.Printf("Value: %p\n", &value) // 输出：Value: 0xc0000140b8
}

3. 使用%q格式化输出带引号的字符串：

import "fmt"

func main() {
    message := "Hello, Go!"

    fmt.Printf("Message: %q\n", message) // 输出：Message: "Hello, Go!"
}

4. 格式化输出Unicode字符：

import "fmt"

func main() {
    fmt.Printf("Unicode: %U\n", 'A') // 输出：Unicode: U+0041
}

5. 使用%b、%o、%x 格式化输出二进制、八进制和十六进制：

import "fmt"

func main() {
    number := 42

    fmt.Printf("Binary: %b\n", number)   // 输出：Binary: 101010
    fmt.Printf("Octal: %o\n", number)    // 输出：Octal: 52
    fmt.Printf("Hexadecimal: %x\n", number) // 输出：Hexadecimal: 2a
}

6. 自定义格式化输出：

import "fmt"

type Person struct {
    Name string
    Age  int
}

func (p Person) String() string {
    return fmt.Sprintf("Name: %s, Age: %d", p.Name, p.Age)
}

func main() {
    person := Person{
        Name: "Alice",
        Age:  28,
    }

    fmt.Println(person) // 输出：Name: Alice, Age: 28
}

7. 错误输出和处理：

import "fmt"

func main() {
    err := fmt.Errorf("Something went wrong")
    if err != nil {
        fmt.Println("Error:", err) // 输出：Error: Something went wrong
    }
}

这些示例展示了fmt包的更多用法，涵盖了格式化输出、格式化标志、自定义格式化和错误处理等方面。你可以根据自己的需求和具体的场景来使用这些方法。再次提醒，查阅官方文档（https://golang.org/pkg/fmt/）可以获取更详细的信息和更多示例。