1. Cuerdas simples
Para cadenas "simples" (típicamente lo que cabe en una línea) la solución más simple es usar fmt.Sprintf()
y amigos ( fmt.Sprint()
, fmt.Sprintln()
). Estas son análogas a las funciones sin la S
letra de inicio , pero estas Sxxx()
variantes devuelven el resultado en string
lugar de imprimirlas en la salida estándar.
Por ejemplo:
s := fmt.Sprintf("Hi, my name is %s and I'm %d years old.", "Bob", 23)
La variable s
se inicializará con el valor:
Hi, my name is Bob and I'm 23 years old.
Sugerencia: Si solo desea concatenar valores de diferentes tipos, es posible que no necesite usarlos automáticamente Sprintf()
(lo que requiere una cadena de formato) como Sprint()
hace exactamente esto. Ver este ejemplo:
i := 23
s := fmt.Sprint("[age:", i, "]") // s will be "[age:23]"
Para concatenar solo string
s, también puede usar strings.Join()
donde puede especificar un separador personalizado string
(que se colocará entre las cadenas para unir).
Pruébalos en Go Playground .
2. Cadenas complejas (documentos)
Si la cadena que está intentando crear es más compleja (por ejemplo, un mensaje de correo electrónico de varias líneas), se fmt.Sprintf()
vuelve menos legible y menos eficiente (especialmente si tiene que hacerlo muchas veces).
Para esto, la biblioteca estándar proporciona los paquetes text/template
y html/template
. Estos paquetes implementan plantillas basadas en datos para generar resultados textuales. html/template
es para generar salida HTML segura contra la inyección de código. Proporciona la misma interfaz que el paquete text/template
y debe usarse en lugar de text/template
siempre que la salida sea HTML.
El uso de los template
paquetes básicamente requiere que proporcione una plantilla estática en forma de un string
valor (que puede ser originario de un archivo en cuyo caso solo proporciona el nombre del archivo) que puede contener texto estático y acciones que se procesan y ejecutan cuando el El motor procesa la plantilla y genera la salida.
Puede proporcionar parámetros que se incluyen / sustituyen en la plantilla estática y que pueden controlar el proceso de generación de salida. La forma típica de tales parámetros son struct
sy map
valores que pueden estar anidados.
Ejemplo:
Por ejemplo, supongamos que desea generar mensajes de correo electrónico que se vean así:
Hi [name]!
Your account is ready, your user name is: [user-name]
You have the following roles assigned:
[role#1], [role#2], ... [role#n]
Para generar cuerpos de mensajes de correo electrónico como este, puede usar la siguiente plantilla estática:
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}}
`
Y proporcione datos como este para ejecutarlo:
data := map[string]interface{}{
"Name": "Bob",
"UserName": "bob92",
"Roles": []string{"dbteam", "uiteam", "tester"},
}
Normalmente, la salida de las plantillas se escribe en un io.Writer
, así que si desea el resultado como a string
, cree y escriba en un bytes.Buffer
(que implementa io.Writer
). Ejecutando la plantilla y obteniendo el 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()
Esto dará como resultado el resultado esperado:
Hi Bob!
Your account is ready, your user name is: bob92
You have the following roles assigned:
dbteam, uiteam, tester
Pruébalo en Go Playground .
También tenga en cuenta que, dado Go 1.10, una alternativa más nuevo, más rápido, más especializado está disponible para los bytes.Buffer
que es: strings.Builder
. El uso es muy similar:
builder := &strings.Builder{}
if err := t.Execute(builder, data); err != nil {
panic(err)
}
s := builder.String()
Prueba este en Go Playground .
Nota: también puede mostrar el resultado de una ejecución de plantilla si proporciona os.Stdout
como destino (que también implementa io.Writer
):
t := template.Must(template.New("email").Parse(emailTmpl))
if err := t.Execute(os.Stdout, data); err != nil {
panic(err)
}
Esto escribirá el resultado directamente en os.Stdout
. Prueba esto en Go Playground .