Alters

Mostrando entradas con la etiqueta Tips. Mostrar todas las entradas
Mostrando entradas con la etiqueta Tips. Mostrar todas las entradas

Tips & Tricks: "cval" en lenguajes dinámicos

Buenas!

¿Dos entradas tan seguidas? Sí... os explico.

No escribía porque estaba empeñado en seguir con las mates en las siguientes entradas, pero como no tengo tiempo para nada, pues he decidido seguir con otras cosillas mientras saco algo de tiempo para las mates (ya que para hacer entradas de matemáticas necesito estar en casa, en mi despacho, donde tengo todos los apuntes).

Así que iré alternando entradas "normales" con entradas de proyectos, ¿ok?

Hoy toca hablar de "cval".

¿Os interesa?

¡Vamos allá!

Interludio

Buenas!

De nuevo por aquí...

Acabada está ya la primera parte de nuestro remote tools... la próxima será, por tanto, matemáticas (tema II, ya).

Pero antes, hay varias cosas que anunciar.

a) Se ve a la vista un nuevo blog personal
b) Surgieron varios temas durante la pasada sección que dejo en cola. A saber:
  b1) Criptología
  b2) Hacking wifi
  b3) Obtención de datos
c) He desarrollado una pequeña función JS/HTML para blogger (lo veremos más abajo)
d) Tengo un nuevo "juguete" del que escribir
e) Hay un pequeño cambio (¡por fin!)

Así que vamos por partes.

Blog personal:

Pues eso... estoy pensando en hacer un pequeño blog donde meter todos mis pensamientos y textos... a ver si podemos fomentar la escritura y el pensamiento (al menos lo intentaré). Os mantendré informados, y, como siempre, si me decido, lo encontraréis más allá de los confines de mi blog.

Temas:

Éstos - y otros que quizás salen durante este tiempo - los guardo en mi pila de ToDo's de mi despacho (tengo un corcho bien grande lleno de papelitos con ideas...)

Función JS/HTML:

Bien, he creado una pequeña galería fotográfica (pensada para el blog de cosplay). Es una de las cosas que blogger no acaba de hacer: al subir varias fotos cuesta cuadrarlas (salen casi siempre una abajo de otra, y cosas así), así que cuando tengo que poner varias queda bastante "cutre".

Así que me estrujé el cerebro, y como soy tan y tan escéptico, no quise coger galerías de terceras personas, sino más bien hacerme una para mi (que de eso va este blog, ¿no?, ¡DIY!).

Y me gustaría compartir con vosotros mi aporte. Por tanto, vamos a ir paso a paso para ver cómo funciona la pequeña galería.

Para empezar, dejo un esquema general de cómo está estructurada la galería:


Para la notación usaré la siguiente convención (ejemplos):

elemento.clase

elemento#id

elemento.clase subelemento#id:estado

El elemento "global" es "div.blogMarquee". Dentro tenemos tres elementos: "div.blogMarqueePhoto", "marquee#bm" y "div.blogMarqueeScroll".

Dentro del primero hay un elemento: "img#cp".

Dentro del segundo están las imágenes, es decir, un conjunto de "marquee#bm img".

Dentro del tercer elemento hay dos "div": "div#bMSL" y "div#bMSR"

El contenido de "marquee#bm" lo tendremos que introducir de manera manual, y será lo único que varíe de una entrada a otra (es decir, la estructura es siempre la misma, solo cambiaremos las imágenes).

Igual os preguntáis que es eso de "marquee". Para los que no hayan usado nunca este elemento NO ESTÁNDAR de HTML decir que es, de manera general, un div cuyo contenido se mueve. De este movimiento podemos definir:

  • Velocidad
  • Frecuencia de movimiento
  • Dirección de movimiento
  • Modo de movimiento
  • Cantidad de ciclos de movimiento
Cuando veamos el código explicaré un poco más cómo funciona.

Entonces, el funcionamiento es el siguente:

 - Las imágenes pasan por "marquee#bm".

 - Al pasar por encima de "marquee#bm", el movimiento cesa, y se muestran flechas de dirección ("div#bMSL" y "div#bMSR").

 - Al pulsar sobre una imagen, ésta se "colocará" en "div.blogMarqueePhoto img#cp".
 - Al pulsar sobre las flechas, podremos navegar por las imágenes (mientras se mantenga el ratón pulsado)

 - Al pulsar sobre "div.blogMarqueePhoto img#cp", la imagen se abrirá a tamaño real en una ventana nueva.

Aquí vemos dos cosas a destacar:

a) Hay un solapamiento de eventos javascript.
b) Tenemos que controlar cuándo el ratón está pulsado sobre "div#bMSL" y "div#bMSR".


Teniendo estas dos cosas en cuenta, vamos a pasar a ver la estructura HTML de nuestra galería:


