Paquets standards courants : `fmt`, `strings`, `encoding/json` (bases)

La richesse intégrée : Explorer la bibliothèque standard Go

L'un des grands points forts de Go est sa bibliothèque standard (`stdlib`) complète et bien conçue. Elle fournit une vaste gamme de fonctionnalités prêtes à l'emploi, couvrant des domaines allant de l'entrée/sortie de base à la manipulation de chaînes, l'encodage de données, le réseau, la cryptographie, et bien plus encore. Souvent, vous pouvez accomplir une grande partie de vos tâches sans avoir besoin de recourir à des bibliothèques externes, ce qui simplifie la gestion des dépendances et assure une certaine cohérence.

Dans ce sous-chapitre, nous allons survoler les bases de trois paquets parmi les plus fondamentaux et les plus fréquemment utilisés de la bibliothèque standard : `fmt` pour l'interaction avec l'utilisateur et le formatage, `strings` pour travailler avec du texte, et `encoding/json` pour manipuler le format de données JSON, omniprésent sur le web.

Connaître ces paquets de base est essentiel pour être productif en Go, car ils constituent les fondations sur lesquelles reposent de nombreuses opérations courantes.

Entrées/Sorties formatées : Le paquet `fmt`

Nous utilisons le paquet `fmt` depuis le tout début de notre apprentissage, principalement pour afficher des informations à la console. Son nom vient de "format" et il fournit des fonctions pour l'entrée/sortie formatée.

Fonctions clés :

