Go
Texto + HTML Plantillas
Buscar..
Plantilla de elemento único
Tenga en cuenta el uso de {{.}} Para generar el elemento dentro de la plantilla.
package main
import (
"fmt"
"os"
"text/template"
)
func main() {
const (
letter = `Dear {{.}}, How are you?`
)
tmpl, err := template.New("letter").Parse(letter)
if err != nil {
fmt.Println(err.Error())
}
tmpl.Execute(os.Stdout, "Professor Jones")
}
Resultados en:
Dear Professor Jones, How are you?
Plantilla de elemento múltiple
Tenga en cuenta el uso de {{range .}} Y {{end}} para desplazarse por la colección.
package main
import (
"fmt"
"os"
"text/template"
)
func main() {
const (
letter = `Dear {{range .}}{{.}}, {{end}} How are you?`
)
tmpl, err := template.New("letter").Parse(letter)
if err != nil {
fmt.Println(err.Error())
}
tmpl.Execute(os.Stdout, []string{"Harry", "Jane", "Lisa", "George"})
}
Resultados en:
Dear Harry, Jane, Lisa, George, How are you?
Plantillas con lógica personalizada.
En este ejemplo, un mapa de función denominado funcMap se suministra a la plantilla a través del método Funcs() y luego se invoca dentro de la plantilla. Aquí, la función increment() se usa para evitar la falta de una función menor o igual en el lenguaje de plantillas. Observe en la salida cómo se maneja el artículo final en la colección.
A - al principio {{- o end -}} se usa para recortar espacios en blanco y se puede usar para ayudar a que la plantilla sea más legible.
package main
import (
"fmt"
"os"
"text/template"
)
var funcMap = template.FuncMap{
"increment": increment,
}
func increment(x int) int {
return x + 1
}
func main() {
const (
letter = `Dear {{with $names := .}}
{{- range $i, $val := $names}}
{{- if lt (increment $i) (len $names)}}
{{- $val}}, {{else -}} and {{$val}}{{end}}
{{- end}}{{end}}; How are you?`
)
tmpl, err := template.New("letter").Funcs(funcMap).Parse(letter)
if err != nil {
fmt.Println(err.Error())
}
tmpl.Execute(os.Stdout, []string{"Harry", "Jane", "Lisa", "George"})
}
Resultados en:
Dear Harry, Jane, Lisa, and George; How are you?
Plantillas con estructuras
Observe cómo se obtienen los valores de campo utilizando {{.FieldName}} .
package main
import (
"fmt"
"os"
"text/template"
)
type Person struct {
FirstName string
LastName string
Street string
City string
State string
Zip string
}
func main() {
const (
letter = `------------------------------
{{range .}}{{.FirstName}} {{.LastName}}
{{.Street}}
{{.City}}, {{.State}} {{.Zip}}
Dear {{.FirstName}},
How are you?
------------------------------
{{end}}`
)
tmpl, err := template.New("letter").Parse(letter)
if err != nil {
fmt.Println(err.Error())
}
harry := Person{
FirstName: "Harry",
LastName: "Jones",
Street: "1234 Main St.",
City: "Springfield",
State: "IL",
Zip: "12345-6789",
}
jane := Person{
FirstName: "Jane",
LastName: "Sherman",
Street: "8511 1st Ave.",
City: "Dayton",
State: "OH",
Zip: "18515-6261",
}
tmpl.Execute(os.Stdout, []Person{harry, jane})
}
Resultados en:
------------------------------
Harry Jones
1234 Main St.
Springfield, IL 12345-6789
Dear Harry,
How are you?
------------------------------
Jane Sherman
8511 1st Ave.
Dayton, OH 18515-6261
Dear Jane,
How are you?
------------------------------
Plantillas HTML
Tenga en cuenta la importación de diferentes paquetes.
package main
import (
"fmt"
"html/template"
"os"
)
type Person struct {
FirstName string
LastName string
Street string
City string
State string
Zip string
AvatarUrl string
}
func main() {
const (
letter = `<html><body><table>
<tr><th></th><th>Name</th><th>Address</th></tr>
{{range .}}
<tr>
<td><img src="{{.AvatarUrl}}"></td>
<td>{{.FirstName}} {{.LastName}}</td>
<td>{{.Street}}, {{.City}}, {{.State}} {{.Zip}}</td>
</tr>
{{end}}
</table></body></html>`
)
tmpl, err := template.New("letter").Parse(letter)
if err != nil {
fmt.Println(err.Error())
}
harry := Person{
FirstName: "Harry",
LastName: "Jones",
Street: "1234 Main St.",
City: "Springfield",
State: "IL",
Zip: "12345-6789",
AvatarUrl: "harry.png",
}
jane := Person{
FirstName: "Jane",
LastName: "Sherman",
Street: "8511 1st Ave.",
City: "Dayton",
State: "OH",
Zip: "18515-6261",
AvatarUrl: "jane.png",
}
tmpl.Execute(os.Stdout, []Person{harry, jane})
}
Resultados en:
<html><body><table>
<tr><th></th><th>Name</th><th>Address</th></tr>
<tr>
<td><img src="harry.png"></td>
<td>Harry Jones</td>
<td>1234 Main St., Springfield, IL 12345-6789</td>
</tr>
<tr>
<td><img src="jane.png"></td>
<td>Jane Sherman</td>
<td>8511 1st Ave., Dayton, OH 18515-6261</td>
</tr>
</table></body></html>
Cómo las plantillas HTML evitan la inyección de código malicioso
Primero, esto es lo que puede suceder cuando se usa text/template para HTML. Tenga en cuenta la propiedad FirstName de Harry).
package main
import (
"fmt"
"html/template"
"os"
)
type Person struct {
FirstName string
LastName string
Street string
City string
State string
Zip string
AvatarUrl string
}
func main() {
const (
letter = `<html><body><table>
<tr><th></th><th>Name</th><th>Address</th></tr>
{{range .}}
<tr>
<td><img src="{{.AvatarUrl}}"></td>
<td>{{.FirstName}} {{.LastName}}</td>
<td>{{.Street}}, {{.City}}, {{.State}} {{.Zip}}</td>
</tr>
{{end}}
</table></body></html>`
)
tmpl, err := template.New("letter").Parse(letter)
if err != nil {
fmt.Println(err.Error())
}
harry := Person{
FirstName: `Harry<script>alert("You've been hacked!")</script>`,
LastName: "Jones",
Street: "1234 Main St.",
City: "Springfield",
State: "IL",
Zip: "12345-6789",
AvatarUrl: "harry.png",
}
jane := Person{
FirstName: "Jane",
LastName: "Sherman",
Street: "8511 1st Ave.",
City: "Dayton",
State: "OH",
Zip: "18515-6261",
AvatarUrl: "jane.png",
}
tmpl.Execute(os.Stdout, []Person{harry, jane})
}
Resultados en:
<html><body><table>
<tr><th></th><th>Name</th><th>Address</th></tr>
<tr>
<td><img src="harry.png"></td>
<td>Harry<script>alert("You've been hacked!")</script> Jones</td>
<td>1234 Main St., Springfield, IL 12345-6789</td>
</tr>
<tr>
<td><img src="jane.png"></td>
<td>Jane Sherman</td>
<td>8511 1st Ave., Dayton, OH 18515-6261</td>
</tr>
</table></body></html>
El ejemplo anterior, si se accede desde un navegador, daría como resultado que el script se ejecute y se genere una alerta. Si, en cambio, se importó el html/template lugar de text/template , la secuencia de comandos se sanearía de forma segura:
<html><body><table>
<tr><th></th><th>Name</th><th>Address</th></tr>
<tr>
<td><img src="harry.png"></td>
<td>Harry<script>alert("You've been hacked!")</script> Jones</td>
<td>1234 Main St., Springfield, IL 12345-6789</td>
</tr>
<tr>
<td><img src="jane.png"></td>
<td>Jane Sherman</td>
<td>8511 1st Ave., Dayton, OH 18515-6261</td>
</tr>
</table></body></html>
El segundo resultado se vería confuso cuando se cargaba en un navegador, pero no daría como resultado la ejecución de un script potencialmente malicioso.
