|
About
Community
Docs
Tools
Comparisons
Site Translations
|
|
Acerca de esta gu?a
|
La Gu?a del usuario de Velocity busca ayudar a los dise?adores de p?ginas y a
los proveedores de contenido a sentirse a gusto con Velocity y con la sint?xis
de su simple pero poderoso lenguaje de script, el Lenguaje de Plantillas de
Velocity (VTL por sus siglas en ingl?s). Muchos de los ejemplos de esta gu?a
muestran como usar Velocity para incluir contenidos din?micos en sitios web,
pero todos los ejemplos de VTL son igualmente aplicables a otras p?ginas y
plantillas.
Gracias por escoger Velocity!
|
|
|
?Qu? es Velocity?
|
Velocity es un motor de plantillas basado en Java. Le permite a los dise?adores
de p?ginas hacer referencia a m?todos definidos dentro del c?digo Java. Los
dise?adores Web pueden trabajar en paralelo con los programadores Java para
desarrollar sitios de acuerdo al modelo de Modelo-Vista-Controlador (MVC),
permitiendo que los dise?adores se concentren ?nicamente en crear un sitio bien
dise?ado y que los programadores se encarguen solamente de escribir c?digo de
primera calidad. Velocity separa el c?digo Java de las p?ginas Web, haciendo el
sitio m?s mantenible a largo plazo y presentando una alternativa viable a Java Server Pages (JSP) o PHP.
Velocity se puede utilizar para crear p?ginas web, SQL, PostScript y cualquier
otro tipo de salida de plantillas. Se puede utilizar como una aplicaci?n
independiente para generar c?digo fuente y reportes, o como un componente
integrado en otros sistemas. Cuando este completo Velocity proveer? servicios
para el conjunto de aplicaciones web de Turbine. Velocity+Turbine
proveer? un servicio de plantillas que facilitar? el desarrollo de aplicaciones
web de acuerdo a un verdadero modelo MVC.
|
|
|
?Qu? puede hacer Velocity por mi?
|
|
El Ejemplo de la tienda de Lodo
|
Suponga que usted es un dise?ador para una tienda en l?nea que se especializa
en vender lodo a la que llamaremos "La Tienda de Lodo en l?nea". Los negocios
est?n muy bien. Sus clientes ordenan diferentes tipos y cantidades de
lodo.
Ellos ingresan en su sitio con su nombre de usuario y su clave secreta, lo que
les permite ver sus ?rdenes y pedir m?s lodo. En estos momentos el Lodo
Terracota, que es muy popular, esta en oferta. Una minor?a de sus clientes
usualmente compra Lodo Rojo Brillante, que tambi?n esta en oferta, pero no es
tan popular y usualmente esta relegado al m?rgen de su p?gina web. La
informaci?n sobre cada cliente esta dentro de su base de datos por lo que surge
la pregunta: ?Por qu? no usar Velocity para enfocar las ofertas especiales para
los clientes que est?n m?s interesados en ciertas clases de lodo?
Velocity hace f?cil el personalizar las p?ginas para sus visitantes. Como un
dise?ador dentro de "El Cuarto de Lodo", usted quiere crear la p?gina que sus
usuarios ver?n despu?s de entrar a su sitio.
Usted se encuentra con los ingenieros de su compa??a, y todos acuerdan que
$cliente contendr? la informaci?n pertienente al cliente que est?
dentro de la p?gina en un momento dado, que $lodosEnOferta contendr?
todos los tipos de lodo que est?n en oferta hoy en d?a. Adem?s, el objeto
$flogger contendr? m?todos para ayudar con la promoci?n. Para la tarea
actual, solo se utilizar?n estas tres referencias. Recuerde, usted no necesita
preocuparse por como los ingenieros de software extraen la informaci?n
necesaria de la base de datos; s?lo tiene que saber que funciona. Esto le
permite a usted continuar con su trabajo a la vez que deja a los ingenieros
hacer el de ellos.
Usted podr?a incluir el siguiente c?digo VTL dentro de su p?gina:
 |
