Las variables en XLST se definen como:

<xsl:variable name="NOMBRE">VALOR</xsl:variable>

y luego se referencian como $NOMBRE

Por ejemplo si queremos una variable para el tamaño del texto podemos hacer:

<xsl:variable name="bodyTextSize">10pt</xsl:variable>

y luego referenciarla por ejemplo:

<font size="$bodyTextSize"><xsl:value-of select="@id"/></font>

Lo bueno de esto es que nos deja realizar operaciones sobre la variable:

<xsl:variable name="bodyTextSize">10</xsl:variable>

<font size="concat($bodyTextSize+2,'pt')"><xsl:value-of select="@id"/></font> //sacaria <font size="12pt">...

<font size="concat($bodyTextSize*2,'pt')"><xsl:value-of select="@id"/></font> //sacaria <font size="20pt">... 

También podemos definir las variables de cosas que cogemos del xml:

<xsl:variable name="id"><xsl:value-of select="@id"/></xsl:variable>

y usarlo donde mas nos convenga (el ejemplo real de fabricalDreams):

<xsl:for-each select="tournament/players/player">
<xsl:variable name="nombre"><xsl:value-of select="@name"/></xsl:variable>
<tr>
<td>
<xsl:value-of select="@name"/>
</td>
<td>
<xsl:value-of select="count(/tournament/games/game[@player1='$nombre' or @player2='$nombre'])"/>
</td>
<td>
<xsl:value-of select="count(/tournament/games/game[(@player1='$nombre' and @winner='1') or (@player2='$nombre' and @winner='2')])"/>
</td>
</tr>
</xsl:for-each>

EH ECHO UN POGRAMA EN JABA I ME DA HUN HERROR

LA PANTAYA NEGRA ME DIZE QE:

Syntax error on token “PUVLIC”

QES ESE HERROR?

GRACIA DE ANTEBRAZO HAMIJOS!

(posible post en forocoches)

Esta gran ida de peoza es gracias al último webcomic de Morghost: 169. Mi primer programa » Fantasmitas S.L..

(no se me ocurría otra forma de decirle lo buena que es la tira… GRACIAS HAMIJO!)

Cuando insertas un enlace en HTML su comportamiento por defecto es que se abra en la ventana actual, si queremos cambiar ese comportamiento, sólo hay que poner el atributo target=”_new” en el enlace y se nos abrirá en una ventana nueva:

<a href="http://www.xhiena.net" target="_new">Xhiena.net</a>

Lo mismo si estamos trabajando con frames, si queremos que un enlace abra la pagina en un frame especifico, en vez de _new ponemos el nombre del frame.

Todo eso esta muy bien, pero sólo cumple los estándares transicionales. Si estamos montando una pagina en con estandar estricto (que, personalmente pienso, es como se deberían hacer todas las webs) no podemos usar ese atributo de la etiqueta a.

Si lo requerimos y no hay otra forma de solucionarlo (si estas trabajando con frames quítalos, ganarás mucho en accesibilidad y usabilidad) se puede usar javascript para simular el atributo target.

La forma de hacerlo consiste en:

1. Cojer todos los enlaces.
2. Ver su atributo rel.
3. Cambiar su propiedad target.

1.- Cojer todos los enlaces

Esto se hace con la funcion getElementsByTagName(“tag”) de javascript, que nos devuelve un array con todos los elementos del documento con ese tag

var enlaces = document.getElementsByTagName("a");

2.- Ver su atributo rel.

para ver el atributo rel de un enlace se puede hacer con getAttribute(“atributo”)
enlace.getAttribute(“rel”)
3.- Cambiar su propiedad target.
eso se hace con .target

enlace .target="";

Una vez claras las cosas que hay que hacer y como se debe hacer, una función que cambiara todos los targets a lo rel podria ser:

function cambiarTargets(){
var enlaces= document.getElementsByTagName("a");
for (var i=0;i<enlaces.length; i++){
enlaces[i].target= enlaces[i].getAttribute("rel");
}
}

Se pueden hacer varias comprobaciones para que el javascript funcione perfectamente:

Que el cliente pueda usar la función:

if (!document.getElementsByTagName) return;

Que el enlace sea un enlace y no un ancla:
enlaces[i].getAttribute(“href”)!=”"
Sólo poner target si tienen un rel especifico:

if(enlaces[i].getAttribute("rel") == "contenido"){
enlaces[i].target = "contenido";
}

Aquí os pongo una función que cambia el tag de los enlaces que tengan rel = new

function cambiarTargets() {
if (!document.getElementsByTagName) return;
var enlaces= document.getElementsByTagName("a");
for (var i=0;i<enlaces.length; i++) {
var enlace = enlaces[i];
if (enlace.getAttribute("href") && enlace.getAttribute("rel") == "new"){
enlace.target = "_new";
}
}
}

Los programadores de verdad no necesitan comentarios — el código es obvio.

Los programadores de verdad no documentan. La documentación es para los idiotas que no pueden leer un volcado de memoria.

Los programadores de verdad pueden escribir bucles de 5 páginas sin confundirse.

Los programadores de verdad escriben su código en binario. O como mucho ensamblador.

Los programadores de verdad escriben código automodificable, especialmente si con ello consiguen ahorrar 20 nanosegundos en un bucle.

Los programadores de verdad no tienen miedo a usar GOTOs.

Los programadores de verdad procesan listas usando Fortran.

Los programadores de verdad desarrollan programas de Inteligencia Artificial en Fortran (si no puedes hacerlo en Fortran, hazlo en ensamblador).

Los programadores de verdad trabajan para la Agencia de Seguridad Nacional, decodificando transmisiones rusas.

Los programadores de verdad no comentan su código. Si fue difícil escribirlo, debería ser difícil entenderlo, y más difícil de modificar.

Los programadores de verdad no programan en BASIC. De hecho, ningún programador escribe en BASIC después de la pubertad.

Los programadores de verdad no programan en LISP. Sólo los idiotas escriben programas con más paréntesis que código.

Los programadores de verdad no usan FORTRAN. FORTRAN es para ingenieros débiles que usan calcetines blancos.

Los programadores de verdad no escriben especificaciones. De hecho, los usuarios deberían dar gracias de obtener algo de nosotros. Tienen suerte de que decidamos entregarles el programa.

Los programadores de verdad no leen manuales. El uso de manuales de referencia es para los novatos y los cobardes.

Los programadores de verdad no dibujan diagramas de flujo. Un diagrama de flujo no es más que documentación para analfabetos. Los cavernícolas dibujaban diagramas de flujo; y mira dónde están ahora.

Los programadores de verdad piensan que la programación estructurada es un invento de los comunistas.

Los programadores de verdad no creen en los plazos. Los supervisores establecen los plazos. Los jefes los firman. Los programadores asustadizos se esfuerzan en cumplirlos. Los programadores de verdad ignoran los plazos.

A los programadores de verdad no les gusta el concepto de programación en equipo. A menos que les asignen el puesto de programador jefe, claro.

Los programadores de verdad usan 5 dígitos para las fechas, y están preparados para el problema del año 10.000.

Los programadores de verdad no prueban el código, los usuarios se inventaron para eso.

Siento decir que no soy un programador de verdad xD

Visto en mundoGeek