Formater une chaîne de caractères Go sans imprimer ?

Question

Existe-t-il un moyen simple de formater une chaîne de caractères en Go sans l'imprimer ?

Je peux le faire :

bar := "bar"
fmt.Printf("foo: %s", bar)

Mais je veux que la chaîne formatée soit renvoyée plutôt qu'imprimée afin de pouvoir la manipuler davantage.

Je pourrais aussi faire quelque chose comme :

s := "foo: " + bar

Mais cela devient difficile à lire lorsque la chaîne de format est complexe, et fastidieux lorsqu'une ou plusieurs des parties ne sont pas des chaînes et doivent être converties en premier, comme par exemple

i := 25
s := "foo: " + strconv.Itoa(i)

Existe-t-il un moyen plus simple de procéder ?

Answer 1

J'ai créé un projet go pour le formatage de chaînes de caractères à partir d'un modèle (il permet de formater des chaînes de caractères dans les formats suivants C# ou Python juste la première version pour les cas très simples), vous pouvez la trouver ici https://github.com/Wissance/stringFormatter

il fonctionne de la manière suivante :

func TestStrFormat(t *testing.T) {
    strFormatResult, err := Format("Hello i am {0}, my age is {1} and i am waiting for {2}, because i am {0}!",
                              "Michael Ushakov (Evillord666)", "34", "\"Great Success\"")
    assert.Nil(t, err)
    assert.Equal(t, "Hello i am Michael Ushakov (Evillord666), my age is 34 and i am waiting for \"Great Success\", because i am Michael Ushakov (Evillord666)!", strFormatResult)

    strFormatResult, err = Format("We are wondering if these values would be replaced : {5}, {4}, {0}", "one", "two", "three")
    assert.Nil(t, err)
    assert.Equal(t, "We are wondering if these values would be replaced : {5}, {4}, one", strFormatResult)

    strFormatResult, err = Format("No args ... : {0}, {1}, {2}")
    assert.Nil(t, err)
    assert.Equal(t, "No args ... : {0}, {1}, {2}", strFormatResult)
}

func TestStrFormatComplex(t *testing.T) {
    strFormatResult, err := FormatComplex("Hello {user} what are you doing here {app} ?", map[string]string{"user":"vpupkin", "app":"mn_console"})
    assert.Nil(t, err)
    assert.Equal(t, "Hello vpupkin what are you doing here mn_console ?", strFormatResult)
}

Answer 2

Je suis venu sur cette page en cherchant spécifiquement un moyen de formater une chaîne d'erreur. Donc, si quelqu'un a besoin d'aide pour la même chose, il faut utiliser la fonction fmt.Errorf() fonction.

La signature de la méthode est func Errorf(format string, a ...interface{}) error . Il renvoie la chaîne de caractères formatée sous la forme d'une valeur qui satisfait à l'exigence de la norme error interface.

Vous pouvez trouver plus de détails dans la documentation - https://golang.org/pkg/fmt/#Errorf .

Answer 3

fmt.SprintF renvoie une chaîne de caractères et vous pouvez la formater de la même manière que vous l'auriez fait avec la fonction fmt.PrintF

Answer 4

Au lieu d'utiliser template.New vous pouvez simplement utiliser l'option new avec modèle.modèle :

package main

import (
   "strings"
   "text/template"
)

func format(s string, v interface{}) string {
   t, b := new(template.Template), new(strings.Builder)
   template.Must(t.Parse(s)).Execute(b, v)
   return b.String()
}

func main() {
   bar := "bar"
   println(format("foo: {{.}}", bar))
   i := 25
   println(format("foo: {{.}}", i))
}