1. Cordes simples
Pour les chaînes "simples" (typiquement ce qui tient dans une ligne), la solution la plus simple est d'utiliser fmt.Sprintf() et ses amis ( fmt.Sprint() , fmt.Sprintln() ). Celles-ci sont analogues aux fonctions sans le démarreur S lettre, mais ces Sxxx() variants renvoient le résultat sous la forme d'un string au 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é avec cette valeur :
Hi, my name is Bob and I'm 23 years old.
Conseil : Si vous souhaitez simplement concaténer des valeurs de différents types, vous n'aurez peut-être pas automatiquement besoin d'utiliser la commande Sprintf() (qui nécessite une chaîne de format) comme Sprint() fait exactement cela. Voir cet exemple :
i := 23
s := fmt.Sprint("[age:", i, "]") // s will be "[age:23]"
Pour la concaténation uniquement string vous pouvez également utiliser strings.Join() où vous pouvez spécifier un séparateur personnalisé string (à placer entre les cordes à 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 message électronique de plusieurs lignes), fmt.Sprintf() devient moins lisible et moins efficace (surtout si vous devez le faire plusieurs fois).
Pour cela, la bibliothèque standard fournit les paquets text/template y html/template . Ces paquets mettent en œuvre des modèles axés sur les données pour générer une sortie textuelle. html/template sert à générer une sortie HTML sécurisée contre l'injection de code. Il fournit la même interface que le paquet text/template et devrait être utilisé à la place de text/template lorsque la sortie est en HTML.
Utilisation de la template vous demande essentiellement de fournir un modèle statique sous la forme d'un fichier string la valeur (qui peut provenir d'un fichier, auquel cas vous ne fournissez que le nom du fichier) qui peut contenir du texte statique, et les actions qui sont traitées et exécutées lorsque 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 la sortie. Les formes typiques de tels paramètres sont struct et map qui peuvent être imbriquées.
Exemple :
Par exemple, disons que vous voulez générer des messages électroniques 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 messages électroniques 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 fournir des données comme celles-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 fichier de type io.Writer donc si vous voulez que le résultat soit un string créer et écrire dans un bytes.Buffer (qui met en œuvre io.Writer ). En exécutant le modèle, on obtient le résultat suivant 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()
Vous obtiendrez ainsi le résultat escompté :
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 .
Notez également que depuis Go 1.10, une alternative plus récente, plus rapide et plus spécialisée est disponible pour 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 de l'exécution d'un modèle si vous indiquez 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)
}
Ceci écrira le résultat directement dans os.Stdout . Essayez ceci sur le Go Playground .
