Detailed explanation of Golang formatting placeholders

Golang formatted placeholder detailed explanation

In Golang programming, formatting strings is a common operation, which can be used to convert different types of data Formatted as string output. When formatting strings, placeholders play a vital role, through which the output format of the data can be specified. This article will introduce in detail some commonly used formatting placeholders in Golang and provide specific code examples for your reference.

1. Basic formatting placeholders

In Golang, the commonly used basic formatting placeholders are as follows:

• %v: Default format
• % v: Add field names when formatting the structure
• %#v: Add type information to the value
• %T: Type of output value
• %%: Percent sign

The following is a simple The sample code demonstrates the use of basic formatting placeholders:

package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{Name: "Alice", Age: 30}
    
    fmt.Printf("Person: %+v
", p)
    fmt.Printf("Type of p: %T
", p)
}

Run the above code, the output results are as follows:

Person: {Name:Alice Age:30}
Type of p: main.Person

2. Width and precision

In When formatting numbers, you can use width and precision to control the format of the output. The following are some commonly used placeholder forms:

• %f: Floating point formatting
• %t: Boolean formatting
• %b: Binary formatting
• %d: Decimal formatting
• %o: Octal format Formatting
• %x: Hexadecimal Formatting

The following example demonstrates how to format a floating point number using width and precision:

package main

import "fmt"

func main() {
    f := 3.14159
    
    fmt.Printf("Default format: %f
", f)
    fmt.Printf("Width and precision: %5.2f
", f)
}

Run the above code, the output result is as follows:

Default format: 3.141590
Width and precision:  3.14

3. String formatting

In addition to numbers and structures, Golang can also format strings. The following are some commonly used string formatting placeholders:

• %s: string
• %q: with double Quoted string
• %x: Hexadecimal string
• %c: Character (Unicode code point)
• %p: Pointer

The following example shows how to format a string:

package main

import "fmt"

func main() {
    str := "Hello, 世界"
    
    fmt.Printf("String: %s
", str)
    fmt.Printf("Quoted string: %q
", str)
    fmt.Printf("Hex encoding: %x
", str)
}

Run the above code, the output is as follows:

String: Hello, 世界
Quoted string: "Hello, 世界"
Hex encoding: 48656c6c6f2c20e4b896e7958c

Summary

This article introduces some commonly used formatting placeholders in Golang, including basic placeholders, width and precision control, and string formatting. By rationally using formatted placeholders, the output data can be made clearer. Readers can flexibly use these placeholders according to actual needs to improve efficiency in daily Golang programming work.

I hope the content of this article will be helpful to everyone, and I also hope that readers can have a deeper understanding and mastery of Golang’s formatting operations in practice.

The above is the detailed content of Detailed explanation of Golang formatting placeholders. For more information, please follow other related articles on the PHP Chinese website!