Comment formater des chaînes dans Go
Découvrez comment utiliser les verbes de formatage de chaîne et quelles fonctions Go les prennent en charge.
Lorsque vous écrivez du code Go, vous trouverez le formatage des chaînes très utile dans de nombreuses situations. Vous analysez peut-être des entrées ou créez une sortie plus complexe qu’une simple concaténation. Vous travaillez peut-être avec des types autres que des chaînes simples.
Le formatage des chaînes dans Go utilise le processus et la syntaxe familiers de la fonction printf, que les langages de Java à Haskell utilisent également.
Go fournit diverses méthodes pour formater les chaînes dans le package fmt. Vous pouvez utiliser des fonctions et des verbes pour le formatage des chaînes en fonction de l'opération ou des entrées que vous souhaitez formater.
Formatage de chaîne dans Go
Les fonctions du package fmt sont similaires à leurs homologues, comme la fonction printf en bash ou C. Go dérive ses verbes de formatage du C.
Vous utilisez des verbes de formatage de chaîne comme espaces réservés pour vos valeurs de variable dans une chaîne conteneur. Vous pouvez ensuite transmettre cette chaîne de formatage à une fonction telle que Printf, ainsi que les valeurs correspondant à ces espaces réservés.
Vous ne pouvez pas utiliser de verbes de formatage de chaîne avec les méthodes Print et Println. Vous pouvez les utiliser avec des méthodes telles que Printf et Sprintf.
fmt.Println("This is a test %v", 90)
fmt.Printf("This is a test %v", 90)
Le verbe %v imprime n'importe quelle valeur dans son format par défaut. La méthode Println ne reconnaît pas les verbes et imprime les arguments qu'elle reçoit. Les fonctions Printf et Sprintf formatent toutes deux le premier argument de chaîne que vous leur transmettez.
Fonctions de formatage de chaîne dans le package fmt
Le formatage des chaînes dans le langage de programmation Go nécessite l'utilisation d'une fonction de formatage de chaîne et d'un verbe. La fonction renvoie la chaîne formatée et les verbes sont les espaces réservés pour les entrées de la chaîne.
La méthode Printf formate l'entrée selon le spécificateur de format et renvoie le nombre d'octets écrits ou d'erreurs.
fmt.Printf("This is a test %v", 90)
Classiquement, vous n'aurez pas à vous soucier des erreurs lorsque vous utiliserez la méthode Printf.
La méthode Sprintf formate selon le format spécifié et renvoie le résultat sous forme de chaîne.
var result = fmt.Sprintf("This is a test %v", 90)
La méthode Fprintf formate la chaîne et l'écrit dans un rédacteur (méthodes qui implémentent l'interface io.Writer)
// write data to standard output
result, err = fmt.Fprintf(writer, "This is a test %v", 90)La méthode Fscanf numérise à partir d'un lecteur et formate selon le format spécifié.
var take string
// read data from the given string
readString := strings.NewReader("This is a test")
read, err := fmt.Fscanf(reader, "%v", &take)
Dans ce cas, Fscanf décode la chaîne du lecteur dans la variable take, et la variable read contient le résultat du format.
Les verbes de formatage de chaîne
Go fournit de nombreux verbes de formatage que vous pouvez utiliser avec les fonctions de formatage de chaîne.
Il existe des verbes généraux de formatage de chaîne comme le verbe %v dans les exemples de fonctions de formatage de chaîne. Vous pouvez utiliser les verbes généraux de formatage de chaîne pour formater n’importe quel type de données.
Vous pouvez utiliser le verbe %#v pour afficher n'importe quelle valeur, le %+v pour les structures, le verbe %T pour le type de n'importe quel value et le verbe %% pour aucune valeur.
type any struct {
name string
age int
isLoggedIn bool
}
var instance = any {
name: "John Doe",
age: 34,
isLoggedIn: true,
}
var result = fmt.Sprintf("This is a struct formatting example %+v", instance)
fmt.Println(result)
La variable result contient la chaîne formatée de la structure instanciée. Si vous l'imprimez, cela devrait ressembler à ceci :
This is a struct formatting example {name:John Doe age:34 isLoggedIn:true}Il existe des verbes pour formater des types de données natifs Go spécifiques, y compris les canaux et les pointeurs.
%t
booléens.
%d
int, int8, etc.
-
%d, %#x if printed with %#v
uint, uint8, etc.
%g
float32, complexe64, etc.
%s
chaîne.
%p
chan.
%P
pointeur.
Vous devez vous assurer de ne pas faire d'erreurs avec les verbes car ils sont sensibles à la casse, comme les verbes chan et pointeur.
Formatage des entiers et des flottants
Il existe des verbes de formatage de chaînes pour formater des entiers dans différentes bases. Vous pouvez utiliser n'importe lequel de ces verbes pour formater des entiers
%b
base 2
%c
le caractère représenté par le point de code Unicode correspondant.
%d
base 10.
%o
base 8.
%O
base 8 avec préfixe 0o.
%q
un caractère littéral entre guillemets simples échappé en toute sécurité avec la syntaxe Go.
%x
base 16, avec des lettres minuscules pour a-f.
%X
base 16, avec des lettres majuscules pour A-F.
%U
Format Unicode : U+1234 ; identique à "U+%04X".
Par exemple, vous pouvez formater un entier en utilisant le verbe %d :
var result = fmt.Sprintf("This is an integer formatting example %d", 90)
fmt.Println(result)Ce sont les verbes permettant de formater les nombres à virgule flottante.
%b
Notation scientifique sans décimale avec un exposant puissance deux, à la manière de strconv. FormatFloat avec le format 'b', par ex. -123456p-78
%e
notation scientifique, par ex. -1.234456e+78
%E
point décimal mais pas d'exposant, par exemple 123,456
%f
point décimal mais pas d'exposant, par exemple 123,456
%F
synonyme de %f.
%g
%e pour les grands exposants, %f sinon. Précision ci-dessous.
%G
%E pour les grands exposants, %F sinon
%x
notation hexadécimale (avec puissance décimale de deux exposants), par exemple -0x1.23abcp+20.
%X
notation hexadécimale majuscule, par ex. -0X1.23ABCP+20.
Voici un exemple de formatage d'un point décimal sans exposant avec le verbe %f.
var result = fmt.Sprintf("This is a floating point example %f", 432.9503)
fmt.Println(result)
Vous pouvez toujours utiliser les verbes généraux si vous n’êtes pas sûr du type.
Formatage des chaînes et des octets
Les types de chaînes et de tranches d’octets sont assez similaires dans Go. Ce sont les indicateurs pour formater les chaînes et les octets.
%s
les octets non interprétés de la chaîne ou de la tranche
%q
une chaîne entre guillemets échappée en toute sécurité avec la syntaxe Go
%x
base 16, minuscules, deux caractères par octet
%X
base 16, majuscules, deux caractères par octet
Voici un exemple de formatage d'une chaîne avec le verbe %s.
var score = "example"
var result = fmt.Sprintf("This is a string formatting example %s", score)
fmt.Println(result)Le package fmt est essentiel pour la programmation Go
Le package fmt contient la plupart des fonctionnalités dont vous aurez besoin pour le formatage des chaînes. Go fournit également un package strings pour la manipulation des chaînes et un package log qui peut formater les chaînes pour la journalisation.
Le package fmt possède des fonctions qui implémentent les interfaces io.Writer et io.Reader. Vous le trouverez utile dans de nombreux cas d’utilisation, tels que la création d’applications Web et en ligne de commande.