LaTeX – Un marco básico para nuestras tablas

Objetivo: dotar de un marco simple a las tablas creadas en LaTeX.

En la entrega anterior aprendimos a generar tablas básicas en \LaTeX mediante el entorno tabular. Aunque cumplen perfectamente su función como elemento estructural, es natural que nos planteemos mejorar su presentación dotándolas, como primera opción, de un marco y líneas de división entre celdas.

Recordemos nuestra artista invitada:

\begin{tabular}{llcr}
pepino & tomate & berenjena & rábano \\
manzana & naranja & fresa & pera \\
\end{tabular}

latex-tablas-1

Comencemos trazando líneas separadoras horizontales, para lo que disponemos del comando \hline, que insertaremos justo en el lugar en el que queremos que aparezca cada línea.

\begin{tabular}{llcr}
\hline
pepino & tomate & berenjena & rábano  \\
\hline
manzana & naranja & fresa & pera \\
\hline
\end{tabular}

latex-tablas-marco-1

Para insertar una línea doble, podemos ejecutar \hline dos veces:

\begin{tabular}{llcr}
\hline
\hline
pepino & tomate & berenjena & rábano  \\
\hline
manzana & naranja & fresa & pera \\
\hline
\hline
\end{tabular}

latex-tablas-marco-2

El trazado vertical se especifica en la propia definición del entorno tabular, donde indicamos la justificación de cada columna, intercalando el símbolo de barra | en las posiciones en las que queremos que figure un separador vertical.

Por ejemplo, si queremos que nuestra tabla presente los bordes izquierdo y derecho, pero no entre medias, la declaración sería del siguiente modo:

\begin{tabular}{|llcr|}

El siguiente código dibuja el marco completo de la tabla, incluyendo todos los separadores interiores:

\begin{tabular}{|l|l|c|r|}
\hline
pepino & tomate & berenjena & rábano  \\
\hline
manzana & naranja & fresa & pera \\
\hline
\end{tabular}

latex-tablas-marco-3

Para finalizar, si en lugar de un símbolo de barra | escribimos dos ||, obtendremos un separador vertical doble. Dejemos, por ejemplo, dobles los verticales externos, pero simples los internos.

\begin{tabular}{||l|l|c|r||}
\hline
pepino & tomate & berenjena & rábano  \\
\hline
manzana & naranja & fresa & pera \\
\hline
\end{tabular}

latex-tablas-marco-4

Todo sencillo de momento, ¿no? Los conceptos no se atragantan cuando se ingieren en pequeños bocados.

Javier Montero Gabarró


LaTeX – Un marco básico para nuestras tablas


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Índice completo de artículos relacionados con \LaTeX.

LaTeX – Aproximación a las tablas

Objetivo: aprender la sintaxis básica para la creación de tablas en LaTeX.

Visto desde fuera, \LaTeX puede intimidar al profano que ocasionalmente asoma su cabeza en el mundillo. Desde dentro, más aún. Perdido entre centenares y centenares de paquetes y comandos, uno se siente siempre un principiante.

Pero lo verdaderamente cierto es que, con un puñado simple de conceptos y comandos bien aprendidos, podemos generar documentos en LaTeX con apariencia profesional desde el primer día. Gradualmente seguimos aprendiendo, colocando piezas en el puzzle, de modo que nuestro repertorio de técnicas crece, ofreciéndonos más flexibilidad y permitiéndonos lograr resultados más elaborados.

Ese es el modo como me gusta estudiar \LaTeX (y tantas otras cosas): pieza a pieza, técnica a técnica, asegurándome bien de practicar e interiorizar cada nuevo elemento antes de precipitarme buscando otro diferente.

Nos aproximaremos a la creación de tablas de ese modo. Comenzaremos por el uso más simple, la creación de una tabla básica con apenas un formato mínimo. Progresivamente exploraremos las distintas opciones de diseño y presentaremos algunos paquetes que extenderán nuestras posibilidades creativas.

Para crear una tabla disponemos del entorno tabular. Es decir, nuestra tabla quedará contenida en un bloque semejante a este:

\begin{tabular}
....
\end{tabular}

Como parámetro obligatorio (y por lo tanto, entre llaves) debemos indicar la justificación individual de cada columna. Si el contenido ha de aparecer justificado a la izquierda, escribimos la letra l (left); si la alineación es a la derecha una r (right); si lo que queremos es que el contenido esté centrado lo indicamos con la letra c (centered). Hay más posibilidades, pero de ellas hablaremos en otra ocasión.