<div class="blogMarquee">
<div class="blogMarqueePhoto">
                <img src="" alt="" width="400" height="300" id="cp" onclick="external(this);">
         </div>
<marquee id="bM" onmouseout="setAmount(this,5);" onmouseover="setAmount(this,0);" srcollamount="5">
<!-- imágenes aquí, en formato: width=320 height=240 -->
</marquee>
<div class="blogMarqueeScroll" onmouseover="setAmount(ge('bM'),0);">
<div id="bMSL" class="binv" onmousedown="action([ge('bM'),10,false],true);" onmouseup="action([ge('bM'),0,false],true);"> < </div>
<div id="bMSR" class="binv" onmousedown="action([ge('bM'),10,true],true);" onmouseup="action([ge('bM'),0,true],true);"> > </div>
</div>
<script type="text/javascript">addId(ge('bM'));</script>
</div>

(No me gusta que desfase el ancho del blog... pero así se ve mejor)

Como vemos, al final hay una llamada JavaScript. Ésta sirve para dar "id" a cada imagen dentro de marquee (ya veremos cómo, en un momento).

Antes de entrar en JS, vamos a estudiar un poco el HTML.

Como vemos, tenemos la estructura comentada, así que no pararemos ahí, sino que veremos el el elemento "marquee#bm".

Vemos que tiene "scrollamount=5". Esto indica la velocidad (5, en este caso) a la que se mueven los elementos. La dirección la veremos más adelante.

Ahora, vamos a por el JS (explicado con comentarios):


/**
 * variable global para el solapamiento
 */
var b_max=2;

/**
 * función action. 
 * Actúa como manejador de solapamiento de eventos entre "marquee#bm img:click" (a) y ("div#bMSL" | "div#bMSR") (b).
 * (a) lanza cphoto
 * (b) lanza move
 * Recibe dos parámetros:
 * @param v: array de parámetros de subllamada
 * @param f: valor de flag 
 */
function action(v,f){
b_max--;

if(f&&b_max>0){
move(v[0],v[1],v[2])
}else{
if(!f){
cphoto(v[0])
}
}

if(b_max==0||f){
b_max=2
}
}

/**
 * función ge.
 * Sinónimo de función "document.getElementById".
 * Recibe un parámetro y retorna un elemento:
 * @param e: id del elemento a retornar
 * @return: elemento cuyo id corresponde a "e"
 */
function ge(e){
return document.getElementById(e)
}

/**
 * función setAmount.
 * Ajusta la velocidad (scrollAmount) del elemento "e" a la velocidad "a".
 * Si la velocidad es 0, se muestran las flechas; en caso contrario se ocultan.
 * Recibe dos parámetros:
 * @param e: elemento a ajustar
 * @param a: velocidad
 */
function setAmount(e,a){
e.direction='left';
e.scrollAmount=a;

if(a==0){
ge('bMSL').className='bMSL';
ge('bMSR').className='bMSR'
}else{
ge('bMSL').className='binv';
ge('bMSR').className='binv'
}
}

/**
 * función addId.
 * Itera sobre el elemento con id "e", y sobre sus hijos, asigna id's de forma secuencial.
 * Del mismo modo, asigna un handler "click" a cada elemento.
 * Recibe un parámetro:
 * @param e: id del elemento a iterar
 */
function addId(e){
am=0;

for(i=0;i<e.childNodes.length;i++){
try{
e.childNodes[i].setAttribute('id','el'+am);
e.childNodes[i].setAttribute('onclick','action([this],false)');
am++
}catch(err){
}
}
}

/**
 * función move.
 * Mueve el elemento "e", en la dirección indicada por "t" a una velocidad "a".
 * Recibe tres parámetros:
 * @param e: elemento a mover
 * @param a: velocidad a fijar
 * @param t: dirección (true para derecha, false para izquierda)
 */
function move(e,a,t){
if(t){
e.direction='right'
}else{
e.direction='left'
}

e.scrollAmount=a
}

/**
 * función cphoto.
 * Muestra el elemento "e" sobre el elemento "#cp"
 * Recibe un parámetro:
 * @param e: elemento a mostrar sobre "#cp"
 */
function cphoto(e){
ge('cp').setAttribute('src',e.getAttribute('src'))
}

/**
 * función external.
 * Abre, en una ventana nueva, el elemento "e".
 * Recibe un parámetro:
 * @param e: elemento a abrir
 */
function external(e){
if(e.getAttribute('src')!=null){
window.open(e.getAttribute('src'))
}
}


Ahora, trataremos los dos asuntos:

a) Solapamiento: usamos este sistema para evitarlo.
b) Se generan dos eventos: onmousedown (cuando la tecla está pulsada) y onmouseup (cuando se suelta la tecla). En el primero, indicamos que se mueva hacia la dirección indicada; en el segundo, indicamos que pare.

