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 Slettre de démarrage , mais ces Sxxx()variantes renvoient le résultat au stringlieu 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 ssera 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 strings, 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/templateet html/template. Ces packages implémentent des modèles basés sur les données pour générer une sortie textuelle. html/templatesert à générer une sortie HTML sûre contre l'injection de code. Il fournit la même interface que le package text/templateet doit être utilisé à la place de text/templatechaque fois que la sortie est HTML.
L'utilisation des templatepackages nécessite essentiellement que vous fournissiez un modèle statique sous la forme d'une stringvaleur (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 structs et les mapvaleurs 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.Bufferqui 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.Stdoutcomme 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 .