Por ejemplo, imaginemos que queremos crear una tabla de 2 filas por 4 columnas en las que las dos primeras columnas se justifican a izquierda, la siguiente se centra y la última se alinéa a la derecha. La definición del entorno sería del siguiente modo:


\begin{tabular}{llcr}
....
\end{tabular}

Observa, una especificación de formato para cada columna.

Si quisiéramos que todas las celdas centrasen su contenido, repetiríamos simplemente el carácter c:

\begin{tabular}{cccc}
....
\end{tabular}

Para introducir los elementos de la tabla empezamos por la primera celda de la primera fila, yendo de columna en columna, separando cada elemento mediante el símbolo & e indicando el final de cada fila mediante una doble barra \\.

Por ejemplo, esta podría ser la primera fila en nuestra tabla de 2 x 4:

pepino & tomate & berenjena & rábano \\

Y estas las dos filas completas:

pepino & tomate & berenjena & rábano \\
manzana & naranja & fresa & pera \\

Dado que la segunda es la última fila, podríamos habernos ahorrado la doble barra final, aunque mantenerlas nos ayuda a mantener el código claro.

De modo que esta es nuestra tabla al completo:

\begin{tabular}{llcr}
pepino & tomate & berenjena & rábano \\
manzana & naranja & fresa & pera \\
\end{tabular}

latex-tablas-1

Aprecia la justificación que hemos definido en cada columna individual.

Si alguna celda no dispone de valor simplemente dejamos un blanco (o no escribimos nada) entre los & y & correspondientes:

\begin{tabular}{llcr}
pepino & tomate & & rábano \\
manzana & naranja & fresa & pera \\
\end{tabular}

latex-tablas-2

Si las que están en blanco son las últimas celdas de una fila, podemos ahorrarnos los separadores oportunos antes de la doble \\ final:

\begin{tabular}{llcr}
pepino & tomate  \\
manzana & naranja & fresa & pera \\
\end{tabular}

latex-tablas-3

Esto es todo lo que quería contarte hoy. Tienes a tu disposición una sencilla herramienta que puede resultarte muy útil a la hora de estructurar en tablas la información en un documento \LaTeX. Naturalmente, una vez aprendidos los rudimentos básicos, desearás ir más allá y hacer cosas como poner un marco al conjunto, por ejemplo. Veremos que es algo sumamente fácil, también.

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2014/06/latex-aproximacion-a-las-tablas/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Índice completo de artículos relacionados con \LaTeX.

MySQL: Eliminación de datos en una tabla

Objetivo: presentar el comando que permite la eliminación de datos de una tabla en MySQL.

En las dos últimas entregas aprendimos los fundamentos para insertar datos en tablas MySQL mediante el comando INSERT. Pero, una vez creados, ¿cómo los eliminamos?, ¿cómo los modificamos? En el artículo de hoy daremos respuesta a la primera pregunta.

Recuperemos la tabla fichajes y observemos su contenido:

mysql> SELECT * FROM fichajes;
+------------+----------+----------+
| fecha      | entrada  | salida   |
+------------+----------+----------+
| 2012-07-01 | 07:32:00 | 17:14:00 |
| 2012-07-02 | 08:15:00 | 17:57:00 |
| 2012-07-03 | 07:31:00 | 16:30:00 |
| 2012-07-04 | 07:25:00 | NULL     |
| 2012-07-05 | 07:45:00 | NULL     |
| 2012-07-06 | 07:30:00 | NULL     |
| 2012-07-07 | 07:15:00 | NULL     |
| 2012-07-08 | 08:01:00 | NULL     |
+------------+----------+----------+
8 rows in set (0.00 sec)

Suponte que queremos eliminar el registro del día 7 de julio. MySQL pone a nuestra disposición el comando DELETE, que usaremos del siguiente modo:

DELETE FROM tabla WHERE condición

Algo que podríamos leer como “borra de la tabla indicada aquello que cumpla cierta condición”.

¿Cuál es la condición que determinará que se borre el registro? Que el campo fecha tenga por valor ‘2012-07-07’. Así pues:

mysql> DELETE FROM fichajes WHERE fecha = '2012-07-07';
Query OK, 1 row affected (0.14 sec)

Constatemos que el comando ha cumplido su misión:

mysql> SELECT * FROM fichajes;
+------------+----------+----------+
| fecha      | entrada  | salida   |
+------------+----------+----------+
| 2012-07-01 | 07:32:00 | 17:14:00 |
| 2012-07-02 | 08:15:00 | 17:57:00 |
| 2012-07-03 | 07:31:00 | 16:30:00 |
| 2012-07-04 | 07:25:00 | NULL     |
| 2012-07-05 | 07:45:00 | NULL     |
| 2012-07-06 | 07:30:00 | NULL     |
| 2012-07-08 | 08:01:00 | NULL     |
+------------+----------+----------+
7 rows in set (0.00 sec)

Como puedes comprobar, el registro de fecha 7 de julio ha sido eliminado de la tabla.

Es necesario que extremes la precaución siempre que uses DELETE. Si la condición de la claúsula WHERE se cumple en varios registros, serán eliminados todos ellos.

Por eso, una buena práctica consiste en ejecutar previamente un comando SELECT, bajo los mismos términos, para obtener el listado de registros afectados.

Imagina, por ejemplo, que queremos eliminar de la tabla fichajes los registros cuya hora de entrada sea superior o igual a las 7:45. Antes de proceder con el comando DELETE es interesante asegurarnos de que los registros que se van a borrar son precisamente los que queremos:

mysql> SELECT * FROM fichajes WHERE entrada >= '07:45:00';
+------------+----------+----------+
| fecha      | entrada  | salida   |
+------------+----------+----------+
| 2012-07-02 | 08:15:00 | 17:57:00 |
| 2012-07-05 | 07:45:00 | NULL     |
| 2012-07-08 | 08:01:00 | NULL     |
+------------+----------+----------+
3 rows in set (0.00 sec)

Observa el uso de la claúsula WHERE también en la sentencia SELECT para filtrar las filas a presentar.

Comprobamos que, efectivamente, esos son los únicos registros que deseamos eliminar. Podemos lanzar ya DELETE sin miedo:

mysql> DELETE FROM fichajes WHERE entrada >= '07:45:00';
Query OK, 3 rows affected (0.03 sec)

Así es como queda nuestra tabla tras esta eliminación:

mysql> SELECT * FROM fichajes;
+------------+----------+----------+
| fecha      | entrada  | salida   |
+------------+----------+----------+
| 2012-07-01 | 07:32:00 | 17:14:00 |
| 2012-07-03 | 07:31:00 | 16:30:00 |
| 2012-07-04 | 07:25:00 | NULL     |
| 2012-07-06 | 07:30:00 | NULL     |
+------------+----------+----------+
4 rows in set (0.00 sec)

¿Y si quisiéramos eliminar todos los registros de la tabla fichajes?

Exactamente igual, con la salvedad de que sobra el WHERE, pues no hay nada que filtrar, ya que no se salvará ninguno:

mysql> DELETE FROM fichajes;
Query OK, 4 rows affected (0.04 sec)

Así de simple.

mysql> SELECT * FROM fichajes;
Empty set (0.01 sec)

Nada que presentar, la tabla está más pelada que el ropero de Tarzán.

Utilizaremos la claúsula WHERE condición en numerosos contextos. Considera el artículo de hoy como un pequeño barniz…

Javier Montero Gabarró


MySQL: Eliminación de datos en una tabla


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


¡Accede al índice con todos los artículos sobre MySQL!

MySQL – Creando la primera tabla

Ha llegado el momento, al fin, de un acontecimiento trascendental y que difícilmente se olvida: la creación de la primera tabla en MySQL.

Ya sabes que la información se organiza en estructuras denominadas tablas. Conceptualmente son como cualquier tipo de tabla con datos que ya conoces, con sus filas y columnas. En el mundo de las bases de datos a las columnas también se las conoce como campos, y a las filas como registros.

El diseño correcto de las tablas y de las relaciones entre ellas es una habilidad crítica en el mundo de las bases de datos relacionales. Factores como la agilidad, usabilidad o la integridad de una base de datos están supeditados a unas tablas bien diseñadas.

Una base de datos no es más que un modelo que trata de abstraer una realidad determinada. Todo el tiempo que inviertas planificando, analizando y diseñando ese modelo será siempre poco.

Dejaremos las cuestiones de optimización de diseño para cuando hayamos presentado todas las herramientas. Vamos a crear hoy una simple tabla para almacenar datos personales. En el camino presentaremos el tipo de datos VARCHAR y aprenderemos a mostrar la estructura de nuestra tabla recién creada.