Por último, falta indicar el estilo de nuestra nueva función:


img{
border:0;
}

.blogMarqueePhoto{
height:300px;
width:400px;
margin-left:auto;
margin-right:auto;
padding:10px;
}

.blogMarqueePhoto img{
width:400px;
height:300px;
border:1px solid #CCC;
 padding:0px
}

.blogMarqueePhoto img:hover{
cursor:pointer;
border-color:#FFF;
}

#bM{
height:245px;
}

.blogMarqueeScroll div{
top:-245px;
width:100px;
height:240px;
position:relative;
font-familt:arial;
font-size:180px;
color:#FFF;
line-height:240px;
opacity:.5;
-moz-opacity:.5;
filter:alpha(opacity=50);
background:#000;
}

.bMSL{
float:left;
}

.bMSR{
float:right;
}

.binv{
display:none;
}

#bM img{
 padding:0px;
}

#bM img:hover,.bMSR:hover,.bMSL:hover{
cursor:pointer;
}

Y ya solo falta rellenar con imágenes y colocarlo en una entrada.

Aquí podéis ver un ejemplo en funcionamiento. Un consejo: usad el ingenio para "importar" fotos desde facebook ;-)

"Juguete":


























Aquí está. Es una lámpara-tecla que compré en la feria del cómic de Barcelona. Mide unos 15cm de largo y se queda en mi despacho.

Ahora ya puedo decir que tengo la luz bajo control ;-)


Cambios:

Hace tiempo que voy detrás de graduarme en la universidad, pero lo que quería hacer estaba fuera de presupuesto (aunque tengo que admitir que de hacer algo relacionado 100% con la informática me gustaría hacerlo); un Bachelor en un centro adscrito a la universidad de Gales. Son tres años de carrera repleta de asignaturas con muy buena pinta...

Pero se va de presupuesto, así que vivía resignado.

Hasta que repasando los apuntes de mates me picó el gusanillo otra vez... así que ahí lo dejo:

¡Me voy a graduar en matemáticas!

Ya me he visto la carrera que voy a hacer y es buena, barata y a distancia. ¡Ale! así, entre curso y curso, podré hacer cursillos de informática (nunca hay que dejar de estudiar)... con este paso estoy más cerca de ser doctor... :-)

Desde luego no es un cambio que haya estado "esperando", más bien vino así de golpe... pero ya está bien.

Tips & Tricks: Overlay de eventos en JavaScript (II)

Buenas!

Vamos a ver rápidamente cómo tratar el solapamiento de eventos con AJAX...

Y es que AJAX puede resultar difícil de usar... ya que muchas veces se necesita de un elemento existente para que funcione bien...

Para empezar con los ejemplos, supondremos la siguiente llamada a función:

doAjax(url, query, getXML, divToChange, ev);

siendo los dos parámetros la URL completa; el tercer parámetro indica (con 1 o 0) si el resultado es o no XML.

El valor de divToChange es el id del div (o elemento) que queramos cambiar. Por otra parte, "ev" hace referencia a si el resultado ha de ser evaluado.

Pues bien, si "divToChange" hace referencia a un id inexistente, habrá un fallo en AJAX, por lo que siempre debemos comprobar que el elemento existe.

¿Y puede ser que no exista?

Pues, sí. Si hacemos varias cargas seguidas con AJAX/JS, puede ser que, al ser AJAX paralelo, intente acceder a un id que todavía no existe.

Para que esto no pase tenemos varias opciones:

a) Esperar un tiempo determinado
b) Evitar que AJAX sea paralelo

La primera opción tiene sus ventajas, pero posee un inconveniente que, para mí, es bastante obvio: dependiendo de la conexión que poseamos tardará un tiempo u otro.

Así, que, siempre que sea factible, al hacer varias cargas con AJAX deberíamos usar AJAX secucuencial.

Pero esto no es todo; si tenemos muchas llamadas AJAX seguidas, podemos hacer que AJAX pierda la petición y quedarnos sin resultado.

Es decir, suponed algo así:

for(i=0;i&lt;20;i++){
  doAajax(url,query,0,'contenido'+i,0);
}

Al ser un bucle sin más, nuestro Request perderá las peticiones (se solaparán), saliendo solo el resultado de la última.

Para no perder las peticiones podríamos esperar, como en el primer caso... pero ¿cuánto?

Pues... un tiempo indefinido, el justo para que la petición termine.

Para ello haremos uso de "setTimeout", cuyo uso es:

window.setTimeout(function(){sentencia_a_ejecutar}, tiempo);

En nuestro caso, debemos embeber la llamada. Es decir, pasaríamos el código anterior al siguiente:

for(i=0;i&lt;20;i++){
  doAjaxTimed(url,query,0,'contenido'+i,0);
}

function doAjaxTimed(url,query,getXML,divToChange,eval){
  window.setTimeout(function(){doAjax(url,query,getXML,divToChange,eval)}, t);
}

Y, SÍ, usamos "t", sin definir... con esto tardará lo que tenga que tardar... y los eventos no se solaparán.

Ahora vamos a otro caso de solapamiento de eventos:

Imaginad que queremos hacer el típico sistema de "select" para elegir país y ciudad. Al elegir un país cambian las ciudades mediante AJAX, y los países se cargan a posteriori con AJAX, de manera que:
<div class="decision">
  <select id="paises"><option value="0"<Seleccione</option></select>
  <select id="ciudades"><option value="0">Seleccione</option></select>
</div>
<script type="text/javascript"&gt;doAjax(url,query,0,"paises",0);//carga de paises</script>
Esto funciona a las mil maravillas para cargar las ciudades. Luego veremos el resto... pero ahora surge la duda: ¿Y si cargamos todo esto previamente con un AJAX?

Entonces, el script no se ejecuta, ya que no evaluamos ninguna sentencia. Tocará pensar algo...

¿Un timer? Pasa lo de siempre, debemos esperar...

He aquí una solución que me gusta más: un handler. Hacemos así:


<div class="decision">
  <select id="paises" onmouseover="carga();"><option value="0"<Seleccione</option></select>
  <select id="ciudades"><option value="0">Seleccione</option></select>
</div>

Y definimos en un fichero externo la función "carga()":

function carga(){
  if(document.getElementById('paises').options.length &gt; 1){
    return false;
  }

  doAjax(url,query,0,'paises',0);
  return false;
}

Y así, al tener el ratón por encima (antes de hacer click) se cargarán los países, sin que se note...

Y con esto podemos tener algo más controlado nuestro JS y AJAX.

Como final me gustaría añadir que estas entradas han sido algo raras y escasas, lo se... estoy demasiado liado con todo... a ver si los futuros cambios me sirven para ir a mejor!

Y como siempre,

¡Hasta la próxima!

Tips & Tricks: Overlay de Eventos en JavaScript

Buenas!

Se avecinan cambios por aquí... de momento todo queda tal como está, pero nunca se sabe...

En fin, vamos a ver un poco el tema del solapamiento de eventos en JavaScript.

Y es que mucho se ha de tener en cuenta a la hora de hacer una serie de funciones JavaScript, ya que, en ocasiones, puede que no suceda aquello que esperamos...

Y es que muchas veces lo que esperamos no es exactamente lo mismo que el navegador "interpreta"... y uno de estos casos es el solapamiento.

Hay varios tipos de solapamiento en JavaScript (realmente se le llama "solapamiento"?). Empezaremos con los básicos, y luego iremos con el tema de AJAX (JavaScript y XML Asíncronos).

¿Qué es el solapamiento?

Supongamos que tenemos esta estructura HTML:

<body>
  <div id="contenido">¡Haz Click!</div>
  <div id="contenedor"></div>
</body>

Y supongamos que queremos que al hacer click sobre el texto (el div, en realidad) se muestre un texto en "contenedor".

Podríamos hacer algo así:

<body>
  <div id="contenido" onclick="document.getElementById('contenedor').innerHTML = 'contenido';>¡Haz Click!</div>
  <div id="contenedor"></div>
</body>


Hay muchas maneras para hacer lo que queremos; podríamos, por ejemplo, crear un nuevo "div"  desde cero (de "la nada") y ponerle el texto, pero esto (me da la sensación) que sería más costoso.

Así, lo que hacemos en el código de arriba es añadir un handler (manejador) que saltará cuando hagamos click (en inglés "on click", y todo junto "onclick") es editar el html interno del elemento con id "contenedor".

Ahora vamos a dejarlo todo por separado, el JS por un sitio y el HTML por otro:

[div]
<script type="text/javascript">
function muestra(){
 document.getElementById('contenedor').innerHTML = 'contenido';
 return false;
}
</script>
<body>
  <div id="contenido" onclick="muestra();">¡Haz Click!</div>
  <div id="contenedor" ></div>
</body>


Esta función no tiene mucho sentido, pues es muy "particular". Así que la vamos a hacer de ámbito general para poder usarla por más de un elemento:

function muestra(elemento,texto){
  document.getElementById(elemento).innerHTML = texto;
  return false;
}

Bien, ahora nuestro handler sería:

onclick="muestra('contenedor', 'Esto es texto');"

Ahora podríamos hacer que cualquier "div" mostrase cualquier texto... es más general.

