1. Chaînes simples
Pour les chaînes "simples" (généralement ce qui tient dans une ligne), la solution la plus simple consiste à utiliser fmt.Sprintf()
and friends ( fmt.Sprint()
, fmt.Sprintln()
). Celles-ci sont analogues aux fonctions sans la S
lettre de démarrage , mais ces Sxxx()
variantes renvoient le résultat au string
lieu de les imprimer sur la sortie standard.
Par exemple:
s := fmt.Sprintf("Hi, my name is %s and I'm %d years old.", "Bob", 23)
La variable s
sera initialisée avec la valeur:
Hi, my name is Bob and I'm 23 years old.
Astuce: Si vous souhaitez simplement concaténer des valeurs de différents types, vous n'aurez peut-être pas besoin d'utiliser automatiquement Sprintf()
(ce qui nécessite une chaîne de formatage) comme c'est Sprint()
exactement le cas. Voir cet exemple:
i := 23
s := fmt.Sprint("[age:", i, "]") // s will be "[age:23]"
Pour concaténer uniquement des string
s, vous pouvez également utiliser strings.Join()
où vous pouvez spécifier un séparateur personnalisé string
(à placer entre les chaînes à joindre).
Essayez-les sur le Go Playground .
2. Chaînes complexes (documents)
Si la chaîne que vous essayez de créer est plus complexe (par exemple un e-mail multiligne), elle fmt.Sprintf()
devient moins lisible et moins efficace (surtout si vous devez le faire plusieurs fois).
Pour cela, la bibliothèque standard fournit les packages text/template
et html/template
. Ces packages implémentent des modèles basés sur les données pour générer une sortie textuelle. html/template
sert à générer une sortie HTML sûre contre l'injection de code. Il fournit la même interface que le package text/template
et doit être utilisé à la place de text/template
chaque fois que la sortie est HTML.
L'utilisation des template
packages nécessite essentiellement que vous fournissiez un modèle statique sous la forme d'une string
valeur (qui peut provenir d'un fichier auquel cas vous ne fournissez que le nom du fichier) qui peut contenir du texte statique et des actions qui sont traitées et exécutées lorsque le Le moteur traite le modèle et génère la sortie.
Vous pouvez fournir des paramètres qui sont inclus / substitués dans le modèle statique et qui peuvent contrôler le processus de génération de sortie. La forme typique de ces paramètres est struct
s et les map
valeurs qui peuvent être imbriquées.
Exemple:
Par exemple, supposons que vous souhaitiez générer des e-mails qui ressemblent à ceci:
Hi [name]!
Your account is ready, your user name is: [user-name]
You have the following roles assigned:
[role#1], [role#2], ... [role#n]
Pour générer des corps de message électronique comme celui-ci, vous pouvez utiliser le modèle statique suivant:
const emailTmpl = `Hi {{.Name}}!
Your account is ready, your user name is: {{.UserName}}
You have the following roles assigned:
{{range $i, $r := .Roles}}{{if $i}}, {{end}}{{.}}{{end}}
`
Et fournissez des données comme celle-ci pour l'exécuter:
data := map[string]interface{}{
"Name": "Bob",
"UserName": "bob92",
"Roles": []string{"dbteam", "uiteam", "tester"},
}
Normalement, la sortie des modèles est écrite dans un io.Writer
, donc si vous voulez que le résultat soit un string
, créez et écrivez dans un bytes.Buffer
(qui implémente io.Writer
). Exécuter le modèle et obtenir le résultat sous la forme string
:
t := template.Must(template.New("email").Parse(emailTmpl))
buf := &bytes.Buffer{}
if err := t.Execute(buf, data); err != nil {
panic(err)
}
s := buf.String()
Cela se traduira par la sortie attendue:
Hi Bob!
Your account is ready, your user name is: bob92
You have the following roles assigned:
dbteam, uiteam, tester
Essayez-le sur le Go Playground .
A noter également que depuis Go 1.10, une nouvelle alternative plus rapide, plus spécialisée est disponible pour ce bytes.Buffer
qui est: strings.Builder
. L'utilisation est très similaire:
builder := &strings.Builder{}
if err := t.Execute(builder, data); err != nil {
panic(err)
}
s := builder.String()
Essayez celui-ci sur le Go Playground .
Remarque: vous pouvez également afficher le résultat d'une exécution de modèle si vous fournissez os.Stdout
comme cible (qui implémente également io.Writer
):
t := template.Must(template.New("email").Parse(emailTmpl))
if err := t.Execute(os.Stdout, data); err != nil {
panic(err)
}
Cela écrira le résultat directement dans os.Stdout
. Essayez ceci sur le Go Playground .