Miles Gracias¡¡¡¡

Alexnara — Fri, 14 Jul 2006 22:47:34 -0700

Realmenrte estoy agradecido y feliz de haber encontrado lo que tanto habia buscado, informacion clara concisa y en español de PHP, los felicito por el gran aporte que hacen a la gente que se inicia como yo a este apasionante mundo de la programacion en PHP.

saludos

Gracias.

Jack — Sat, 17 Jun 2006 12:30:04 -0700

La verdad, se agradece esta breve referencia, ya que en la web hay contenido, pero extenso y en ingles. Con este conpendio puedo trabajar mas rapido.

Gracias

Diana Mabel — Tue, 26 Jul 2005 10:59:12 -0700

me has ayudado mucho, me ha servidomontones esto de las plantillas y me gusto mucho..... besos

Curso de PHP VI. De Plantillas y demases, parte 1: el enfoque KI

Php y otras yerbas, por Clbustos (trackback) — Sat, 02 Apr 2005 01:21:07 -0800

Un viejo tema en todo foro de discusión que se precie de PHP es el uso de plantillas. En la Tercera parte del curso me di la lata de explicar el porque del uso de plantillas, las ventajas de separ

Enhorabuena! es muy interesante el manual...

Jordi — Mon, 26 Jan 2004 01:53:20 -0800

Enhorabuena! es muy interesante el manual...
Jordi

Separación contenido / diseño - Uso de plantillas

admin — Tue, 06 Jan 2004 20:30:40 -0800

Separación de contenido-diseño y manejo de plantillas (Templates).
1.- Modelo de separación diseño - contenido
2.- Plantillas
- 2.1.- Introducción
- 2.2.- PEAR::Template_IT

Separación de contenido-diseño y manejo de plantillas (Templates).

Si bien PHP nació como un lenguaje embebido en HTML, y resulta muy rápido desarrollar programas pequeños de ese modo, cuando un proyecto crece, surge la necesidad de separar el código de la presentación, por variadas razones:

Consistencia y flexibilidad: La matriz básica de contenido de todo el sitio puede estar contenida en un sólo archivo, garantizando que la presentación de todo el sitio sea consistente.Además, los cambios en esta plantilla básica automáticamente se reflejan en la totalidad del sitio.
Separación de trabajo de los diseñadores y los desarrolladores: El código html puede ser trabajado con herramientas WYSWYG, en tanto que el código permanece seguro de cualquier alteración accidental.
Reutilización de la presentación: Una misma plantilla puede ser utilizada para presentar múltiples tipos de contenido. Por ejemplo, se puede crear un formato estándar de presentación de resultados tabulares, que puede ser utilizado para diversos objetivos.
Reutilización del contenido - código: El mismo contenido generado por un código puede ser presentado de muchas maneras distintas, solamente cambiando la plantilla. Incluso, con las herramientas adecuadas, se pueden obtener otros tipo de salida, tales como XML, Excel o PDF.
Reutilización de elementos: Se puede trabajar de manera modular, creando elementos que pueden ser reutilizados en diversos lugares con la simple adición de un texto específico

Es conveniente recordar que la separación de presentación y contenido también debe asegurarse, dentro de lo posible, en el código, separando las funciones encargadas de presentar información al usuario, recoger datos de formulario y las que procesan la información (relación con base de datos, cálculo numérico, etc.)

1.- Modelo de separación diseño - contenido

Aquí se propone un modelo básico de separación:

El usuario recibe de nuestro modelo una salida HTML, a través de su navegador. Esta aparece en un formato específico por acción de uno o más archivos CSS. Las zonas dinámicas del texto son generados por código PHP encargado de la presentación (uso de plantillas), el cual recibe la información necesaria tanto de las posibles entradas de los usuarios (por ej., replicación de los campos de un formulario en caso de error), como del código encargado de la lógica del proyecto. El código encargado de la lógica del negocio recibe las entradas de los usuarios, selecciona que presentación y que variables van a ser mostradas, a partir de los contenidos que se encuentran en el backend, que incluye elementos como la base de datos, archivos, etc., que soportan la información.

2.- Plantillas

2.1.- Introducción

Todos los sistemas de plantillas en PHP tienen un funcionamiento similar:

Se crea el objeto
Se carga el template HTML, ya sea este en un archivo o como una variable.
Se selecciona el bloque de HTML en el cual se trabajará
Se ingresan las variables dentro de la plantilla.
Se procesa el contenido.
Se obtiene el resultado, ya sea como una variable o presentándolo directamente en pantalla.

Entre los sistemas de plantillas más conocidos se encuentran:

Fast Templates: es una conversión de la librería de igual nombre de Perl. Presenta la desventaja de que resulta más lenta que otros sistemas, debido al uso de expresiones regulares POSIX en vez de Perl, y su limitada funcionalidad.
Smarty: Uno de los más famosos, si no el más, sistemas de plantillas para php. Su gran ventaja es que "compila" la plantilla en código php directo, el cual es cacheado y ejecutado directamente. Sus desventajas radican en la estrecha unión existente entre el código que se ocupa para presentar y la presentación (si se ocupan las variables de forma incorrecta, se puede caer la página completa) y la complejidad que presenta, haciendolo casi un lenguaje nuevo.

2.2.- PEAR::Template_IT

2.2.1.- Introducción

Para efectos de presentar un sistema de plantillas, he decido utilizar la clase PEAR_Template_IT por las siguientes razones.