Sigamos haciendo nuestra "web"... ahora queremos que al pulsar otro elemento que no sea el div "contenido" el texto se oculte.

Para denotar "cualquier elemento", podemos usar el body mismo... ya que éste contiene todos los elementos.

<body onclick="document.getElementById('contenedor').innerHTML = '';"> ** nótese que son dos comillas simples, un ";" y unas comillas dobles **

o lo que es lo mismo:

<body onclick="muestra('contenedor', '');">

Y vamos a probar, y... ¡OH! nuestra "web" no funciona!

Como decía antes, sí funciona, solo que no como esperábamos.

¿Y qué ha pasado? Se han solapado dos eventos JavaScript.

Vamos a explicar esto un poco: imaginad una web como algo tridimensional... (como lo hace FireFox cuando editamos el diseño OTF :-P )

Entonces, nuestra "web" sería algo así (lo haría más bien hecho, pero es tarde y no me apetece mucho jugar con las perspectivas del CorelDraw X5...):



Supongamos que el cubo verde es "contenido", el rojo "contenedor" y lo azul es "body". Al hacer click en "contenido" saltará el evento que pone el texto, pero a su vez estamos haciendo click sobre "body", por lo que vuelve a saltar el evento, borrando el texto...

Es decir, así como los programas tienen una pila de llamadas donde se apilan las llamadas de funciones, para saber a qué dirección de memoria volver cuando acabe la función actual, JS tiene una pila eventos, de manera que parece que no funcione, pero en realidad va todo tan rápido que parece que no funcione...

Entonces, ¿Cómo hacemos para que funcione como queremos?

Analicemos la situación: al hacer click en "contenido", la función es llamada dos veces, mientras que en cualquier otro sitio solo es llamada una vez.

Por tanto, podemos definir las siguientes cláusulas:

 - Si la función se ha de mantener, se harán X clicks (2, en este caso)
 - Si no, se harán solo Y clicks (1 en este caso).

Bien, vamos a hacer un poco más grande nuestro JS:

<script type="text/javascript">
var max = 2;

function muestra(elemento, contenido, flag){
  max--;

  if(flag && max > 0){
   document.getElementById(elemento).innerHTML = '';
  }else{
    if(!flag){
        document.getElementById(elemento).innerHTML = contenido;
    }
  }

  if(max == 0 || flag){
    max = 2;
  }
}
</script>

Entonces, vamos a ver:

Primero hacemos un contador global, con valor 2. Luego hemos modificado la función para que acepte un parámetro adicional (booleano), para diferenciar la llamada del div de otras.

Entonces, en "contenido" haremos:

onclick="muestra('contenedor', 'texto', false);"

y en body:

onclick="muestra('contenedor', 'texto', true);"

Así, al hacer click sobre el div, pasará lo siguiente (suponiendo una primera ejecución):


  • Parámetros de entrada: "contenedor", "texto", "false"
  • max disminuye (max = 1)
  • Entra en el "else"
  • Se escribe el texto
  • No entra en el if
  • Devuelve la llamada a la pila
  • Llamada desde Body: "contenedor", "", "true"
  • max disminuye (max = 0)
  • Entra en el else
  • NO entra en el if (y por tanto no se modifica nada)
  • Entra en el segundo if (max = 2)
¡Bien!, el texto ya se queda. Si llamamos directamente desde body:

  • Parámetros: "contenedor", "texto", "true"
  • max disminuye (max = 1)
  • Entra en el if
  • Vacía el elemento
  • Entra en el segundo if (max = 2)
Y hemos evitado que, al solaparse, se produzca un borrado.

En la próxima entrada, veremos solapamientos con AJAX, y cómo solucionarlos de varias maneras.

Más adelante (la siguiente entrada a la de AJAX), entraremos en un mundo algo diferente: Matemáticas.

Ya veremos cómo acaba esta aventura.

Saludos, como siempre, y...

¡Hasta la próxima!


Diseño web: máxima compatibilidad: Tips & tricks


Buenas!

Llegamos a la última entrega de diseño web, la que seguramente sea la más extensa, y la que llevará más carga práctica.

Ya que será una entrega larga y con varios puntos, vuelvo a dejar el índice:

  1. Porcentajes
  2. Agrupar contenido en clases superiores
  3. Inherit, initial u omitir
  4. Contenido "centrado"
  5. Contenido que se "redimensiona"
    1. Fondo
    2. Contenido
  6. Jugar con la transparencia
  7. Efectos "misc"
    1. Scroll modificado
    2. Cajas con borde
    3. Modificar "select"
    4. Scroll "dependiente"
    5. Editar listas
  8. Div vs Span
  9. Compatibilizar con otros navegadores


  • Porcentajes
Los porcentajes pueden usarse en los atributos:
  • Top
  • Left
  • Width
  • Height