Para crear una tabla primero, obviamente, deberás haber creado la base de datos, el contenedor al cual pertenece (con el comando CREATE DATABASE que vimos en una entrega anterior). Pero no basta con que la base de datos exista; además, deberás indicar, con el comando USE, que vas a trabajar con esa base de datos en particular.

Vamos a crear una tabla, denominada personas, perteneciente a la base de datos contactos, y que contendrá tres campos: el nombre, los apellidos y un posible alias con el que podremos referirnos opcionalmente a esa persona.

Lo primero que debes determinar es el tipo de datos de cada campo y su tamaño máximo. En este sencillo ejemplo estamos ante tres campos que contendrán texto. Estimamos que para indicar el nombre nos baste con 20 caracteres, 40 para los apellidos y otros 20 para el alias.

Existe un tipo de datos en MySQL perfecto para este tipo de contenidos: VARCHAR.

VARCHAR permite campos de texto de hasta 65.532 caracteres (255 si estás usando una versión de MySQL anterior a la 5.0.3). Esos son muchos caracteres. Y lo bueno del tipo VARCHAR es que sólo va ocupar lo que realmente esté ocupando cada valor (salvo uno o dos bytes más que emplea para almacenar la longitud exacta).

No esperemos más, metámosle mano a la tabla ya.

Si la base de datos contactos no existe, créala con

CREATE DATABASE contactos;

O emplea cualquier otra que prefieras, da igual. Lo importante aquí es que aprendas ahora el comando para crear tablas, no resolver ninguna necesidad en concreto.

Indica que vas a operar sobre contactos con

USE contactos;

El comando para crear una tabla no podía ser otro: CREATE TABLE. Obsérvalo detalladamente:

mysql> CREATE TABLE personas
    -> (
    -> nombre VARCHAR(20),
    -> apellidos VARCHAR(40),
    -> alias VARCHAR(20)
    -> );
Query OK, 0 rows affected (0.04 sec)

Un comando no termina hasta que no se incluye el punto y coma final. Por lo tanto, el efecto de ir pulsando ENTER es que simplemente abre una nueva línea (señalizada con el cursor ->), hecho que utilizo para dejar el comando con un aspecto más presentable que si lo hubiera escrito todo contiguo en una sola línea:

mysql> CREATE TABLE personas(nombre VARCHAR(20), apellidos VARCHAR(40), alias VARCHAR(20));

Es importante que observes algunos detalles…

En primer lugar, fíjate como todo el conjunto aparece entre un par de paréntesis.

Por otro lado, observa el uso de VARCHAR después del nombre del campo, indicando entre paréntesis el tamaño máximo que ocupará.

Date cuenta, también, de que cada pareja nombre – tipo, viene separada de la siguiente por una coma.

Y, finalmente, no te olvides del punto y coma final, tras el paréntesis de cierre de CREATE TABLE, indicando que tu comando está visto para sentencia.

Ya está la tabla creada. Pero ahora, ¿cómo visualizamos su estructura?

El comando MySQL para conocer la estructura de una tabla es DESCRIBE, que puedes acortar con DESC.

mysql> DESC personas;
+-----------+-------------+------+-----+---------+-------+
| Field     | Type        | Null | Key | Default | Extra |
+-----------+-------------+------+-----+---------+-------+
| nombre    | varchar(20) | YES  |     | NULL    |       |
| apellidos | varchar(40) | YES  |     | NULL    |       |
| alias     | varchar(20) | YES  |     | NULL    |       |
+-----------+-------------+------+-----+---------+-------+
3 rows in set (0.00 sec)

¡Qué buena pinta tiene esto! Vemos el nombre del campo y su tipo. El YES, en la columna Null, indica que puede aceptar valores nulos (es decir, que dejes el contenido en blanco). El NULL en Default corresponde al valor por defecto: si a la hora de introducir datos no especificas un contenido se sobreentiende que dejas el campo en blanco. Ya hablaremos de esto, así como de las otras columnas que aparecen, a su debido momento.

Y esto es todo por hoy, que no es poco. Puedes entretenerte creando otras tablas para afianzar estos conocimientos. O puedes usar alguna de las bases de datos que incluye ya MySQL y hurgar entre la estructura de sus tablas con el comando DESCRIBE.

Javier Montero Gabarró


MySQL – Creando la primera tabla


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta

Tablas HTML con celdas irregulares – 3 de 3