• `fmt.Println(a ...interface{})` : Affiche ses arguments séparés par des espaces et ajoute une nouvelle ligne à la fin. C'est la fonction la plus simple pour un affichage rapide.
• `fmt.Printf(format string, a ...interface{})` : Affiche une sortie formatée selon une chaîne de formatage (le premier argument). Utilise des "verbes" de formatage (commençant par `%`) pour spécifier comment afficher les arguments suivants (ex: `%d` pour entier, `%s` pour chaîne, `%v` pour valeur par défaut, `%T` pour type, `%+v` pour afficher les noms des champs d'une struct, `%f` pour flottant, `%t` pour booléen, `%p` pour pointeur...).
• `fmt.Sprintf(format string, a ...interface{})` : Fonctionne comme `Printf`, mais au lieu d'afficher le résultat, elle le retourne sous forme de `string`. Très utile pour construire des chaînes complexes.
• `fmt.Errorf(format string, a ...interface{})` : Comme nous l'avons vu, fonctionne comme `Sprintf` mais retourne une valeur satisfaisant l'interface `error`.

Exemple rapide :

package main

import "fmt"

type Point struct { X, Y int }

func main() {
    nom := "Alice"
    age := 30
    p := Point{10, 20}

    fmt.Println("Simple:", nom, age, p)
    // Simple: Alice 30 {10 20}

    fmt.Printf("Formaté: Nom=%s, Age=%d, Point=%v, TypePoint=%T\n", nom, age, p, p)
    // Formaté: Nom=Alice, Age=30, Point={10 20}, TypePoint=main.Point
    
    fmt.Printf("Struct détaillée: %+v\n", p)
    // Struct détaillée: {X:10 Y:20}

    message := fmt.Sprintf("%s a %d ans.", nom, age)
    fmt.Println("Message construit:", message)
    // Message construit: Alice a 30 ans.
}

Le paquet `fmt` fournit également des fonctions pour lire l'entrée utilisateur (comme `fmt.Scanln`), mais l'impression et le formatage de chaînes sont ses usages les plus courants.

Manipulation de texte : Le paquet `strings`

Le travail avec des chaînes de caractères est omniprésent en programmation. Le paquet `strings` offre un ensemble complet de fonctions utilitaires pour manipuler les chaînes encodées en UTF-8 (le standard en Go).

Quelques fonctions très utiles :

• `strings.Contains(s, substr string) bool` : Vérifie si `s` contient `substr`.
• `strings.Count(s, substr string) int` : Compte les occurrences non chevauchantes de `substr` dans `s`.
• `strings.HasPrefix(s, prefix string) bool` : Vérifie si `s` commence par `prefix`.
• `strings.HasSuffix(s, suffix string) bool` : Vérifie si `s` se termine par `suffix`.
• `strings.Index(s, substr string) int` : Retourne l'index de la première occurrence de `substr` dans `s`, ou -1 si non trouvé.
• `strings.Join(elems []string, sep string) string` : Concatène les éléments de la slice `elems` en une seule chaîne, séparés par `sep`.
• `strings.Replace(s, old, new string, n int) string` : Remplace les `n` premières occurrences de `old` par `new` dans `s`. Si `n < 0`, remplace toutes les occurrences (`strings.ReplaceAll` est un raccourci pour cela).
• `strings.Split(s, sep string) []string` : Découpe `s` en une slice de sous-chaînes en utilisant `sep` comme délimiteur.
• `strings.ToLower(s string) string` / `strings.ToUpper(s string) string` : Convertit la chaîne en minuscules ou majuscules.
• `strings.TrimSpace(s string) string` : Supprime les espaces (selon `unicode.IsSpace`) au début et à la fin de `s`.

Exemple :

package main

import (
    "fmt"
    "strings"
)

func main() {
    phrase := "   Go est simple, Go est puissant!   "

    fmt.Printf("Contient 'Go' ? %t\n", strings.Contains(phrase, "Go")) // true
    fmt.Printf("Nombre de 'est' ? %d\n", strings.Count(phrase, "est"))     // 2
    fmt.Printf("Commence par '   Go' ? %t\n", strings.HasPrefix(phrase, "   Go")) // true

    mots := strings.Split("pomme,banane,orange", ",")
    fmt.Printf("Mots: %q\n", mots) // Mots: ["pomme" "banane" "orange"]
    fmt.Println("Joindre mots:", strings.Join(mots, " | ")) // Joindre mots: pomme | banane | orange

    fmt.Println("Majuscules:", strings.ToUpper(phrase))
    // Majuscules:    GO EST SIMPLE, GO EST PUISSANT!   

    fmt.Println("Sans espaces extérieurs:", strings.TrimSpace(phrase))
    // Sans espaces extérieurs: Go est simple, Go est puissant!
    
    remplace := strings.Replace(phrase, "est", "EST", 1) // Remplace 1 fois
    fmt.Println("Remplace 1 fois:", remplace)
    // Remplace 1 fois:    Go EST simple, Go est puissant!   
}

Travailler avec JSON : Le paquet `encoding/json` (bases)

JSON (JavaScript Object Notation) est un format d'échange de données textuel léger et très répandu, notamment pour les API web et les fichiers de configuration. Le paquet `encoding/json` de Go fournit les outils pour convertir des données Go en JSON (Marshalling ou Encodage) et inversement, convertir du JSON en données Go (Unmarshalling ou Décodage).

Opérations clés :

1. Marshalling (`json.Marshal`) : Convertit une structure de données Go (typiquement une struct ou une map) en une slice de bytes (`[]byte`) représentant les données au format JSON.

2. Unmarshalling (`json.Unmarshal`) : Prend une slice de bytes contenant des données JSON et les décode pour remplir les champs d'une structure de données Go (généralement un pointeur vers une struct ou une map).

Exemple simple :

package main

import (
    "encoding/json"
    "fmt"
    "log"
)

// Struct pour représenter des données utilisateur
// Notez les 'struct tags' `json:"..."` qui contrôlent les noms dans le JSON
type Utilisateur struct {
    ID       int    `json:"id"` 
    Nom      string `json:"nom"`
    Email    string `json:"email,omitempty"` // omitempty: n'inclut pas si la valeur est vide
    EstAdmin bool   `json:"est_admin"`
    // Ce champ ne sera pas inclus dans le JSON car non exporté (minuscule)
    motDePasse string 
}

func main() {
    // --- Marshalling (Go -> JSON) ---
    u1 := Utilisateur{
        ID:       1,
        Nom:      "Alice",
        Email:    "alice@example.com",
        EstAdmin: true,
        motDePasse: "secret", // Sera ignoré
    }

    jsonData, err := json.MarshalIndent(u1, "", "  ") // MarshalIndent pour une sortie lisible
    if err != nil {
        log.Fatalf("Erreur Marshal: %v", err)
    }
    fmt.Println("JSON généré:\n", string(jsonData)) // Convertit []byte en string pour afficher

    // --- Unmarshalling (JSON -> Go) ---
    jsonInput := []byte(`{"id": 2, "nom": "Bob", "est_admin": false, "ville": "Paris"}`)
    
    var u2 Utilisateur
    // On passe un pointeur vers u2 pour que Unmarshal puisse la modifier
    err = json.Unmarshal(jsonInput, &u2) 
    if err != nil {
        log.Fatalf("Erreur Unmarshal: %v", err)
    }
    fmt.Printf("\nUtilisateur décodé: %+v\n", u2)
    // Note: le champ 'ville' du JSON est ignoré car absent dans la struct Utilisateur.
    // Le champ Email sera vide (valeur zéro "").
}

Sortie :

JSON généré:
 {
  "id": 1,
  "nom": "Alice",
  "email": "alice@example.com",
  "est_admin": true
}

Utilisateur décodé: {ID:2 Nom:Bob Email: EstAdmin:false motDePasse:}

Les struct tags (ex: ``json:"nom"``) sont très importants pour contrôler la correspondance entre les champs Go et les clés JSON, gérer les cas (camelCase vs snake_case), et omettre des champs optionnels vides (`omitempty`). Seuls les champs exportés (commençant par une majuscule) d'une struct peuvent être encodés ou décodés par le paquet `encoding/json`.

Conclusion : Des outils standards pour des tâches courantes

Ce survol des paquets `fmt`, `strings` et `encoding/json` vous donne un aperçu de la puissance et de la praticité de la bibliothèque standard Go. `fmt` est indispensable pour toute interaction formatée, `strings` simplifie grandement le travail avec le texte, et `encoding/json` est la pierre angulaire de la manipulation JSON en Go.

Explorer la documentation de la bibliothèque standard est une étape essentielle pour tout développeur Go. Vous y découvrirez de nombreux autres paquets couvrant des domaines variés (`net/http` pour le web, `os` pour le système d'exploitation, `io` pour les entrées/sorties, `time` pour la gestion du temps, `crypto` pour la cryptographie, etc.), vous permettant de construire des applications robustes et performantes en vous appuyant sur des fondations solides et bien testées.