Cordas simples

Para cordas “simples” (tipicamente o que cabe em uma linha) a solução mais simples é usar fmt.Sprintf() e amigos (fmt.Sprint(), fmt.Sprintln()). Estas são análogas às funções sem a letra inicial S, mas estas Sxxx() variantes retornam o resultado como um string em vez de as imprimir para a saída padrão.

Por exemplo:

s := fmt.Sprintf("Hi, my name is %s and I'm %d years old.", "Bob", 23)

A variável s será inicializada com o valor:

Hi, my name is Bob and I'm 23 years old.

Tip: Se você quiser apenas concatenar valores de diferentes tipos, você pode não precisar usar automaticamente Sprintf() (que requer uma string de formato), pois Sprint() faz exatamente isso. Veja este exemplo:

i := 23s := fmt.Sprint("") // s will be ""

Para concatenar apenas strings, você também pode usar strings.Join() onde você pode especificar um separador personalizado string (a ser colocado entre as strings para juntar).

Tente estes no Go Playground.

Cadeias complexas (documentos)

Se a cadeia de caracteres que está a tentar criar é mais complexa (por exemplo, uma mensagem de e-mail com várias linhas), fmt.Sprintf() torna-se menos legível e menos eficiente (especialmente se tiver de fazer isto muitas vezes).

Para isto a biblioteca padrão fornece os pacotes text/template e html/template. Estes pacotes implementam modelos orientados por dados para a geração de saída textual. html/template é para gerar a saída HTML segura contra a injeção de código. Ela fornece a mesma interface do pacote text/template e deve ser usada no lugar de text/template sempre que a saída for HTML.

Usando os pacotes template basicamente requer que você forneça um template estático na forma de um valor string (que pode ser originado de um arquivo, caso em que você só fornece o nome do arquivo) que pode conter texto estático, e ações que são processadas e executadas quando o mecanismo processa o template e gera a saída.

Você pode fornecer parâmetros que são incluídos/substituídos no template estático e que podem controlar o processo de geração de saída. A forma típica de tais parâmetros são structs e map valores que podem ser aninhados.

Exemplo:

Por exemplo, digamos que você queira gerar mensagens de e-mail com esta aparência:

Hi !Your account is ready, your user name is: You have the following roles assigned:, , ... 

Para gerar corpos de mensagens de e-mail como este, você poderia usar o seguinte template estático:

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}}`

E fornecer dados como este para executá-lo:

data := mapinterface{}{ "Name": "Bob", "UserName": "bob92", "Roles": string{"dbteam", "uiteam", "tester"},}

Saída normal dos templates são escritos em um io.Writer, então se você quer o resultado como um string, crie e escreva em um bytes.Buffer (que implementa io.Writer). Executando o template e obtendo o resultado como 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()

Esta resultará na saída esperada:

Hi Bob!Your account is ready, your user name is: bob92You have the following roles assigned:dbteam, uiteam, tester

Tente-o no Go Playground.

Note também que desde Go 1.10, uma alternativa mais nova, mais rápida e mais especializada está disponível para bytes.Buffer que é: strings.Builder. O uso é muito similar:

builder := &strings.Builder{}if err := t.Execute(builder, data); err != nil { panic(err)}s := builder.String()

Tente este no Go Playground.

Nota: você também pode exibir o resultado da execução de um template se você fornecer os.Stdout como alvo (que também implementa io.Writer):

t := template.Must(template.New("email").Parse(emailTmpl))if err := t.Execute(os.Stdout, data); err != nil { panic(err)}

Isso irá escrever o resultado diretamente para os.Stdout. Tente isto no Go Playground.