En las dos últimas entregas presentamos los atributos colspan y rowspan , que nos permitían combinar celdas contiguas en una tabla. Quiero proponerte ahora un ejercicio avanzado que estoy seguro sabrás resolver si has comprendido lo hasta ahora explicado.

Se trata de escribir el código HTML que genera la siguiente tabla:

Tómate el tiempo que necesites para resolver el problema.

¿Atascado en alguna parte? ¿Algún concepto un tanto difuso aún? Si, a pesar de todo, te cuesta hallar la solución, sigue leyendo, entonces…

Recordemos el procedimiento para diseñar este tipo de tablas sin problemas:

1) Procesar los elementos fila a fila, comenzando por la primera, y de izquierda a derecha, es decir, del mismo modo que realizamos la lectura de un libro.

2) No debemos incluir celdas que pertenezcan a una extensión ya iniciada en una definición anterior.

Según esto, en la primera fila nos encontraríamos con tres definiciones de datos: la primera (alfa) extiende la celda tres columnas horizontalmente, la segunda (bravo) es normal y la tercera (charlie) extiende dos filas verticalmente.

<tr>
  <td colspan="3">alfa</td><td>bravo</td><td rowspan="2">charlie</td>
</tr>

La segunda fila contiene cuatro definiciones, pues su última celda pertenece a una extensión que se realizó en la primera fila.

<tr>
  <td>delta</td><td>echo</td><td>foxtrot</td><td>golf</td>
</tr>

La tercera fila es suculenta: contiene tres definiciones y la segunda (india) es peculiar, pues contiene una expansión tanto horizontal como vertical.

<tr>
  <td>hotel</td><td colspan="3" rowspan="2">india</td><td>juliet</td>
</tr>

Presta mucha atención a cómo hemos incluido, dentro de la misma etiqueta td, tanto el atributo colspan como rowspan.

En la cuarta fila debemos definir sólo dos elementos, uno al principio y otro al final, pues las tres hipotéticas celdas centrales pertenecen a una extensión que se inició en la fila anterior.

<tr>
  <td>kilo</td><td>lima</td>
</tr>

Por último, la quinta fila es completamente normal, con sus cinco definiciones de datos, una para cada columna. Me he permitido incluirla en el diseño para que se reflejen bien los límites de cada columna y se dimensionen con claridad todas las extensiones anteriores.

<tr>
  <td>mike</td><td>november</td><td>oscar</td><td>papa</td><td>quebec</td>
</tr>

Este es el código completo del diseño:

<table border="1">
<tr>
  <td colspan="3">alfa</td><td>bravo</td><td rowspan="2">charlie</td>
</tr>
<tr>
  <td>delta</td><td>echo</td><td>foxtrot</td><td>golf</td>
</tr>
<tr>
  <td>hotel</td><td colspan="3" rowspan="2">india</td><td>juliet</td>
</tr>
<tr>
  <td>kilo</td><td>lima</td>
</tr>
<tr>
  <td>mike</td><td>november</td><td>oscar</td><td>papa</td><td>quebec</td>
</tr>
</table>

Y, colorín colorado, esta tabla se ha acabado…

Javier Montero Gabarró


Tablas HTML con celdas irregulares – 3 de 3


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta

Tablas HTML con celdas irregulares – 2 de 3

Ayer comenzamos el tratamiento de las tablas irregulares en HTML y aprendimos el modo de extender las celdas horizontalmente utilizando el atributo colspan. Aplicando la misma aproximación por filas que tan bien nos ha funcionado hasta el momento, aprenderemos cómo extender celdas verticalmente.

Esta es la tabla que diseñaremos hoy:

Esto es como jugar a los barquitos. Comencemos por la primera fila:

Las tres primeras celdas son normales:

<td>manzana</td><td>pera</td><td>fresa</td>

La cuarta es la que presenta la extensión vertical. El atributo con el que la indicaremos es rowspan, tomando como valor el número total de celdas que ocupa la extensión.

<td rowspan="3">naranja</td>

La fila primera es, por lo tanto:

<tr>
  <td>manzana</td><td>pera</td><td>fresa</td><td rowspan="3">naranja</td>
</tr>

Presta mucha atención ahora a como creamos la segunda fila. La idea es la siguiente: sólo contabilizaremos aquellas celdas que no formen parte de una extensión ya comenzada. Es decir, únicamente aparecerán las normales o las que comiencen una extensión.

