Go Academy · Leçon

Sprintf et Fprintf

Écrire du texte formaté dans des chaînes et des écrivains

Sprintf et Fprintf est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

La famille Printf

Le paquet fmt propose trois fonctions de formatage apparentées :

Printf écrit sur la sortie standard.
Sprintf renvoie une chaîne formatée.
Fprintf écrit vers n'importe quel écrivain.

package main

import "fmt"

func main() {
    fmt.Printf("hello %s\n", "world")
}

Sprintf renvoie une chaîne

fmt.Sprintf formate exactement comme Printf mais, au lieu d'afficher le résultat, il le renvoie sous forme de chaîne que vous pouvez stocker ou réutiliser.

package main

import "fmt"

func main() {
    msg := fmt.Sprintf("%s scored %d", "Bob", 95)
    fmt.Println(msg)
}

Créer des identifiants

Sprintf est pratique pour assembler des clés, des noms de fichiers ou des étiquettes à partir de plusieurs éléments.

package main

import "fmt"

func main() {
    id := fmt.Sprintf("user-%04d", 42)
    fmt.Println(id)
}

Formater des nombres en texte

Utilisez Sprintf pour transformer des nombres en chaînes correctement formatées, par exemple pour représenter une devise.

package main

import "fmt"

func main() {
    label := fmt.Sprintf("Price: $%.2f", 7.5)
    fmt.Println(label)
}

Fprintf écrit vers un écrivain

fmt.Fprintf prend un io.Writer comme premier argument et écrit le résultat formaté dedans. os.Stdout est un tel écrivain.

package main

import (
    "fmt"
    "os"
)

func main() {
    fmt.Fprintf(os.Stdout, "to stdout: %d\n", 1)
}

Écrire sur la sortie d'erreur standard

Envoyez les informations de diagnostic vers os.Stderr avec Fprintf afin de les séparer de la sortie normale.

package main

import (
    "fmt"
    "os"
)

func main() {
    fmt.Fprintf(os.Stderr, "warning: %s\n", "low disk")
}

Fprintf dans un Builder

Puisque strings.Builder est également un io.Writer, vous pouvez le formater directement, puis lire la chaîne à la fin.

package main

import (
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder
    fmt.Fprintf(&b, "%s=%d;", "x", 10)
    fmt.Fprintf(&b, "%s=%d", "y", 20)
    fmt.Println(b.String())
}

Fprintf dans un bytes.Buffer

Un bytes.Buffer est une autre cible courante pour un écrivain. Accumulez le contenu, puis convertissez-le en chaîne.

package main

import (
    "bytes"
    "fmt"
)

func main() {
    var buf bytes.Buffer
    fmt.Fprintf(&buf, "row %d\n", 1)
    fmt.Fprintf(&buf, "row %d\n", 2)
    fmt.Print(buf.String())
}

Sprint et Fprint sans f

Les versions avec f prennent une chaîne de format. Supprimez le f pour Sprint/Fprint, qui concatènent simplement les arguments avec le formatage par défaut.

package main

import "fmt"

func main() {
    s := fmt.Sprint("a", 1, true)
    fmt.Println(s)
}

Sprintln ajoute des espaces

fmt.Sprintln joint les arguments en les séparant par des espaces et ajoute un retour à la ligne, puis renvoie la chaîne.

package main

import "fmt"

func main() {
    s := fmt.Sprintln("x", 1, "y", 2)
    fmt.Print(s)
}

Choisir le bon outil

Choisissez selon la destination :

Vous avez besoin d'une chaîne ? Utilisez Sprintf.
Vous écrivez sur la sortie standard ? Utilisez Printf.
Vous écrivez dans un fichier, un tampon ou un flux d'erreur ? Utilisez Fprintf.

package main

import (
    "fmt"
    "os"
)

func main() {
    s := fmt.Sprintf("count=%d", 3)
    fmt.Fprintf(os.Stdout, "%s\n", s)
}

Vérification rapide

Quelle fonction renvoie le texte formaté au lieu de l'afficher ?

Récapitulatif : Sprintf et Fprintf

Vous avez découvert la famille des fonctions de formatage :

Sprintf renvoie une chaîne.
Fprintf écrit vers n'importe quel io.Writer (sorties standard et d'erreur, tampons et générateurs).
Les variantes sans f utilisent le formatage par défaut.

package main

import (
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder
    fmt.Fprintf(&b, "result=%s", fmt.Sprintf("%d%%", 80))
    fmt.Println(b.String())
}

Questions Fréquemment Posées

La leçon « Sprintf et Fprintf » est-elle gratuite ?

Oui — le texte complet de « Sprintf et Fprintf » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Sprintf et Fprintf » ?

Écrire du texte formaté dans des chaînes et des écrivains Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Sprintf et Fprintf » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Go Academy