Le Go par l'exemple: Formattage de chaines

Go propose un excellent support du formattage façon printf. Voici quelques exemples de formattages courants.

 
package main

import "fmt"
import "os"

type point struct {
    x, y int
}

func main() {

Go propose plusieurs “verbes” d’affichage, conçus pour formatter des valeurs générales en Go. Par exemple, ceci affiche une instance de notre structure point.

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

Si la valeur est une struct, la variable %+v va inclure les noms des champs.

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

La variante %#v affiche une représentation en syntaxe Go de la valeur, c’est-à-dire le bout de code qui produirait cette valeur.

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

Pour afficher le type d’une valeur, on utilise %T.

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

Formatter des booléens est simple.

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

Il y a beaucoup d’options pour formatter des entiers. %d est le formattage standard, en base 10.

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

%b fournit une représentation binaire.

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

%c affiche le caractère correspondant à l’entier donné.

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

%x renvoie l’encodage héxadécimal.

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

Il y a également plusieurs options de formattage pour les float. Pour du formattage basique décimal, utilisez %f.

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

%e et %E formattent les float en (des versions légèrement modifiées de) notation scientifique.

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

Pour afficher des chaînes basiques utilisez %s.

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

Pour des chaines avec double-quote comme en code Go, utiliser %q.

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

Comme avec les entiers vus plus tôt %x affiche la chaîne en base 16, avec 2 caractères de sortie par octet d’entrée.

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

Pour afficher une représentation d’un pointeur, utiliser %p.

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

Lorsqu’on formatte des nombres, on veut souvent controller la largeur et la précision du chiffre en sortie. Pour spécifier la largeur d’un entier, on met un nombre après le % dans le verbe. Par défaut le résultat est justifié et complété avec des espaces.

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

On peut aussi préciser la largeur des floats, mais on peut cette fois-ci également préciser la largeur de la précision avec la syntaxe largeur.precision

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

Pour justifier à gauche, ajouter -.

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

Vous pouvez aussi vouloir contrôller la largeur lorsque vous formattez des chaînes, en particulier pour contrôller qu’elles s’alignent comme dans des tableaux. Voici un exemple justifié à droite :

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

Pour justifier à gauche, on utilise -, comme pour les nombres.

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

Pour le moment nous avons vu Printf, qui affiche la chaîne dans os.Stdout. Sprintf formatte et renvoie la chaîne sans l’afficher.

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

On peut formatter et afficher dans des io.Writers autres que os.Stdout avec Fprintf.

 
    fmt.Fprintf(os.Stderr, "an %s\n", "error")
}

$ go run string-formatting.go
{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
0x42135100
|    12|   345|
|  1.20|  3.45|
|1.20  |3.45  |
|   foo|     b|
|foo   |b     |
a string
an error

Exemple suivant: Expressions régulières.

par @clemkeirua de KeiruaProd | retours | source | license