Independencia total de código y presentación: cualquiera sea el tipo de variables, el único problema que pueda ocurrir es que no se presente un contenido.
Facilidad de uso: no más de 10 funciones bastan para manejar casi todo el sistema
Manejo de Bloques: Template_IT permite el manejo de bloques engarzados, los cuales, opcionalmente, pueden ser eliminados automáticamente si no se utilizan. Si se ocupa la clase derivada ITX, incluso se pueden reemplazar bloques en tiempo real.
Uso modular: la salida de una plantilla puede ser mostrada en forma directa, o puede utilizada como parte de una plantilla mayor.

2.2.2.- Uso de Template_IT.

HTML

En el HTML, se definen bloques y variables.

Archivo: personas.tpl.html

<html>
<head>
<link href="{CSS}" rel="stylesheet" type="text/css">
</head>
<body>
<h1>Listado de nombres</h1>
<p><b>Formato Css</b></p>
<FORM METHOD=GET ACTION="">
<INPUT TYPE="radio" NAME="css" value="personas1.css">personas1.css
<br>
<INPUT TYPE="radio" NAME="css" value="personas2.css">personas2.css
<p>
<INPUT TYPE="submit">
</p>
</FORM>
<table>
<tr>
<td>Nombre: <b>{NOMBRE}</b></td>
<td>Apellido: <b>{APELLIDO}</b></td>
<td>Telefonos:
<br />
<ul>
<li><b>{TELEFONO}</b></li>
</ul>
</td>
</tr>
</table>
</html>

CSS

Archivo personas1.css

body {
font-family:Arial;
}
table {
border:2px ridge black;
background:#eee;
border-collapse:collapse;
}
td {
border:1px solid #aaa;
padding:5px;
font-size:12pt;
}
h1 {
background:#0000cc;
font-weight:bold;
color:white;
padding:10px;
}

Archivo personas2.css

body {
font-family:Geneva;
color:white;
background:blue;
}
table {
border:2px ridge black;
background:#FFFF00;
border-collapse:collapse;
}
td {
color:black;
border:1px solid #aaa;
padding:5px;
font-size:12pt;
}
h1 {
background:#FFFF00;
font-weight:bold;
color:red;
padding:10px;
border:3px dashed #FFFF99;
}

PHP

Archivo: personas.php

<?php
require_once "HTML/Template/IT.php";
$aDatos = array (
"0" => array("nombre" => "Stig", "apellido" => "Bakken", "telefonos" => array("222222", "333333")),
"1" => array("nombre" => "Martin", "apellido" => "Jansen", "telefonos" => array("222222", "333333")),
"2" => array("nombre" => "Alexander", "apellido" => "Merz", "telefonos" => array())
);
$sCss=(isset($_REQUEST["css"])?$_REQUEST["css"]:"personas1.css"); // defino que css voy a usar
$tpl = new HTML_Template_IT("./"); // directorio donde se encuentran las plantillas
$tpl->loadTemplatefile("personas.tpl.html", true, true); // cargo la plantilla, borrando las variables y bloques sin usar
foreach($aDatos as $aPersona) {
// Asigno primero el bloque más interno
$tpl->setCurrentBlock("telefonos");
foreach($aPersona["telefonos"] as $sTelefono) {
$tpl->setVariable("TELEFONO", $sTelefono) ;
$tpl->parseCurrentBlock();
}
// después, el más externo
$tpl->setCurrentBlock("personas");
$tpl->setVariable("NOMBRE", $aPersona["nombre"]);
$tpl->setVariable("APELLIDO", $aPersona["apellido"]);
$tpl->parseCurrentBlock();
}
$tpl->setVariable("CSS",$sCss); // defino la variable css
// presento
$tpl->show();
?>

2.2.3.- Funciones.

Constructor: HTML_Template_IT([string $raiz= ""])

$tpl=new HTML_Template_IT("./templates");

Crea el objeto. $raiz es el directorio donde se encuentran las plantillas

boolean IntegratedTemplate::loadTemplatefile (string $archivo, boolean [$removerVariables = TRUE], boolean [$removerBloques= TRUE])

$tpl->loadTemplateFile("plantilla.html",true,false);

Carga la plantilla. $removerVariables permite borrar aquellas variables que no han sido utilizadas, en tanto que $removerBloques borra todo el código de un bloque si ninguna variable fue asignada

boolean IntegratedTemplate::setCurrentBlock ([string $bloque= "__global"])

$tpl->setCurrentBlock("personas");

Define el bloque en el cual las variables van a ser asignadas.

void IntegratedTemplate::setVariable (mixed $nombreVariable [, mixed $contenidoVariable= ""])

$tpl->setVariable("NOMBRE",$nombre);

Asigna un valor a una variable de la plantilla. Se puede utilizar un array en el primer argumento, siendo las claves los nombres de las variables y los valores los contenidos a asignar, o dos string, tal como se presenta en la definición de la función.

boolean IntegratedTemplate::touchBlock (string $block)

$tpl->touchBlock("mensaje");

Preserva un bloque vacío. Es especialmente util para mostrar mensajes predefinidos en el HTML, que no requieren una asignación de variables.

void IntegratedTemplate::parse ([string $bloque= "__global" ])

$tpl->parse();

Procesa el bloque definido por $bloque. Si no se define , se procesa toda la plantilla

void IntegratedTemplate::show ([string $bloque])

$tpl->show();

Muestra en pantalla el bloque definido por $bloque. Si este no se define, se muestra toda la plantilla.

string IntegratedTemplate::get ([string $block = "__global"])

$tpl->get();

Retorna en un string el bloque definido por $bloque. Si este no se define, se devuelve toda la plantilla.