Sirven para indicar medidas porcentuales, es decir, no son medidas fijas (como lo sería "width: 25px;")
Al ser un porcentaje, cogerán el valor de su parent node (padre) como 100%.

Un ejemplo: supongamos la siguiente estructura:


<div class="clase1">
  <div class="sclase1">
    <div class="sclase2">
    </div>
    <div class="sclase3">
    </div>
  </div>
</div>

style:

.clase1{width:200px;height:200px;top:0px;left:0px;position:relative;}
.sclase1{width:50%;height:50%;top:20%;left:10%;position:relative;}
.sclase2{width:10%;height:100%;top:0;left:0;position:relative;}
.sclase3{width:40%;top:20px;position:relative;}

Bien, analicemos cómo quedaría:

Esta es la representación del navegador del ejemplo. A destacar dos aspectos: he añadido un "background-color" a cada clase; y he añadido "height:1px" a ".sclase3", para que se vea (ya que si no tiene los atributos "width" o "height", se adapta al contenido; y a contenido vacío, el div "desaparece").

Ahora veamos las medidas "reales" de cada div:









  • Clase1:
    • Width: 200px
    • Height: 200px
    • Top: 0px;
    • Left: 0px;
  • Sclase1:
    • Width: 100px (50% de parent - 200px -)
    • Height: 100px (50% de parent - 200px -)
    • Top: 40px (20% del largo - height - de parent - 200px -)
    • Left: 20px (10% del ancho - width - de parent - 200px -)
  • Sclase2:
    • Width: 10px (10% de parent - 100px -)
    • Height: 100px (100% de parent - 100px -)
    • Top: 0
    • Left: 0
  • Sclase3:
    • Width: 40px (40% de parent - 100px -)
    • Height: variable (1px en el ejemplo)
    • Top: 20px (20% de parent - 100px -), pero son en total 120 px partiendo desde la esquina superior izquierda de "Sclase1" (verde), ya que "Sclase2" ocupa todo el largo.
    • Left: 0

  • Agrupar contenido en clases superiores:
Esto es algo que tendremos que hacer a posteriori de que el CSS esté listo.

Esta medida da como resultado un CSS más pequeño y manejable, y se basa en el siguiente concepto:

"Si todos los hijos (child node) tienen una misma característica, ésta la puede implementar el padre (parent node) y que así, la hereden los hijos".

Es decir, si yo tengo algo así:


.clase1{top:0px;left:0px;}
.sclase1{font-family: arial;font-weight:700;}
.sclase2{background-color:blue;}
.sclase3{font-family:arial;}
.sclase4{font-family:arial;font-weight:700;}

<div class="clase1">
  <div class="sclase1">
     HOLA, SCLASE1
  </div>
  <div class="sclase2">
    <div class="sclase3">
       HOLA, SCLASE3
    </div>
    <div class="sclase4">
       HOLA, SCLASE4
    </div>
  </div>
</div>

El resultado sería el siguiente:

  • HOLA, SCLASE1: Texto en negrita, fuente arial
  • HOLA, SCLASE3: Texto normal, fondo azul, fuente arial
  • HOLA, SCLASE4: Texto en negrita, fondo azul, fuente arial.
Como vemos, todo el texto es en arial, por lo que podríamos añadir "font-family: arial" a "clase1" y eliminarlo de las demás. De este modo, todos los hijos (a no ser que se definiera una regla específica) heredarían la fuente de "clase1".

Con esto, ahorramos algo de espacio en el CSS, lo que lo hará más pequeño, y por tanto, más fácil de descargar para el navegador.

  • Inherit, Initial, Omitir
Inherit es un valor de atributo que equivale a "heredar" de un parent. En chrome, y versiones recientes de IE, dejar un atributo vacío equivale a hacer "inherit", si el parent tiene dicho atributo definido.

Initial es un valor de atributo que equivale a dejar el atributo a "por defecto" del navegador. Si, por decir algo, la fuente por defecto de nuestro navegador es "calibri", y dentro de un div con "font-family:arial" ponemos un div con "font-family:initial", el texto de éste será "calibri". El valor initial no es soportado por todos los navegadores (me refiero a algunas versiones de IE...)

Omitir el atributo en cuestión es dejar que el explorador decida: por lo general se sigue la siguiente norma: si el parent tiene el atributo, el child lo hereda; en caso contrario, se hace "initial". Aquí está la trampa, ya que cada navegador puede tener sus reglas de "omitir" y de "initial"...

Yo personalmente siempre intento definir el máximo de atributos (es decir, intentar dejar el mínimo de omitidos, omitiendo solamente los que quiero heredar), y evito usar "initial", ya que algunos exploradores no lo aceptan. Inherit también da problemas con IE, así que muchas veces no lo uso (por eso uso el omitir).

  • Contenido centrado