Aplicando este principio, la definición de las celdas es sencilla. La primera celda es normal:

<td>melón</td>

La segunda comienza una extensión, por lo que debe figurar (con su correspondiente valor de rowspan):

<td rowspan="2">sandía</td>

La tercera celda vuelve a ser normal:

<td>pomelo</td>

La cuarta celda forma parte de una extensión ya iniciada, por lo que no se indica nada, quedando la fila completa definitivamente sólo con tres definiciones <td>:

<tr>
  <td>melón</td><td rowspan="2">sandía</td><td>pomelo</td>
</tr>

En la tercera fila aparecen dos extensiones ya iniciadas, por lo que sólo figurarán dos definiciones <td> (4 – 2 = 2):

<tr>
  <td>cereza</td><td>kiwi</td>
</tr>

Finalmente, la última fila es completamente normal:

<tr>
  <td>uva</td><td>ciruela</td><td>níspero</td><td>granada</td>
</tr>

Y nuestra tabla al completo queda definida, entonces, del siguiente modo:

<table border="1">
<tr>
  <td>manzana</td><td>pera</td><td>fresa</td><td rowspan="3">naranja</td>
</tr>
<tr>
  <td>melón</td><td rowspan="2">sandía</td><td>pomelo</td>
</tr>
<tr>
  <td>cereza</td><td>kiwi</td>
</tr>
<tr>
  <td>uva</td><td>ciruela</td><td>níspero</td><td>granada</td>
</tr>
</table>

En la próxima y última entrega dedicada a las tablas irregulares contemplaremos el caso en que haya celdas que se extienden a la vez en sentido horizontal y vertical. Con lo explicado en estos dos artículos debería bastarte para resolver el problema por ti mismo y te invito a comprobarlo. No obstante, daremos la solución detallada.

Tocado – Tocado –

La próxima será Hundido.

Javier Montero Gabarró


Tablas HTML con celdas irregulares – 2 de 3


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta

Tablas HTML con celdas irregulares – 1 de 3

Continuamos el estudio de las tablas en HTML rizando el rizo. En este artículo y en los dos siguientes aprenderemos a diseñar tablas que presentan celdas irregulares, resultado de combinar celdas contiguas entre sí.

Echa un vistazo a la tabla siguiente y verás de qué estoy hablando.

Observa como, en la primera fila, la segunda celda tiene una anchura de dos columnas. En la tercera fila, la primera celda tiene una anchura de tres columnas y la segunda de dos.

Como siempre, nos aproximaremos al diseño fila a fila. Comencemos por la primera.

La primera celda es normal, por lo que la definiremos exactamente del modo que explicamos en los artículos anteriores:

<td>manzana</td>

La siguiente celda tiene trampa, pues presenta una anchura de dos columnas. Existe un atributo para especificar el ancho de una celda en columnas: colspan.

Puesto que la celda ocupa dos columnas, este atributo tomará 2 como valor:

<td colspan="2">pera</td>

Las dos celdas siguientes son normales:

<td>fresa</td><td>naranja</td>

La primera fila queda, entonces, definida del siguiente modo:

<tr>
  <td>manzana</td><td colspan="2">pera</td><td>fresa</td><td>naranja</td>
</tr>

Sólo hay cuatro pares <td>...</td>, en lugar de 5, ya que hay una celda ocupa lo de dos.

La segunda fila no presenta misterio alguno:

<tr>
  <td>melón</td><td>sandía</td><td>pomelo</td><td>cereza</td><td>granada</td>
</tr>

Finalmente, la tercera tiene dos celdas irregulares, la primera de tres columnas de ancho:

<td colspan="3">melocotón</td>

Y la segunda de dos:

<td colspan="2">kiwi</td>

Ya tenemos, entonces, nuestra tabla al completo:

<table border="1">
<tr>
  <td>manzana</td><td colspan="2">pera</td><td>fresa</td><td>naranja</td>
</tr>
<tr>
  <td>melón</td><td>sandía</td><td>pomelo</td><td>cereza</td><td>granada</td>
</tr>
<tr>
  <td colspan="3">melocotón</td><td colspan="2">kiwi</td>
</tr>
</table>

En el próximo artículo veremos cómo extender las celdas verticalmente. No te supondrá ningún problema si has comprendido lo explicado aquí.

Javier Montero Gabarró


Tablas HTML con celdas irregulares – 1 de 3


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta