Chaînes de format de Go fmt.Printf

Syntaxe de base du langage Go

fmt.Printf est une puissante fonction de formatage de sortie du langage Go, principalement utilisée pour formater des chaînes et envoyer le résultat vers la sortie standard (généralement la console).

fmt.Printf formate les variables suivantes selon la chaîne de format spécifiée ; la syntaxe est la suivante :

fmt.Printf(格式化样式, 参数列表…)

Style de formatage :Forme de chaîne, les symboles de formatage commencent par%Commence par % ; %s est le format de chaîne, %d est le format d'entier décimal.
Liste des paramètres :Plusieurs paramètres sont séparés par des virgules, et leur nombre doit correspondre un à un au nombre dans la chaîne de format, sinon une erreur sera signalée à l'exécution.

Exemple

package main

import (
"fmt"
"strings"
)

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

// Afficher la chaîne en minuscules
fmt.Printf("hello, %s\n", strings.ToLower(name))

// Afficher la chaîne en majuscules
fmt.Printf("hello, %s\n", strings.ToUpper(name))

// Afficher l'âge en décimal
fmt.Printf("%s is %d years old\n", name, age)

// Âge affiché comme un nombre à virgule flottante avec deux décimales
fmt.Printf("%s is %.2f years old\n", name, age)
}

Résultat de sortie :

hello, John Doe
hello, JOHN DOE
John Doe is 27 years old
John Doe is %!f(int=27) years old

Symboles de formatage des chaînes en Go :

Spécificateur de format	Description	Exemple
Format général
`%v`	Afficher la variable au format par défaut	`fmt.Printf("%v", 42)`
`%+v`	Afficher la structure avec les noms des champs	`fmt.Printf("%+v", struct{A int}{A: 42})`
`%#v`	Formater la sortie en syntaxe Go	`fmt.Printf("%#v", map[string]int{"a": 1})`
`%T`	Type de la valeur de sortie	`fmt.Printf("%T", 42)`
`%%`	Afficher le signe de pourcentage	`fmt.Printf("%%")`
Valeur booléenne
`%t`	Sortie`true`ou`false`	`fmt.Printf("%t", true)`
Integer
`%b`	Représentation binaire	`fmt.Printf("%b", 5)`
`%c`	Caractère Unicode correspondant	`fmt.Printf("%c", 65)`
`%d`	Représentation décimale	`fmt.Printf("%d", 42)`
`%o`	Représentation octale	`fmt.Printf("%o", 10)`
`%x`	Représentation hexadécimale (lettres minuscules)	`fmt.Printf("%x", 15)`
`%X`	Représentation hexadécimale (lettres majuscules)	`fmt.Printf("%X", 15)`
`%U`	Sortie au format Unicode	`fmt.Printf("%U", 65)`
Nombre à virgule flottante
`%f`	Nombre à virgule flottante décimal	`fmt.Printf("%f", 3.14)`
`%e`	Notation scientifique (e minuscule)	`fmt.Printf("%e", 3.14)`
`%E`	Notation scientifique (E majuscule)	`fmt.Printf("%E", 3.14)`
`%g`	Sélection automatique`%f`ou`%e`Représentation concise	`fmt.Printf("%g", 3.14)`
Chaînes et octets
`%s`	Chaîne simple	`fmt.Printf("%s", "Go")`
`%q`	Chaîne ou caractère entre guillemets doubles	`fmt.Printf("%q", "Go")`
`%x`	Chaque octet représenté par deux caractères hexadécimaux	`fmt.Printf("%x", "abc")`
`%X`	Représentation hexadécimale (majuscules)	`fmt.Printf("%X", "abc")`
Pointeur
`%p`	Adresse de pointeur	`fmt.Printf("%p", &x)`

La chaîne de format se compose de texte normal et de spécificateurs de format.

Spécificateur de format avec% Commence par %, suivi d'un ou plusieurs caractères qui spécifient le type de format.

La structure d'un spécificateur de format est :

%[flags][width][.precision]verb

indicateursIndicateurs utilisés pour contrôler la sortie formatée (facultatif).
- -: Aligné à gauche.
- +: Affiche toujours le signe de la valeur.
- 0: complété par des zéros.
- #Ajoute un préfixe pour le binaire, l'octal, l'hexadécimal, etc.
- Space: Nombres positifs précédés d'un espace, nombres négatifs précédés de-。
width: Largeur de sortie (facultatif).
.precisionNombre de chiffres après la virgule pour les nombres à virgule flottante (facultatif).
verb: Utilisé pour spécifier la méthode de formatage des données.

1. Formatage des entiers

fmt.Printf("十进制: %d, 二进制: %b, 八进制: %o, 十六进制: %x\n", 42, 42, 42, 42)
// 输出：十进制: 42, 二进制: 101010, 八进制: 52, 十六进制: 2a

2. Formatage des nombres à virgule flottante

fmt.Printf("普通: %f, 科学计数法: %e, 自动: %g\n", 123.456, 123.456, 123.456)
// 输出：普通: 123.456000, 科学计数法: 1.234560e+02, 自动: 123.456

3. Formatage des chaînes de caractères

fmt.Printf("普通字符串: %s, 带引号: %q, 十六进制: %x\n", "Go", "Go", "Go")
// 输出：普通字符串: Go, 带引号: "Go", 十六进制: 476f

4. Utilisation de la largeur et de l'alignement

fmt.Printf("|%10s|%-10s|\n", "right", "left")
// 输出：|     right|left      |

5. Formatage des structures

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. Formatage des valeurs booléennes

fmt.Printf("布尔值: %t, %t\n", true, false)
// 输出：布尔值: true, false

Exemple

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")
}

Résultat de sortie :

{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

Syntaxe de base du langage Go

autres extensions

Chaînes de format de Go fmt.Printf

Exemple

Exemple

Leçons associées