|
|
|
<HTML>
<BODY>
Hello $cliente.Nombre!
<table>
#foreach( $lodo in $lodosEnOferta )
#if ( $cliente.haComprado($lodo) )
<tr>
<td>
$flogger.obtenerPromocion( $lodo )
</td>
</tr>
#end
#end
</table>
|
|
|
|
|
Los detalles exactos de la sentencia foreach ser?n descritos en
profundidad pr?ximamente; lo que es importante es el impacto que este peque?o
script pueda tener en su sitio. Cuando un cliente con una debilidad por el
Lodo Rojo Brillante ingrese, si el Lodo Rojo Brillante esta en oferta, eso
ser? lo que el cliente ver?, de manera prominente. Si otro cliente, con una
historia larga de compras de Lodo Terracota ingresa, entonces para ?l la
noticia de un rebaja de Lodo Terracota estar? en un lugar muy importante. La
flexibilidad de Velocity es enorme y s?lo esta limitada por su creatividad.
En la referencia de VTL est?n documentados muchos otros elementos de Velocity
que, colectivamente le dan el poder y la flexibilidad que usted necesita para
hacer de su sitio en la red una presencia en la red. A medida que
usted se familiarice con estos elementos usted comenzar? a aprovechar el poder
de Velocity.
|
|
|
|
|
El Lenguaje de Plantillas de Velocity (VTL): Una Introducci?n
|
El Lenguaje de Plantillas de Velocity (VTL) fue creado para prover la
manera mas f?cil, simple y limpia de incorporar contenido din?mico
dentro de una p?gina web. Incluso un desarrollador de p?ginas web con
poca y ninguna experiencia puede r?pidamente ser capaz de utilizar VTL
para incluir contenido din?mico en un sitio web.
VTL usa referencias para incluir contenido din?mico dentro
de un sitio web. Una variable es un tipo de referencia que puede
referirse a algo definido dentro del c?digo Java o obtener su valor
de un enunciado VTL en la p?gina misma. A continuaci?n hay
un ejemplo de un enunciado VTL que se puede incluir en un documento
HTML:
Este enunciado VTL, como todos los enunciados VTL comienza con el
caracter # y contiene una directiva: set. Cuando
un visitante solicita su p?gina, el Motor de Plantillas de Velocity
buscar? dentro del contenido de su p?gina y encontrar? todos los
s?mbolos #, para luego determinar cu?les marcan el comienzo
de enunciados VTL y cu?les no tienen nada que ver con VTL.
El caracter # viene seguido por una directiva set.
La directiva set utiliza una expresi?n (encerrada entre
par?ntesis) -- una ecuaci?n que asigna un valor a una
variable.
La variable se encuentra en el lado derecho y el valor est? en el lado
izquierdo; los dos se encuentran separados por un signo igual
(=).
En el ejemplo en la parte superior, la variable es $a y el
valor es Velocity. Esta variable, al igual que todas las
referencias, comienza con el caracter $. Los valores siempre
se encuentran ente comillas; con Velocity no hay confusi?n acerca de
los tipos de datos, ya que solamente cadenas (informaci?n basada en
texto) pueden ser pasados a las variables.
La siguiente regla puede ser ?til para entender mejor como funciona
Velocity: Las Referencias comienzan con $ y se
utilizan para obtener algo. Las directivas comienzan con #
y se utilizan para hacer algo
En el ejemplo anterior #set se utiliz? para asignarle un valor
a una variable. La variable, $a, puede utilizarse dentro de la
plantilla para escribir la palabara "Velocity".
|
|
|
Referencias
|
Existen tres tipos de referencias en VTL: variables, propiedades y
m?todos. Como un dise?ador que utilizar VTL, usted y sus ingenieros
deben llegar a un acuerdo respecto a los nombres de las referencias
para que usted pueda utilizarlas correctamente en sus plantillas.
Todo lo que entra y sale de una referencia se trata como una cadena
de caracteres (un objeto String). Si existe un objeto que representa
$foo (por ejemplo, un objeto Integer), entonces Velocity
llamar? el m?todo .toString() de ese objeto para
convertirlo en una cadena de caracteres.
Variables
La notaci?n breve de una variable esta compuesta por un signo "$"
inicial seguido de un Identificador. Un identificador VTL
debe comenzar con un caracter alfab?tico (a .. z ? A .. Z). El resto
de los caracteres deb ser de alguno de los siguiente tipos:
- alfab?tico (a .. z, A .. Z)
- num?rico (0 .. 9)
- l?nea ("-")
- underscore ("_")
A continuaci?n hay algunos ejemplos de referencias v?lidas en VTL:
|
|
|
|
$foo
$lanzaLodo
$lanza-lodo
$lanza_lodo
$lanzaLodo1
|
|
|
|
|
Cuando VTL hace referencia una variable, po ejemplo, $foo,
la variable puede obtener su valor de una directiva set
dentro de la plantilla, o del c?digo Java. Por ejemplo, si la
variable de Java $foo tiene el valor bar en el
momento en que se solicita la plantilla, entonces bar
reemplaza todas las ocurrencias (o instancias) de $foo
dentro de la p?gina web. De manera alterna, si se incluye el
enunciado
La salida ser? la misma para todas las instancias de $foo
que se encuentren a continuaci?n es esta directiva.
Propiedades
El segundo sabor de referencias VTL son las propiedades; las
propiedades tienen un formato particular. La versi?n corta se
compone de un signo $ seguido de un identificador VTL,
seguido de un punto y de otro identificador VTL. A continuaci?n hay
ejemplos de referencias de propiedades v?lidas en VTL:
|
|
|
|
$cliente.Direccion
$compra.Total
|
|
|
|
|
Tome el primer ejemplo, $cliente.Direccion. Puede tener dos
significados. Puede significar, Busque en la tabla de hashing
identificada como cliente y devuelva el valor asociado con
la llave Direccion. Pero $customer.Address puede
tambi?n referirse a un m?todo (las referencias que se relacionan con
m?todos se discutir?n en la secci?n siguiente);
$customer.Address puede ser una manera corta de escribir
$customer.getAddress(). Cuando su p?gina sea solicitada
Velocity determinar? cu?l de las dos posibilidades tiene sentido, y
luego devolver? el valor apropiado.
Methods
Un m?todo esta definido dentro del c?digo de Java y es capaz de
hacer algo ?til, como desarrollar un c?lculo o llegar a una
decisi?n. Los m?todos son referencias compuestas de un signo "$"
inicial seguido en un identificador VTL, seguido de un Cuerpo de
M?todo VTL. Un cuerpo de m?todo VTL, a su vez esta formado
por un identificador VTL seguido por un par?ntesis izquierdo ("("),
seguido, opcionalmente, por una lista de par?metros, para terminar
en un par?ntesis derecho. A continuaci?n hay ejemplos de referencias
de m?todos v?lidas dentro de VTL:
|
|
|
|
$cliente.getDireccion()
$compra.getTotal()
$pagina.setTitulo( "My P?gina Principal" )
$persona.establecerAtributos( ["Extra?o", "Raro", "Excitado"] )
|
|
|
|
|
Los primeros dos ejemplos -- $cliente.getDireccion() y
$compra.getTotal() -- pueden parecer similares a aquellos
utilizados en la secci?n de propiedades, $cliente.Direccion
y $compra.Total. Si usted supuso que estos ejemplos est?n
relacionados de alguna manera, usted esta en lo cierto.
Las Propiedades VTL pueden utilizarse como notaci?n abreviada para
los m?todos de VTL. La propiedad $cliente.Direccion tiene
exactamente el mismo efecto que el m?todo
$cliente.getDireccion() (N?tese el uso de la palabra
inglesa get en lugar de la castellana obtener).
Generalmente es preferible utilizar una Propiedad si esta
disponible. La diferencia principal entre las propiedades y los
m?todos es que usted le puede dar una lista de par?metros a un
M?todo.
La notaci?n breve se puede utilizar en los M?todos siguientes:
|
|
|
|
$sol.getPlanetas()
$anhelido.getMugre()
$album.getFoto()
|
|
|
|
|
Podr?amos esperar que estos m?todos devolvieran los nombres de los
planetas que giran alrededor del sol, alimentaran un gusano de
tierra y extrajeran una foro de un album. Los siguientes M?todos
solo se pueden referenciar por medio de la notaci?n larga:
|
|
|
|
$sol.getPlaneta( ["Tierra", "Marte", "Neptuno"] )
## No es posible pasar una lista de par?metros con $sun.Planets
$sisifo.empujarPiedra()
## Si dijera $sisifo.piedra Velocity asumir?a $sisifo.pushPiedra()
$libro.setTitulo( "Homenaje a Colombia" )
## No se puede pasar un par?metro en la notaci?n abreviada.
|
|
|
|
|
Notaci?n Formal de
Referncias
La notaci?n abreviada para referencias fue utilizada en los ejemplos
anteriores, pero tambi?n existe una notaci?n formal para referencias,
que se demuestra a continuaci?n:
|
|
|
|
${lanzaLodo}
${cliente.Direccion}
${compra.getTotal()}
|
|
|
|
|
Casi en todos los casos usted utilizar? la notaci?n abreviada, pero
existen escenarios en los cuales la notaci?n formal se requiere para
procesar corectamente la plantilla.
Suponga que usted estuviera creando una frase en la que $vicio
se utilizar? como prefijo para el ajetivo de una clase. La idea es
permitir a algui?n escoger la palabra base para producir uno de los dos
siguientes resultados: "Juan es un pir?mano." ? "Juan es un
clept?mano.". En este caso la notaci?n abreviada no es apropiada;
considere el siguiente ejemplo:
Hay ambig?edad aqu?, y Velocity asume que $viciomano, no
$vicio, es el Identificador que usted quer?a utilizar. Al no
encontrar ning?n valor para $viciomano Velocity escribir?
simplemente $viciomano. Este problema se resueklve usando
notaci?n formal.
Ahora Velocity save que la referencia es $vicio y no
$viciomano. La notaci?n formal es ?til cuando las
referencias est?n ubicadas directamente al lado del texto dentro de
una plantilla.
Notaci?n de Referenias
Silenciosas
Cuando Velocity encuentra una referencia indefinida, su
comportamiento normal es es de escribir el nombre de la referencia.
Por ejemplo, suponga que la siguiente referencia aparece como parte
de una plantilla VTL.
|
|
|
|
<input type="text" name="correo" value="$correo"/>
|
|
|
|
|
Cuando el formulario se carga por primera vez la referencia
$correo no tiene valor, pero usted probablemente preferir?a
un texto en blanco a uno con el valor de "$correo". Usando la
notaci?n de referencias silenciosa se pasa por alto el
comportamiento normal de Velocity. Para lograr eso en lugar de
$correo en el VTL usted utilizar?a $!correo. Con
esta modificaci?n el ejemplo anterior quedar?a as?:
|
|
|
|
<input type="text" name="correo" value="$!correo"/>
|
|
|
|
|
Ahora cuando el formulario se carga por primera vez y $correo no
tenga valor una cadena vac?a se escribir? en lugar de "$correo".
La notaci?n formal y la silenciosa se puede usar juntas como se
muestra en el ejemplo siguiente:
|
|
|
|
<input type="text" name="correo" value="$!{correo}"/>
|
|
|
|
|
|
|
|
Directivas
|
Las Referencias le permiten a los dise?adores de plantillas generar
contenido din?mico para sitios web, mientras que las
directivas -- elementos de script f?ciles de usar que se
pueden usar para manipular de manera creativa la salida del c?digo
Java -- les permiten a los dise?adores realmente estar a cargo de la
apariencia y en contenido del sitio web.
#set
La directiva #set se utiliza para establecer el valor de una
referencia. El valor se puede asignar a una referencia de variable o
una referencia de propiedad, siempre entre par?ntesis, como se muestra
a continuaci?n:
|
|
|
|
#set( $primate = "mono" )
#set( $cliente.Comportamiento = $primate )
|
|
|
|
|
El lado izquierdo (LI) de la asignaci?n debe ser una referencia de
variable o una referencia de propiedad. El lado derecho (LD) puede
ser de alguno de los siguientes tipos:
- Referencia de Variable
- Constante de Cadena
- Referencia de Propiedad
- Referencia de M?todo
- Literal Num?rico
- Lista de elementos como arreglo
These examples demonstrate each of the aforementioned types:
|
|
|
|
#set( $mono = $pedro ) ## Referencia de Variable
#set( $mono.Amigo = "monica" ) ## Constante de Cadena
#set( $mono.Culpar = $casablanca.Fuga ) ## referencia de propiedad
#set( $mono.Plan = $doctor.llamar($web) ) ## referencia de m?todo
#set( $mono.Numero = 123 ) ##Literal Num?rico
#set( $mono.Decir = ["No", "es", $mi, "culpa"] ) ##Arreglo
|
|
|
|
|
NOTA: En el ?ltimo ejemplo los elementos definidos con el operador
[..] son accesibles usando los m?todos definidos en la clase ArrayList.
As?, por ejemplo, usted podr?a acceder el primer elemento del arreglo utilizando $mono.Decir.get(0), con lo que obtendr?a la palabra "No".
El lado derecho tambi?n puede ser una expresi?n aritm?tica sencilla:
|
|
|
|
#set( $value = $foo + 1 )
#set( $value = $bar - 1 )
#set( $value = $foo * $bar )
#set( $value = $foo / $bar )
|
|
|
|
|
Si el Lado Derecho es una propiedad o referencia de m?todo que se
eval?a como null, no ser? asignada al lado
izquierdo. No es posible remover una referencia existente del
contexto utilizando este mecanismo. Esto puede ser confuso para los
reci?n llegados a Velocity. Por ejemplo:
|
|
|
|
#set( $resultado = $consulta.criterio("nombre") )
El resultado de la primera consulta en $resultado
#set( $resultado = $consulta.criterio("direccion") )
El resultado de la segunda consulta es $resultado
|
|
|
|
|
Si $consulta.criterio("nombre") retorna la cadena "pedro",
y $consulta.criterio("direccion") retorna null, el
VTL anterio se mostrar?a de la siguiente manera:
|
|
|
|
El resultado de la primera consulta en pedro
El resultado de la primera consulta en pedro
|
|
|
|
|
Esto tiende a confundir a quines est?n comenzando, que construyen
ciclos #foreach que intentan hacer #set de una
referencia por medio de una propiedad o un m?todo e inmediatamente
eval?an la referencia con una directiva #if. Por ejemplo:
|
|
|
|
#set( $criterios = ["nombre", "direccion"] )
#foreach( $criterio in $criterios )
#set( $resultado = $consulta.criterios($criterio) )
#if( $result )
La consulta tuvo ?xito
#end
#end
|
|
|
|
|
En el ejemplo anterior, no ser?a inteligente confiar en la
evaluaci?n de $resultado para determinar si una consulta
tuvo ?xito. Despu?s de que $result ha sido agregado al
contexto (por medio de una directiva #set), no puede volver
a establecerse a null (quitarse del contexto). Los detalles
de las directivas #if y #foreach son cubiertos con
mayor detalle posteriormente en esta gu?a.
Una soluci?n para este problema puede ser predefinir
$resultado a false. Luego, si la llamada a
$consulta.criterios() falla, es posible verificar.
|
|
|
|
#set( $criterios = ["nombre", "direccion"] )
#foreach( $criterio in $criterios )
#set( $resultado = false )
#set( $resultado = $consulta.criterios($criterio) )
#if( $resultado )
La consulta tuvo ?xito
#end
#end
|
|
|
|
|
A diferencia de algunas de las otras directivas de Velocity, la
directiva #set no tiene un enunciado #end.
Cadenas de Caracteres
Cuando se utiliza la directiva #set, los literales de
cadena que est?n encerrados en comillas dobles ser?n evaluados y
mostrados en la plantilla, como se demuestra a continuaci?n:
|
|
|
|
#set( $directorioRaiz = "www" )
#set( $nombrePlantilla = "indice.vm" )
#set( $plantilla = "$directorioRaiz/$nombrePlantilla" )
$plantilla
|
|
|
|
|
La salida ser?:
Sin embargo, cuando la cadena de caracteres esta encerrada en
comillas sencillas, no ser? evaluada:
|
|
|
|
#set( $foo = "bar" )
$foo
#set( $blarg = '$foo' )
$blarg
|
|
|
|
|
Se muestra como:
Por defecto, la caracter?stica de las comillas sencillas para
mostrar texto sin evaluar esta disponible en Velocity; sin embargo
este valor por defecto se puede cambiar editando el archivo
velocity.properties de tal manera que
stringliterals.interpolate=false.
|
|
|
Sentencias If-Else
|
Condicionales
La directiva #if en Velocity permite que se incluya texto
dentro de la plantilla generada, con la condici?n de que el
enunciado condicional evalue a verdadero. Por ejemplo:
|
|
|
|
#if( $foo )
<strong>Velocity!</strong>
#end
|
|
|
|
|
La variable $foo se eval?a para determinar si es verdadera,
cosa que ocurrir? bajo una de dos circunstancias: (i) $foo
es un valor booleano (verdadero ? falso) que tiene un valor de
verdadero, ? (ii) el valor no es null. Recuerde que el
contexto de Velocity solamente contiene objetos, por lo que cuando
se dice 'booleano' se habla en realidad de la clase Boolean. Esto es
cierto incluso para los m?todos que devuelven un valor de tipo
boolean - la infraestructura de introspecci?n devolver?
un Boolean del mismo valor l?gico.
El contenido que se encuentra entre el enunciado #if y el
enunciado #end es lo que se escribe en la plantilla si la
evaluaci?n resulta en un valor verdadero. En este caso, si
$foo es verdadero, la salida ser?: "Velocity!". De manera
an?loga, si $foo tiene un valor null, o evalua a
falso, entonces el enunciado completo es falso y no se escribe nada.
Un elemento #elseif ? #else puede utilizarse junto
con una sentencia #if para indicar condiciones adicionales
o la labor por defecto. Note que el Motor de Plantillas de Velocity
parar? en la primera expresi?n que evalue a verdadero. En el ejemplo
siguiente suponga que $foo tiene un valor de 15 y
$bar tiene un valor de 6.
|
|
|
|
#if( $foo < 10 )
<strong>Vaya hac?a el Norte</strong>
#elseif( $foo == 10 )
<strong>Vaya hac?a el Este</strong>
#elseif( $bar == 6 )
<strong>Vaya al Sur</strong>
#else
<strong>Vaya al Oeste</strong>
#end
|
|
|
|
|
En este ejemplo, $foo es mayor que diez, por lo que las
dos primeras comparaciones fallan. A continuaci?n se compara
$bar con 6, como son iguales, la salida es Vaya al
Sur
Actualmente las comparaciones num?ricas de Velocity est?n
restringidas a los elementos de la clase Integer - cualquier otra
cosa evaluar? a falso. La ?nica excepci?n a esta regla es
la igualdad, '==', donde Velocity exige que los objetos a cada lado
del '==' sean de la misma clase.
Operadores
L?gicos y Relacionales
Velocity usa el operador de equivalencia para determinar las
relaciones entre las variables. A continuaci?n hay un ejemplo
sencillo para ilustrar como se utiliza el operador de igualdad.
|
|
|
|
#set ($foo = "?cido desoxiribonucleico")
#set ($bar = "?cido ribonucleico")
#if ($foo == $bar)
En este caso es claro que no son equivalentes por lo que....
In this case it's clear they aren't equivalent. So...
#else
No son equivalentes y esta ser? la salida.
#end
|
|
|
|
|
Velocity tiene tambi?n operadores l?gicos para el Y, el O y el NO
(AND, OR y NOT). Para mayor informaci?n vea la Gu?a de Referencia VTL.
A continuaci?n se encuentran ejemplos que demuestran la utilizaci?n
de los operadores l?gicos AND, OR y NOT.
|
|
|
|
## Y l?gico
#if( $foo && $bar )
<strong>Esto Y aquello</strong>
#end
|
|
|
|
|
La directiva #if() solamente evaluar? a verdadero si tanto
$foo como $bar son ciertos. Si $foo es
falso la expresi?n evaluar? a falso; $bar no ser? evaluada.
Si $foo es verdadero el Motor de Plantillas de Velocity
verificar? el valor de $bar; si $bar es cierto,
entonces toda la expresi?n es cierto y la salida es Esto Y
aquello. Si $bar es falso, entonces no habr?
ninguna salida porque toda la expresi?n es falsa.
El O l?gico trabaja de la misma manera, pero s?lo una de las
referencias debe evaluar a verdadero para que toda la expresi?n
evalue a verdadero. Considere el ejemplo siguiente.
|
|
|
|
## O l?gico
#if( $foo || $bar )
<strong>Esto O Aquello</strong>
#end
|
|
|
|
|
Si $foo es verdadero, el Motor de Plantillas de Velocity no
necesita consultar $bar,; sin importar si $bar es
cierto o falso, la expresi?n ser? cierta, y Esto O
Aquello ser? la salida. Si $foo es falso, en
cambio, es necesario verificar $bar. En este caso, si
$bar es falso, entonces la expresi?n es falsa y no se
escribe nada. De otro lado, si $bar es verdadero, entonces
toda la expresi?n es verdadera y el resultado es Esto O
Aquello
Con el operador l?gico NO, solo hay un argumento :
|
|
|
|
## NO l?gico
#if( !$foo )
<strong>eso NO</strong>
#end
|
|
|
|
|
Aqu? si $foo es cierto, entonces !$foo es falso, y
no se escribe nada. Por el contrario, si $foo es falso,
entonces !$foo ser? verdadero y eso NO
ser? escrito. Tenga cuidado de no confundir este operador con la
referencia sileciosa $!foo, que es algo completamente
distinto.
|
|
|
Ciclos Foreach
|
Ciclo Foreach
El elemento #foreach permite la construcci?n de ciclos. Por
ejemplo:
|
|
|
|
<ul>
#foreach( $producto in $todosProductos )
<li>$producto</li>
#end
</ul>
|
|
|
|
|
Este cilco #foreach hace que el objeto correspondiente a la
lista de $todosProductos sea iterado buscando todos los productos de
la lista. En cada iteraci?n del ciclo, el valor de
$todosProductos se asigna a la variable $producto.
El contenido de la variable $todosProductos es un Vector,
una tabla de Hashing (Hashtable) o un arreglo (Array). El valor
asignado a la variable $producto es un objeto Java y se
puede referenciar desde una variabkle como tal. Por ejemplo, si
$product fuera realmente un elemento de la clase Producto
en Java, su nombre se podr?a obtener referenciando el m?todo
$producto.Nombre (ie: $Product.getName()).
Ahora supongamos que $todosProductos es una tabla de
Hashing. Si usted quisiera recuperar los valores de las llaves de la
tabla de Hashing, al igual que los objetos dentro de esta, usted
podr?a utilizar c?digo como el siguiente:
|
|
|
|
<ul>
#foreach( $llave in $todosProductos.keySet() )
<li>Llave: $llave -> Valor: $todosProductos.get($llave)</li>
#end
</ul>
|
|
|
|
|
Velocity proporciona una manera sencilla de obtener el contador del
ciclo para que usted pueda hacer algo como lo siguiente:
|
|
|
|
<table>
#foreach( $cliente in $listaClientes )
<tr><td>$velocityCount</td><td>$cliente.Nombre</td></tr>
#end
</table>
|
|
|
|
|
El nombre por defecto para la referencia de la variable contador del
ciclo, que se especifica en el archivo
velocity.properties, es
$velocityCount. Por defecto el contador comienza en 1, pero esto se
puede hacer 0 o 1 en el archivo velocity.properties. A
continuaci?n se muestra el fragmento de este archivo que corresponde
al contador de ciclo (en ingl?s, tal como aparece en el archivo
original):
|
|
|
|
# Default name of the loop counter
# variable reference.
directive.foreach.counter.nombre = velocityCount
# Default starting value of the loop
# counter variable reference.
directive.foreach.counter.initial.value = 1
|
|
|
|
|
|
|
|
Include
|
El elemento de script #include le permite al dise?ador de
plantillas importar un archivo local, que despu?s es insertado en la
localizaci?n donde se encuentra la sentencia #include. Los
contenidos del archivo no se muestran por intermedio del motor de
plantillas por lo que si se hacen referencias dentro del archivo,
estas no ser?n reemplazadas. Por motivos de seguridad el archivo que
va a ser incluido debe encontrarse en el directorio indicado por la
propiedad TEMPLATE_ROOT.
El archivo al que se refiere la directiva #include se
encierra entre comillas. Si mas de un archivo ser? incluido, los
nombres de los archivos a incluir deben ir separados por comas.
|
|
|
|
#include( "uno.gif","dos.txt","tres.htm" )
|
|
|
|
|
El archivo a incluir no tiene que ser referenciado por nombre, de
hecho, muchas veces es preferible usar una variable, en lugar de un
nombre de archivo. Esto puede ser ?til para dirigir la salida de
acuerdo a criterios determinados cuando la solicitud de la p?gina es
enviada, es decir, que dependa de factores como los datos del
usuario que visita la p?gina, el momento del d?a, etc. A
continuaci?n se muestra un ejemplo en el que se usan tanto un nombre
como una variable.
|
|
|
|
#include( "greetings.txt", $seasonalstock )
|
|
|
|
|
|
|
|
Parse
|
El elemento de script #parse le permite al dise?adore de
plantillas importar un archivo local que contiene VTL. Velocity
procesar? el VTL y mostrar? la plantilla especificada.
Al igual que la directiva #include, #parse puede
utilizar una variable, en lugar de una plantilla. Todas las
plantillas a las que #parse se refiera deben incluirse bajo
TEMPLATE_ROOT. A diferencia de la directva #include,
#parse solo recibe un argumento.
Las plantillas de VTL puede tener sentencias #parse que se
refieran a plantillas que a su vez tengan sentencias
#parse. La l?nea parse_directive.maxdepth del
archivo velocity.properties, cuyo valor por defecto es
10, permite a los usuarios configurar el m?ximo n?mero de
referencias a #parse que pueden ocurrir desde una ?nica
plantilla. (Nota: Si la propiedad parse_directive.maxdepth
no esta dentro del archivo velocity.properties,
Velocity establecer? el valor por defecto en 10.) La recursi?n esta
permitida, por ejemplo, si la plantilla hacerfoo.vm
contiene las siguientes l?neas:
|
|
|
|
Cuenta Regresiva.
#set( $cuenta = 8 )
#parse( "parsefoo.vm" )
Listo hacerfoo.vm!
|
|
|
|
|
Hay una referencia a la plantilla parsefoo.vm, que
contiene el siguiente c?digo VTL:
|
|
|
|
$cuenta
#set( $cuenta = $cuenta - 1 )
#if( $cuenta > 0 )
#parse( "parsefoo.vm" )
#else
Listo parsefoo.vm!
#end
|
|
|
|
|
Despu?s de que se muestra "Cuenta Regresiva.", Velocity pasa por
parsefoo.vm, contando hac?a abajo desde 8. Cuando el
conteo llegue a 0, mostrar? el mensaje "Listo parsefoo.vm!". En este
punto Velocity volver? a dofoo.vm y escribir? el
mensaje "Listo hacerfoo.vm!".
|
|
|
Stop
|
El elemento de script #stop permite al dise?ador parar la
ejecuci?n del motor de plantillas y volver. Esto es ?til para prop?sitos
de correcci?n de errores.
| |