Siempre queremos centrar el contenido de nuestras webs... ahora os daré un par de "trucos" para que siempre quede todo bien centrado:

  • Contenido centrado: para ello, lo metemos todo en un div, y le añadimos las siguientes reglas de estilo:
    • margin-left: auto
    • margin-right: auto
    • margin-top: auto
  • Texto centrado verticalmente: para conseguirlo, modificaremos el interlineado, del siguiente modo:
    • line-height: **height del div**

  • Redimensionar contenido

Para hacer un fondo que se redimensiona, basta con hacer un par de cambios:

Creamos un div, fuera de cualquier otro, y dentro insertamos el fondo (como <img>). A la imagen le ponemos el siguiente estilo:

z-index:1;position:absolute;width:100%;height:100%

Y voliá!

Para que el contenido se redimensione, tenemos que jugar de nuevo con los porcentajes en nuestro div principal. El "inconveniente" es que al redimensionar el contenido, todo tendrá que cambiar de tamaño, y, por tanto, tendremos que ir siempre con porcentajes.

  • Jugar con la transparencia
La transparencia de un objeto es algo que se puede usar para crear efectos que hagan destacar unos elementos sobre otros. Por ejemplo, algo que está fuera de un rango, puede tener cierta transparencia para indicar que precisamente está fuera del rango.

El sistema recomendado para la transparencia es el siguiente:

filter:alpha(opacity=X);-moz-opacity: .X;opacity: .X

Donde X variará entre 0 (transparente) y 100 (opaco). Daros cuenta de que los dos últimos atributos van precedidos de "." (es decir, son del estilo 0.X, pero se puede omitir el "0").

El primer atributo es para que la transparencia se vea en IE; el segundo para mozilla; el último es de propósito general.

Hay que tener cuidado con la opacidad, ya que siempre se hereda (aunque se modifique el atributo en una child class). Por ello, siempre que queráis hacer un div con transparencia, y "dentro" (visualmente hablando) un div sin transparencia, lo que recomiendo es hacer los dos div "hermanos" (al mismo nivel), y ajustar las alturas para que de la sensación de que uno está dentro del otro.


  • Efectos "misc"
    • Scroll modificado
Se puede modificar el scroll a varios niveles: desde hacer que desaparezca forzosamente, hasta cambiar su aspecto.

Para el primer propósito, haremos uso de los atributos "overflow", y sus variantes "overflow-x" y "overflow-y". Los valores que pueden adoptar, son: hidden, visible, auto (initial, inherit).

Hidden esconde siempre el scroll; visible lo muestra siempre; auto deja que el explorador decida.

Para modificar el scroll, podemos recurrir a métodos propios de los navegadores, tales como -webkit-XXX, o modificar el body para IE. Otra manera es recurrir a jquery (supongo...).

    • Cajas con borde:
Podemos jugar con el borde de un div, para que enmarque información u otras funciones. Al atributo "border" se le pueden añadir sufijos, como "-bottom", "-top"... para especificar solo una parte del div. Con ello podemos conseguir líneas rectas.

    • Modificar Select:
El select es un input que no se puede cambiar mucho, pero podemos adaptarlo un poco para darle un estilo propio (sin necesidad de jquery).

Para ello, vamos a ver unos ejemplos:

Ejemplo 1: metemos el select dentro de un div, le cambiamos el fondo, le quitamos el borde y lo hacemos más pequeño:


Ejemplo 2: partiendo del ejemplo 1, hacemos el select más ancho que el div, de manera que la flecha desaparezca. A su vez, le ponemos un fondo al div, el cual sea una imagen de una flecha, y la colocamos al borde, simulando que es el botón. Al hacer click sobre la imagen (o cualquier otro punto) se desplegará el select.


    • Scroll dependiente
Para ello, usaremos un poco de JavaScript. Añadiendo el manejador "onresize" podemos controlar cuándo la página se redimensiona.

Dentro del manejador, podemos controlar el tamaño de la pantalla o de cierto div, y modificar el CSS para que el scroll pase, por ejemplo, de hidden a visible.


    • Editar listas
Para editar una lista desordenada (ul) no tenemos más que cambiar el estilo, de la siguiente manera:

