71 lines
2.9 KiB
Markdown
71 lines
2.9 KiB
Markdown
---
|
|
title: Using templates with your web server
|
|
localeTitle: Usando plantillas con su servidor web
|
|
---
|
|
Cuando tenga un servidor web, es posible que desee insertar datos en sus respuestas. Veamos un código:
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"net/http"
|
|
"html/template"
|
|
)
|
|
|
|
type PAGE struct {
|
|
NAME string
|
|
}
|
|
|
|
var page PAGE
|
|
|
|
func main() {
|
|
page.NAME = "Mark"
|
|
http.HandleFunc("/", servePage)
|
|
http.ListenAndServe(":8080", nil)
|
|
}
|
|
|
|
func servePage(writer http.ResponseWriter, reqest *http.Request) {
|
|
template := template.New("sayHello")
|
|
template, _ = template.Parse("Hello {{.NAME}}!")
|
|
template.Execute(writer, page)
|
|
}
|
|
```
|
|
|
|
Ahora inicie este programa y navegue por su navegador para:
|
|
```
|
|
http://localhost:8080/
|
|
```
|
|
|
|
La respuesta será:
|
|
```
|
|
Hello Mark!
|
|
```
|
|
|
|
Pero, ¿cómo funciona esto y qué hace el código? Bueno, en primer lugar importamos el paquete `net/http` para que podamos ejecutar un servidor web. Luego importamos el paquete `html/template` . Esto habilita una característica llamada plantillas; Y ahí es donde se trata este artículo.
|
|
|
|
También creamos un tipo llamado `PAGE` , que tiene un campo llamado `NAME` como `string` tipo. También creamos una variable global llamada `page` de tipo `PAGE` , la estructura que acabamos de crear. En la función `main` le damos al campo `NAME` de la `page` un valor de `Mark` - mi nombre, ¡pero no dude en usar su propio nombre!
|
|
|
|
La función `servePage` es un poco difícil al principio. Vamos a desarmarlo:
|
|
|
|
```go
|
|
func servePage(writer http.ResponseWriter, reqest *http.Request) {
|
|
|
|
// 1. Creating a template
|
|
template := template.New("sayHello")
|
|
|
|
// 2. Filling the template
|
|
template, _ = template.Parse("Hello {{.NAME}}!")
|
|
|
|
// 3. Executing the template
|
|
template.Execute(writer, page)
|
|
}
|
|
```
|
|
|
|
Qué hacemos aquí? Veamos paso a paso:
|
|
|
|
1. Creamos una _plantilla_ . Debe ingresar un nombre, pero en realidad no importa el nombre que elija. Aquí elegí decir `sayHello` .
|
|
2. Luego llenamos la plantilla con algún texto. Por favor tome nota de la `{{.NAME}}` .
|
|
3. Finalmente, _ejecutamos_ la plantilla. Esto significa que la plantilla se completa y se envía al cliente.
|
|
|
|
Pero, ¿cómo vamos de `{{.NAME}}` a `Mark` ? Bueno, ¿recuerdas que usamos la variable de `page` como un parámetro para el método `Execute` ? Este método mira los datos en la plantilla y ve `{{.NAME}}` . El `.NAME` indica que debe buscar un campo llamado `NAME` dentro de la variable que se especificó como un parámetro cuando se llamó a `Execute` . En este caso, encuentra ese campo y toma nota de que el valor es `Mark` . `{{` Y `}}` le dicen a `Execute` que debe reemplazar `{{.NAME}}` con el valor que encontró. Así que el resultado final se convertirá en `Hello Mark!` .
|
|
|
|
Puedes tener múltiples campos y múltiples `{{.XXX}}` . Esta es una manera realmente fácil de insertar datos en las respuestas, ¡y ahora sabe cómo crear una plantilla en Go! |