Go fmt.Sprintf chaîne de format

Syntaxe de base du langage Go

Go peut utiliser fmt.Sprintf pour formater des chaînes, comme suit :

fmt.Sprintf(格式化样式, 参数列表…)
  • Style de formatage :Sous forme de chaîne, les symboles de formatage sont indiqués par%Au début, %s est le format de chaîne, et %d est le format d'entier décimal.
  • Liste des paramètres :Plusieurs paramètres sont séparés par des virgules, et le nombre de paramètres doit correspondre un à un au nombre de spécificateurs de format dans la chaîne de format ; sinon, une erreur d'exécution sera signalée.

Exemple

package main


import (
    "fmt"
    "io"
    "os"
)


func main() {
    // En Go, formater une chaîne et l'affecter à une nouvelle chaîne à l'aide de fmt.Sprintf
    // %s représente une chaîne
    var stockcode="000987"
    var enddate="2020-12-31"
    var url="Code=%s&endDate=%s"
    var target_url=fmt.Sprintf(url,stockcode,enddate)
    fmt.Println(target_url)

    // Un autre exemple, %d représente un entier
    const name, age = "Kim", 22
    s := fmt.Sprintf("%s a %d ans.\n", name, age)
    io.WriteString(os.Stdout, s) // Pour simplifier, ignorer certaines erreurs
}

Le résultat de sortie est:

Code=000987&endDate=2020-12-31
Kim is 22 years old.

Exemple

package main
import (
    "fmt"
    "io"
    "os"
)
func main() {
 
    // Déclarer des variables numériques
    const num1, num2, num3 = 5, 10, 15
 
    // Appeler la fonction Sprintf()
    s := fmt.Sprintf("%d + %d = %d", num1, num2, num3)
 
    // Utiliser la fonction WriteString() pour afficher le résultat sur le terminal afin d'écrire le
    // "os.Stdout" est le contenu de la chaîne
    io.WriteString(os.Stdout, s)
 
}

Le résultat de sortie est:

5 + 10 = 15

Symboles de formatage des chaînes en Go :

Format Description
%v Affiche la valeur telle quelle
%+v En s'appuyant sur %v, développe les noms et valeurs des champs de la structure.
%#v Affiche la valeur au format syntaxique du langage Go
%T Affiche le type et la valeur au format syntaxique Go.
%% Affiche % lui-même
%b Affiche les entiers en binaire
%o Affiche les entiers en octal
%d Affiche les entiers en décimal
%x Affiche les entiers en hexadécimal
%X Affiche les entiers en hexadécimal avec des lettres majuscules.
%U Caractère Unicode
%f Nombre à virgule flottante
%p Pointeur, affiché en hexadécimal

Exemple

package main

import "fmt"

func main() {
    name := "John"
    age := 30
    height := 175.5

    result := fmt.Sprintf("Name: %s, Age: %d, Height: %.2f", name, age, height)
    fmt.Println(result)
}

Dans l'exemple ci-dessus, %s, %d et %.2f dans la chaîne de format "Name: %s, Age: %d, Height: %.2f" sont respectivement remplacés par les valeurs des variables name, age et height, où%.2fReprésente un format à virgule flottante avec deux décimales.

Le résultat de sortie est:

Name: John, Age: 30, Height: 175.50

%.2fEst une option de formatage à virgule flottante utilisée pour contrôler la précision décimale des nombres à virgule flottante, où2Indique le nombre de décimales à conserver, et vous pouvez le modifier selon vos besoins.

Autres exemples d'utilisation :

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

Le résultat de sortie est:

{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

Alignement

En utilisant les paramètres de largeur et d'alignement dans la chaîne de format, vous pouvez contrôler l'alignement de la chaîne générée.

Les paramètres d'alignement couramment utilisés incluent :

  • %s: Pour le format de chaîne, les paramètres d'alignement suivants peuvent être utilisés :
    • %s: Alignement par défaut, aligné à gauche.
    • %10s: Spécifie l'alignement à droite avec une largeur de 10.
    • %-10s: Spécifie l'alignement à gauche avec une largeur de 10.
  • %d: Pour le format entier, les paramètres d'alignement suivants peuvent être utilisés :
    • %d: Alignement par défaut, aligné à droite.
    • %10d: Spécifie l'alignement à droite avec une largeur de 10.
    • %-10d: Spécifie l'alignement à gauche avec une largeur de 10.
  • %f: Pour le format à virgule flottante, les paramètres d'alignement suivants peuvent être utilisés :
    • %f: Alignement par défaut, aligné à droite.
    • %10f: Spécifie l'alignement à droite avec une largeur de 10.
    • %-10f: Spécifie l'alignement à gauche avec une largeur de 10.

Exemple

package main

import "fmt"

func main() {
    str := "Hello"
    num := 42
    floatNum := 3.14159

    fmt.Printf("|%s|\n", str)
    fmt.Printf("|%10s|\n", str)
    fmt.Printf("|%-10s|\n", str)

    fmt.Printf("|%d|\n", num)
    fmt.Printf("|%10d|\n", num)
    fmt.Printf("|%-10d|\n", num)

    fmt.Printf("|%f|\n", floatNum)
    fmt.Printf("|%10f|\n", floatNum)
    fmt.Printf("|%-10f|\n", floatNum)
}

Le résultat de sortie est:

|Hello|
|     Hello|
|Hello     |
|42|
|        42|
|42        |
|3.141590|
|  3.141590|
|3.141590  |

Syntaxe de base du langage Go

autres extensions