Cuando está creando un sitio web, normalmente generará parte de su contenido final de forma dinámica. Luego querrá inyectar esos datos en sus páginas web finales para mostrarlos en un navegador.
Puede tomar uno de dos enfoques: incrustar la estructura de su página en su programa o combinar sus datos finales con archivos de plantilla separados.
Las plantillas proporcionan separación de preocupaciones para una base de código más fácil de mantener. También facilita la división de tareas de front-end y tareas de back-end, asignándolas a diferentes miembros del equipo. Go tiene un excelente soporte de plantillas en su biblioteca estándar.
Primeros pasos con las plantillas en Go
Go tiene dos paquetes de plantillas en la biblioteca estándar: texto/plantilla y html/plantilla. El paquete text/template tiene funcionalidad para analizar archivos de texto, mientras que html/template maneja HTML. Al usar la plantilla/html, está protegido contra ataques de secuencias de comandos en sitios cruzados (XSS), ya que Go evita la entrada de datos durante el procesamiento. Esta es otra ventaja de las plantillas sobre un enfoque manual.
Dado que el paquete de plantillas es parte de la biblioteca estándar, no necesitará instalar ninguna dependencia; solo importalo:
importar "html/plantilla"
Inicia por creando un archivo HTML para usar como plantilla para su aplicación. Puedes usar el estándar .html extensión o bien .gohtml o .tmpl, ambos son que también son comunes. Independientemente de la extensión que utilice, la funcionalidad dentro de su aplicación será la misma. Algunos editores de texto pueden aplicar diferentes resaltados de sintaxis según las extensiones de sus plantillas. Aquí hay un esqueleto básico:
<!DOCTYPE html>
<idioma html="es">
<cabeza>
<juego de caracteres meta="UTF-8">
<título>Documento</title>
</head>
<cuerpo>
</body>
</html>
Guarde este archivo en el directorio de su programa Go. Ahora puede comenzar a trabajar con él, como una plantilla, dentro de su programa.
Crear una instancia global de la Modelo método del paquete de plantilla. Accederá a esta instancia de plantilla desde varias partes de su programa.
variable tmplt *plantilla. Modelo
Tendrá que crear un servidor simple para renderizar y mostrar sus plantillas. Aquí se explica cómo iniciar un servidor simple en Go usando el red/http paquete:
funciónejecutarServidor() {
http. HandleFunc("/inicio", handlePage)
error := http. ListenAndServe("localhost:8080", nulo)
si error! = nulo {
Iniciar sesión. Fatalln("Hay un error con el servidor:", err)
}
}
llamarás al ejecutarServidor función de su función principal para iniciar el servidor. El servidor tiene una sola ruta, la /home ruta, que mostrará su página. los handlePage El parámetro es el nombre de una función de controlador que representará su página. los escucharyservir el método inicia el servidor escuchando en el puerto 8080 en localhost, es decir, su propia computadora.
Pasar variables a plantillas
Crear una estructura global llamada Noticias:
escribe Noticias estructura {
Titular cuerda
Cuerpo cuerda
}
Utilizará esta estructura para almacenar datos y pasarlos a su plantilla para mostrarlos en su página final. En su plantilla, puede usar esta sintaxis para inyectar datos:
{{ nombre }}Dónde nombre es el nombre de una variable que ha pasado a su plantilla. Cuando represente la plantilla, reemplazará los valores entre llaves con los datos correspondientes de su código Go. Dado que el siguiente ejemplo pasará una estructura, utilizará la notación de puntos para acceder a sus campos:
<cuerpo>
<h1>{{ .Título }}</h1>
<pags> {{ .Cuerpo }} </pags>
</body>
Reemplace el elemento de cuerpo vacío en el marcado de esqueleto de su plantilla con el código anterior.
los handlePage La función del controlador verificará que la solicitud de la página sea una solicitud GET. Luego, completa una estructura con datos de muestra antes de representar la plantilla y publicar la página final:
funciónhandlePage(escritor http. ResponseWriter, solicitud *http. Solicitud) {
si solicitud. Método == "OBTENER" {
tmplt, _ = plantilla. ParseFiles("tutorial.html")evento := Noticias{
Titular: "makeuseof.com tiene todo Tech",
Cuerpo: "Visita MUO por todo lo relacionado con la tecnología",
}err := prueba. Ejecutar (escritor, evento)
si error! = nulo {
devolver
}
}
}
los ParseFiles El método analiza el archivo HTML que especifique. los evento variable es la estructura inicializada. los Ejecutar El método inyectará los datos proporcionados en la página final, de acuerdo con los marcadores de posición en la plantilla. Ejecutar toma un escritor de respuestas y los datos, en este caso, la estructura.
Aquí está el resultado de ejecutar el servidor y visitar la página:
Uso de estructuras de control en plantillas
También puede usar estructuras de control como declaraciones condicionales y bucles en sus plantillas.
Un bucle le permite generar varios valores y reutilizar la misma estructura para cada uno. Utilizar el rango palabra clave para definir el comienzo del contenido repetido y el final palabra clave para el final. Dentro del ciclo puedes usar el {{.}} sintaxis para inyectar el valor actual:
{{rango .}}
- {{.}}
{{final}}
Luego, pasará el nombre de la estructura de datos que desea recorrer como parámetro al método Execute:
hacerUsoDeCategorías := []cuerda{"Tecnología explicada", "Programación", "Linux",
"Android", "iOS", "Muchos más..."}err := prueba. Ejecutar (escritor, makeUseOfCategories)
si error! = nulo {
devolver
}
los makeUseOfCategories variable es una porción de cadenas para pasar como el parámetro de datos. Este es el resultado de recorrer el segmento:
Puede usar una declaración condicional en sus plantillas para probar el valor de una variable booleana. Cree una estructura con campos booleanos, como esta:
escribe VerdaderoFalso estructura {
Es verdad bool
Es falso bool
es por defecto bool
}
Para usar un condicional, incluya el si palabra clave entre llaves dobles antes del nombre de la variable a probar. Termina el bloque condicional con el final palabra clave entre llaves:
{{si .Es Verdadero}}
<pags>Evalúa verdadero y generará</pags>
{{final}}{{si .Es predeterminado}}
<pags>Evalúa falso y ganó'salida</pags>
{{final}}
{{si .Es falso}}
<pags>Evalúa falso y ganó'salida</pags>
{{final}}
Inicializar una estructura en Go establece los valores en falso de forma predeterminada, por lo que si no inicializa un campo, se evalúa como falso. Al inicializar la estructura y pasar la variable como datos a la plantilla, solo los campos que se evalúan como verdaderos hacen que aparezca la salida.
opción := TrueFalser {
Es verdad: verdadero,
Es falso: falso,
}
err := prueba. Ejecutar (escritor, elección)
El resultado final incluye solo un párrafo, ya que solo el campo isTrue se evalúa como verdadero:
No tiene que usar plantillas para sus aplicaciones de back-end
Las plantillas no son un requisito para sus aplicaciones Go. Puede usar otros enfoques, como incrustar la estructura de su página en su programa, junto con su lógica y otros comportamientos.
Sin embargo, terminarás haciendo más trabajo para ti. Las plantillas de Go ayudan a prevenir ataques XSS y facilitan la separación del trabajo en la estructura de la página de la lógica del servidor.
