Verbes de formatage

Fait partie de la section Fondamentaux du Journey GO de Coddy — leçon 30 sur 109.

Apprenons-en davantage sur les verbes de formatage en Go. Les verbes de formatage sont des espaces réservés spéciaux que nous utilisons avec fmt.Printf() pour afficher différents types de données de manières spécifiques.

Tout d'abord, créons quelques variables avec différents types de données :

name := "Gopher"
age := 5
height := 1.5
isActive := true

Après avoir exécuté ce code, nous avons créé quatre variables : une chaîne de caractères, un entier, un flottant et un booléen.

Maintenant, utilisons le verbe de formatage par défaut %v. Il fonctionne avec n'importe quel type de données et affiche la valeur dans son format par défaut :

fmt.Printf("Default: %v\n", name)
fmt.Printf("Default: %v\n", age)
fmt.Printf("Default: %v\n", height)
fmt.Printf("Default: %v\n", isActive)

Après avoir exécuté ce code, vous verrez :
Default: Gopher
Default: 5
Default: 1.5
Default: true

Le verbe %v formate automatiquement chaque valeur selon son type — qu'il s'agisse d'une chaîne de caractères, d'un entier, d'un flottant ou d'un booléen.

Ensuite, utilisons le verbe de formatage %d spécifiquement pour les entiers :

fmt.Printf("Integer: %d\n", age)

Après l'exécution de ce code, Integer: 5 s'affichera à l'écran. Le %d est parfait pour afficher des nombres entiers.

Affichons notre valeur flottante en utilisant le verbe de formatage %f :

fmt.Printf("Float: %f\n", height)

Après l'exécution de ce code, Float: 1.500000 s'affichera à l'écran. Notez que %f affiche six décimales par défaut.

Nous pouvons contrôler le nombre de décimales en ajoutant un spécificateur de précision :

fmt.Printf("Float (2 decimals): %.2f\n", height)

Après l'exécution de ce code, Float (2 decimals): 1.50 s'affichera à l'écran. Le .2 avant f limite la sortie à 2 décimales.

Enfin, affichons notre valeur booléenne en utilisant le verbe de formatage %t :

fmt.Printf("Boolean: %t\n", isActive)

Après l'exécution de ce code, Boolean: true s'affichera à l'écran. Le %t est spécifiquement destiné à l'affichage des valeurs booléennes.

Rappel : utilisez %v pour n'importe quel type, %d pour les entiers, %f pour les flottants et %t pour les booléens.

Défi

Débutant

Dans ce défi, vous allez vous entraîner à utiliser des verbes de formatage avec fmt.Printf. Vous avez plusieurs variables de différents types déjà définies. Votre tâche consiste à les afficher en utilisant les verbes de formatage appropriés (%v, %d, %f, %s, %t, etc.).

Aide-mémoire

Les verbes de formatage sont des espaces réservés spéciaux utilisés avec fmt.Printf() pour afficher différents types de données :

Verbes de formatage courants :

%v - format par défaut pour n'importe quel type
%d - entiers
%f - nombres à virgule flottante (floats)
%t - booléens
%s - chaînes de caractères (strings)

Utilisation de base :

name := "Gopher"
age := 5
height := 1.5
isActive := true

fmt.Printf("Default: %v\n", name)     // Par défaut : Gopher
fmt.Printf("Default: %v\n", age)      // Par défaut : 5
fmt.Printf("Default: %v\n", height)   // Par défaut : 1.5
fmt.Printf("Default: %v\n", isActive) // Par défaut : true
fmt.Printf("Integer: %d\n", age)      // Entier : 5
fmt.Printf("Float: %f\n", height)     // Nombre à virgule : 1.500000
fmt.Printf("Boolean: %t\n", isActive) // Booléen : true

Contrôler le nombre de décimales :

fmt.Printf("Float (2 decimals): %.2f\n", height) // Nombre à virgule (2 décimales) : 1.50

Essayez vous-même

package main

import "fmt"

func main() {
	// Ces variables sont déjà définies pour vous
	age := 25
	height := 5.9
	isStudent := true
	name := "Alex"
	
	// TODO: Utilisez fmt.Printf pour imprimer la phrase suivante avec les verbes de format corrects :
	// "Name: Alex, Age: 25, Height: 5.900000, Student: true"
	
	// Écrivez votre code ci-dessous :
	
}