.clase li {background: #FFFFFF url("imagen") 0 10px no-repeat;padding: 0 0 5px 22px;}

Analicemos: el background lo establecemos así: fondo blanco; con la imagen especificada en "url"; con una posición de 0,10 (la modificaremos sobre la marcha para que quede en la posición que queramos);la imagen no se repetirá, y tendrá una distancia al parent de 0,0,5,22 (esto también lo modificamos sobre la marcha).

Entonces, en nuestra "ul", le añadimos esta clase y ya lo tenemos.

  • Div vs Span
Como elementos contenedores, tenemos básicamente "div" y "span".

El primero es un bloque, mientras que el segundo es como una capa. Es decir, si un span tiene especificados un ancho y un alto, es muy probable que no los adopte; mientras que el div si (ya que es un bloque).

Yo personalmente no uso mucho los span; los uso especialmente para definir estilos de texto concretos (ya que el span no es un bloque). Para el resto, uso div.

  • Compatibilizar con otros navegadores

Esta es la parte más difícil de todas... cada navegador tiene sus propias reglas... por lo que a veces pensamos: "¿un CSS para cada navegador?"; podemos hacer eso, usando una función JS que determine qué navegador y versión está siendo usada... pero hay otras opciones, los llamados "hacks".

Ahora os explicaré una serie de reglas para crear reglas específicas para navegadores en concreto:

  • Para IE:
    • 8 y anterior: antes del ";" si añadimos "\9", dejaremos esa regla solo para estas versiones de IE. 
    • 7 y anterior: si ponemos un "*" antes de la regla, dejaremos esa regla solo para estas versiones.
    • 6 y anterior: si ponemos un "_" antes de la regla, dejaremos esa regla solo para estas versiones.
  • Para FF:
    • @-moz-document url-prefix(){}
      • Dentro de las llaves reescribiremos todas las clases que queramos cambiar solo para FF
  • Para Opera:
    • @media not screen and(1){}
      • Dentro de las llaves reescribiremos todas las clases que queramos cambiar solo para Opera
Es decir, si tenemos las siguientes clases:

.clase1{top:10px;_top:20px;*top:30px;top:40px\9;}
@-moz-document url-prefix(){.clase1{top:60px;}}
@media not screen and(1){.clase1{top:70px;}}

Para cada navegador se verían diferentes top, a saber:
  • Default: 10px
  • IE 8: 40px:
  • IE 7: 30px;
  • IE 6: 20px;
  • FF: 60px;
  • Opera: 70px;
Aplicando estas reglas, podemos hacer que el estilo esté todo en un archivo, y a la vez que sea específico para cada explorador.

Finalmente decir que quedan por explotar muchos aspectos de CSS, como hacer div girados X grados, los fondos con degradado, sombras... todo ello quizás lo expongo en una nueva sección de CSS, quién sabe (queda anotado en mi tablón!).

También comentar, a todo gurú del CSS que lea esto, que se que es posible que hayan cosas inexactas... sed indulgentes con mis conocimientos de CSS!

Supongo que esta será la última entrada del año en el blog... así que hagamos planes para el año que viene!


  • BuscaM!nas: lo siento, pero me veo obligado a dejar el proyecto de lado durante mucho mucho tiempo, ya que tengo un montón de proyectos por en medio que quiero acabar antes de ponerme de nuevo con esto.
  • Blog: Para el año que viene, intentaré ser más novedoso, e introducir paranoicos programas que hagan que os preguntéis qué me tomo para programar esas cosas... jeje... dejo una lista de temas que tengo pendientes de meter en el blog:
    • CSS avanzado
    • Optimización PHP
    • Uso de htaccess
    • HPL2
    • M!nas
      • MSAccess
      • COBOL
      • PHP
    • Varios (relleno) -> solo por si acaso...
    • PPHP -> paranoia en la que en breve me pondré a trabajar
    • COBOL avanzado
    • ASM
    • "Hacking"
      • cURL
      • VB.net
        • Procesos
        • FTP
        • HTTP
    • D - COBOL -> trabajando en ello
    • NS - NA -> trabajando en ello
    • Control remoto -> trabajando en ello
    • PS2Cloud -> trabajando en ello
    • Criptografía -> ampliando conocimientos cada día...
  • Personal: Como propósitos para el próximo año tengo (en cuanto a informática):
    • Adelantar mi libro (ya tengo uno terminado y registrado... ya os comentaré si me lo publican)
    • Quizás empezar uno nuevo
    • Adelantar mis proyectos (al menos PS2Cloud  y el control remoto tienen que estar para este año)
    • Adelantar la definición de mi "lenguaje de programación" (sí, estoy tan mal de la azotea que estoy creando un lenguaje de programación - bueno, estoy a un nivel teórico aún)
    • Hacer al menos 5 series de entradas en el blog
    • Terminar ISPA
    • Aprender algo de IA
    • Aprender sobre algún tema de Hardware
    • Aprender sobre algún tema de Software
    • Aprender sobre algún tema "misc" (vulnerabilidades, exploits, "bajo nivel" del S.O...)
Como veis, siempre trato de aprender cosas nuevas, y es que me gusta aprender cosas nuevas...

En fin, supongo que hasta el año que viene no volveré a escribir... así que

¡Hasta la próxima!