string - strip_tags - ¿Formatear una cadena Go sin imprimir?

strip_tags wordpress

Question

¿Hay una forma sencilla de formatear una cadena en Go sin imprimir la cadena?

Puedo hacer:

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

Pero quiero que se devuelva la cadena formateada en lugar de imprimirla para poder manipularla aún más.

También podría hacer algo como:

s := "foo: " + bar

Pero esto se vuelve difícil de leer cuando la cadena de formato es compleja, y engorroso cuando una o muchas de las partes no son cadenas y deben convertirse primero, como

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

Soy muy nuevo en Go, mi experiencia es en Ruby, donde esto es sencillo. ¿Hay una manera más sencilla de hacer esto?

Answer 1

1. cuerdas simples

Para cadenas "simples" (generalmente 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 letra S arranque, pero estas variantes Sxxx() devuelven el resultado como una 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 utilizar Sprintf() (que requiere una cadena de formato) ya que Sprint() hace exactamente esto. Vea este ejemplo:

i := 23
s := fmt.Sprint("[age:", i, "]") // s will be "[age:23]"

Para concatenar solo la string s, también puede usar strings.Join() donde puede especificar una string separadora personalizada (que se colocará entre las cadenas para unir).

Prueba estos en el Go Playground .

2. Cuerdas complejas (documentos)

Si la cadena que intenta crear es más compleja (por ejemplo, un mensaje de correo electrónico de varias líneas), 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 controladas por datos para generar resultados textuales. html/template es para generar una salida HTML segura contra la inyección de código. Proporciona la misma interfaz que el paquete de text/template y debe usarse en lugar de text/template siempre que la salida sea HTML.

El uso de los paquetes de template básicamente requiere que proporcione una plantilla estática en forma de un valor de string (que puede provenir 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 motor procesa la plantilla y genera la salida.

Puede proporcionar parámetros que están incluidos / sustituidos 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 las struct y map valores de map que pueden estar anidados.

Ejemplo:

Por ejemplo, digamos que desea generar mensajes de correo electrónico que se parecen a esto:

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 ne $i 0}}, {{end}}{{.}}{{end}}
`

Y proporcionar 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 , por lo que si desea el resultado como una string , cree y escriba en un bytes.Buffer . bytes.Buffer (que implementa io.Writer ). Ejecutando la plantilla y obteniendo el resultado como una 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á lugar a la salida esperada:

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

Pruébalo en el Go Playground .

También tenga en cuenta que desde Go 1.10, hay una alternativa más nueva, más rápida y más especializada 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 el Go Playground .

Nota: también puede mostrar el resultado de la ejecución de una 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 el Go Playground .

Answer 2

En su caso, necesita usar Sprintf () para la cadena de formato.

func Sprintf(format string, a ...interface{}) string

Sprintf formatea de acuerdo con un especificador de formato y devuelve la cadena resultante.

s := fmt.Sprintf("Good Morning, This is %s and I''m living here from last %d years ", "John", 20)

Tu salida será:

Buenos días, este es John y estoy viviendo aquí desde los últimos 20 años.

Answer 3

Sprintf

Aquí también hay un uso de él en el tutorial "A Tour of Go".

return fmt.Sprintf("at %v, %s", e.When, e.What)

Answer 4

La función fmt.SprintF devuelve una cadena y puede formatear la cadena de la misma manera que lo haría con fmt.PrintF