Programación · DacaCode

SQL: Transacciones, Índices y Constraints

Dacadev — Fri, 26 Jun 2026 00:00:00 -0500

Tabla de Contenido

En sistemas con múltiples usuarios escribiendo datos al mismo tiempo, la diferencia entre una aplicación confiable y una que corrompe información suele estar en cómo manejas transacciones en SQL, índices y constraints. En el artículo anterior analizamos Vistas (Views); ahora cerramos la serie con mecanismos de integridad y rendimiento.

Note

En este artículo vas a aprender cómo iniciar y cerrar transacciones con COMMIT y ROLLBACK, cuándo usar savepoints, cómo funcionan los índices B-tree, bitmap y full-text, y cómo las constraints mantienen reglas de integridad dentro del esquema.

Qué es una transacción en SQL

Una transacción agrupa una o varias sentencias SQL que deben ejecutarse como una unidad lógica. El objetivo es que los cambios se apliquen completos o no se apliquen en absoluto.

Consideremos una transferencia bancaria. Restar dinero de una cuenta y sumarlo a otra no son acciones independientes desde el punto de vista del negocio. Si una actualización se ejecuta y la otra falla, el sistema queda en un estado inconsistente.

START TRANSACTION;

 /* retirar dinero de la primera cuenta, validando saldo suficiente */
UPDATE account SET avail_balance = avail_balance - 500
WHERE account_id = 9988
 AND avail_balance > 500;

IF <exactly one row was updated by the previous statement> THEN
 /* depositar dinero en la segunda cuenta */
 UPDATE account SET avail_balance = avail_balance + 500
 WHERE account_id = 9989;

 IF <exactly one row was updated by the previous statement> THEN
 /* todo funcionó, hacer los cambios permanentes */
 COMMIT;
 ELSE
 /* algo falló, deshacer todos los cambios de esta transacción */
 ROLLBACK;
 END IF;
ELSE
 /* saldo insuficiente o error durante la actualización */
 ROLLBACK;
END IF;

En este flujo, COMMIT confirma los cambios y ROLLBACK revierte todo lo ejecutado desde el inicio de la transacción. La base de datos actúa como una frontera de consistencia.

Candados y concurrencia

Cuando varias sesiones intentan leer o escribir los mismos datos, el motor puede usar candados (locks) sobre filas, páginas o tablas. Los locks evitan que una transacción lea datos en transición o sobrescriba cambios que todavía no han sido confirmados.

Iniciar una transacción

Los servidores de base de datos suelen manejar la creación de transacciones de una de estas dos formas:

Siempre existe una transacción activa asociada a la sesión. Cuando la transacción actual termina, el servidor inicia automáticamente una nueva.
Cada sentencia SQL se confirma automáticamente, a menos que inicies una transacción explícita.

En MySQL, una transacción explícita puede comenzar con:

start transaction

Tip

Puedes configurar el comportamiento de autocommit según el motor y el cliente que uses.

Terminar una transacción

Una vez iniciada una transacción, necesitas terminarla explícitamente para que los cambios sean permanentes. COMMIT marca los cambios como definitivos y libera recursos usados durante la transacción,.

Si decides deshacer lo ejecutado desde el inicio de la transacción, usas ROLLBACK. El servidor devuelve los datos al estado previo de la transacción.

Además de COMMIT y ROLLBACK, una transacción puede terminar por otros eventos:

El servidor se apaga; al reiniciar, la transacción pendiente se revierte automáticamente.
Ejecutas una sentencia de esquema como ALTER TABLE; en varios motores esto puede confirmar la transacción actual e iniciar otra.
Ejecutas otro START TRANSACTION; algunos motores confirman la transacción anterior antes de abrir la nueva.
El servidor detecta un deadlock, elige una transacción como víctima y la revierte para desbloquear el sistema.

Warning

Las sentencias DDL no siempre participan en transacciones igual que las sentencias DML. Antes de mezclar ALTER TABLE, CREATE INDEX o cambios de esquema con operaciones de datos, revisa el comportamiento específico de tu motor.

Savepoints dentro de una transacción

Los savepoints permiten definir puntos intermedios de rollback dentro de una misma transacción. En lugar de revertir todo, puedes regresar a un punto específico y continuar trabajando.

Índices y constraints

Una consulta sin apoyo puede obligar al servidor a escanear fila por fila. En tablas con millones de registros y decenas de columnas, esto se convierte en un cuello de botella.

Los índices son estructuras auxiliares que permiten encontrar filas con menos trabajo. Aceleran búsquedas, filtros, joins y ordenamientos.

Creación de índices

Para crear un índice en MySQL podemos usar ALTER TABLE. Supongamos que el sistema consulta clientes frecuentemente por correo electrónico:

mysql> ALTER TABLE customer
 -> ADD INDEX idx_email (email);
Query OK, 0 rows affected (1.87 sec)
Records: 0 Duplicates: 0 Warnings: 0

Después de crear el índice, el optimizador decide si conviene usarlo. El motor evalúa estadísticas, cardinalidad y costo estimado.

Podemos inspeccionar los índices existentes con SHOW INDEX:

mysql> SHOW INDEX FROM customer \G;
*************************** 1. row ***************************
 Table: customer
 Non_unique: 1
 Key_name: idx_email
 Seq_in_index: 1
 Column_name: email
 Collation: A
 Cardinality: 599
 Sub_part: NULL
 Packed: NULL
 Null: YES
 Index_type: BTREE
...
5 rows in set (0.06 sec)

Y también podemos eliminarlos cuando dejan de aportar valor:

mysql> ALTER TABLE customer
 -> DROP INDEX idx_email;
Query OK, 0 rows affected (0.50 sec)
Records: 0 Duplicates: 0 Warnings: 0

Info

Cada índice ocupa espacio y debe actualizarse cuando cambian las filas afectadas. Un índice acelera lecturas específicas, pero también puede encarecer escrituras como INSERT, UPDATE y DELETE.

Índices únicos

Un índice único cumple dos funciones: acelera búsquedas y evita valores duplicados en las columnas indexadas. Cada vez que insertas una fila o modificas la columna, el servidor valida si el valor ya existe.

mysql> ALTER TABLE customer
 -> ADD UNIQUE idx_email (email);
Query OK, 0 rows affected (0.64 sec)
Records: 0 Duplicates: 0 Warnings: 0

Si intentas insertar un cliente con un email ya registrado, el motor rechaza la operación:

mysql> INSERT INTO customer
 -> (store_id, first_name, last_name, email, address_id, active)
 -> VALUES
 -> (1,'ALAN','KAHN', 'ALAN.KAHN@sakilacustomer.org', 394, 1);
ERROR 1062 (23000): Duplicate entry 'ALAN.KAHN@sakilacustomer.org' 
 for key 'idx_email'

Índices multicolumna

También puedes crear índices que cubren varias columnas. Si buscas clientes por apellido y nombre, un índice compuesto puede ser más útil que dos índices separados.

mysql> ALTER TABLE customer
 -> ADD INDEX idx_full_name (last_name, first_name);
Query OK, 0 rows affected (0.35 sec)
Records: 0 Duplicates: 0 Warnings: 0

El orden importa. Un índice (last_name, first_name) ayuda a consultas que filtran por last_name o por last_name junto con first_name. No ayuda igual a una consulta que filtra solo por first_name.

Tipos de índices

Índices B-tree

Los índices B-tree organizan los valores como árboles balanceados. Los branch nodes sirven para navegar por rangos, mientras que los leaf nodes almacenan los valores reales del índice.

Branch nodes dirigen la búsqueda hacia el rango correcto; leaf nodes contienen las entradas finales asociadas a los valores indexados.

flowchart TD
 root["Nodo raíz
A - M | N - Z"]
 b1["A-C | D-F | G-I | J-M"]
 b2["N-P | Q-S | T-V | W-Z"]
 root --> b1
 root --> b2
 b1 --> l1["Barker
Blake"]
 b1 --> l2["Fleming
Fowler"]
 b1 --> l3["Gooding
Grossman
Hawthorne"]
 b1 --> l4["Jameson
Markham
Mason"]
 b2 --> l5["Parker
Portman"]
 b2 --> l6["Roberts
Smith"]
 b2 --> l7["Tucker
Tulman
Tyler"]
 b2 --> l8["Ziegler"]

Este tipo de índice funciona muy bien para columnas con muchos valores distintos, como customer.last_name, fechas, identificadores externos o campos usados en rangos.

Índices bitmap

Los bitmap indexes están diseñados para columnas de baja cardinalidad, es decir, columnas con pocos valores posibles repetidos en muchas filas. Un ejemplo clásico es customer.active, donde puede haber solo 1 para activo y 0 para inactivo.

En lugar de mantener un árbol grande, el motor mantiene bitmaps por valor. Para consultar clientes inactivos, puede recorrer el bitmap del valor 0 y localizar las filas correspondientes.

Esta estrategia es compacta para baja cardinalidad, pero se degrada cuando la columna tiene demasiados valores distintos.

Índices de texto

Cuando almacenas documentos o contenido largo, buscar palabras con un escaneo completo es costoso.

MySQL y SQL Server ofrecen índices full-text; Oracle incluye herramientas bajo Oracle Text. Estos mecanismos están especializados para documentos y búsquedas textuales.

Cómo se usan los índices

Los índices permiten acceder rápidamente a datos, pero el motor decide si usarlos según el plan de ejecución. Un índice creado no garantiza automáticamente una consulta más rápida.

Observemos tres criterios prácticos:

Crea índices alrededor de consultas frecuentes, no alrededor de columnas al azar.
Evita indexar columnas con baja selectividad usando B-tree si el motor ofrece una estrategia mejor.
Mide el impacto en escrituras, porque cada índice debe mantenerse actualizado.

Constraints: restricciones de integridad

Una constraint es una restricción aplicada a una o más columnas de una tabla. Vive dentro del esquema y protege los datos desde la base.

Los tipos principales son:

Primary key constraints: identifican la columna o combinación de columnas que garantizan unicidad dentro de una tabla.
Foreign key constraints: restringen una o más columnas para que contengan valores existentes en la primary key de otra tabla.
Unique constraints: evitan duplicados en una o más columnas; una primary key es un caso especial de unicidad.
Check constraints: restringen los valores permitidos para una columna según una condición.

Normalmente las constraints se crean junto con la tabla usando CREATE TABLE. Este ejemplo del esquema Sakila combina primary key, índices y foreign keys:

CREATE TABLE customer (
 customer_id SMALLINT UNSIGNED NOT NULL AUTO_INCREMENT,
 store_id TINYINT UNSIGNED NOT NULL,
 first_name VARCHAR(45) NOT NULL,
 last_name VARCHAR(45) NOT NULL,
 email VARCHAR(50) DEFAULT NULL,
 address_id SMALLINT UNSIGNED NOT NULL,
 active BOOLEAN NOT NULL DEFAULT TRUE,
 create_date DATETIME NOT NULL,
 last_update TIMESTAMP DEFAULT CURRENT_TIMESTAMP 
 ON UPDATE CURRENT_TIMESTAMP,
 PRIMARY KEY (customer_id),
 KEY idx_fk_store_id (store_id),
 KEY idx_fk_address_id (address_id),
 KEY idx_last_name (last_name),
 CONSTRAINT fk_customer_address FOREIGN KEY (address_id) 
 REFERENCES address (address_id) ON DELETE RESTRICT ON UPDATE CASCADE,
 CONSTRAINT fk_customer_store FOREIGN KEY (store_id) 
 REFERENCES store (store_id) ON DELETE RESTRICT ON UPDATE CASCADE
)ENGINE=InnoDB DEFAULT CHARSET=utf8;

También puedes agregar constraints después con ALTER TABLE:

ALTER TABLE customer
ADD CONSTRAINT fk_customer_address FOREIGN KEY (address_id)
REFERENCES address (address_id) ON DELETE RESTRICT ON UPDATE CASCADE;

ALTER TABLE customer
ADD CONSTRAINT fk_customer_store FOREIGN KEY (store_id)
REFERENCES store (store_id) ON DELETE RESTRICT ON UPDATE CASCADE;

La cláusula ON DELETE RESTRICT protege contra registros huérfanos cuando se intenta eliminar una fila padre.

Para foreign keys, las acciones comunes ante borrados y actualizaciones son:

ON DELETE RESTRICT: impide borrar la fila padre si existen filas hijas relacionadas.
ON DELETE CASCADE: borra automáticamente las filas hijas cuando se borra la fila padre.
ON DELETE SET NULL: asigna NULL en la foreign key de las filas hijas cuando se borra la fila padre.
ON UPDATE RESTRICT: impide actualizar la clave padre si hay filas hijas relacionadas.
ON UPDATE CASCADE: propaga el cambio de clave hacia las filas hijas.
ON UPDATE SET NULL: asigna NULL en la foreign key de las filas hijas cuando cambia la clave padre.

Warning

CASCADE es potente, pero debe modelarse con cuidado. Una eliminación pequeña puede disparar borrados en varias tablas.

Conclusión de la serie SQL

Las transacciones, índices y constraints completan la base práctica para trabajar con SQL de forma profesional. Protegen operaciones compuestas, reducen el costo de acceso a datos y llevan reglas críticas al esquema.

Con este artículo cerramos la serie de SQL. Para repasar desde el inicio, vuelve a: Fundamentos SQL: SELECT, FROM y WHERE. Desde ahí puedes recorrer consultas, filtros, joins, agrupaciones, subconsultas, vistas y estos mecanismos de integridad y rendimiento.

SQL: Vistas (Views) para Abstraer y Asegurar tus Datos

Dacadev — Tue, 23 Jun 2026 00:00:00 -0500

Tabla de Contenido

Cuando una base de datos crece, las consultas empiezan a acumular lógica de negocio, joins repetidos, filtros de seguridad y columnas calculadas. En ese punto, las vistas en SQL se vuelven una herramienta clave: con CREATE VIEW podemos encapsular una consulta y exponerla como si fuera una tabla lógica. En el artículo anterior vimos subqueries y subconsultas; ahora vamos a usar ese mismo nivel de composición para abstraer, asegurar y simplificar el acceso a datos.

Note

En este artículo analizaremos qué es una vista, cómo crearla con CREATE VIEW, por qué ayuda con seguridad, agregación, complejidad y datos distribuidos, y qué condiciones debe cumplir una vista para ser actualizable.

Qué es una vista

Una vista no es una tabla física. En términos prácticos, es una consulta guardada en la base de datos que puedes consultar con SELECT como si fuera una tabla. La vista no almacena los registros por sí misma; almacena la definición del query que se ejecutará cuando accedas a ella.

Esto reduce repetición y mejora la legibilidad. Si una consulta se usa todos los días, o si quieres exponer solo ciertas columnas a un equipo o aplicación, una vista ofrece una interfaz estable sobre las tablas base.

Consideremos una vista sobre la tabla customer:

CREATE VIEW customer_vw
 (customer_id,
 first_name,
 last_name,
 email 
 )
AS
SELECT 
 customer_id,
 first_name,
 last_name,
 concat(substr(email,1,2), '*****', substr(email, -4)) email
FROM customer;

En este ejemplo, la vista customer_vw expone customer_id, first_name, last_name y email. Observemos un detalle importante: el email no se entrega completo, sino enmascarado mediante concat() y substr().

Para usar la vista, la consultamos como cualquier otra relación:

mysql> SELECT first_name, last_name, email
 -> FROM customer_vw;
+-------------+--------------+-------------+
| first_name | last_name | email |
+-------------+--------------+-------------+
| MARY | SMITH | MA*****.org |
| PATRICIA | JOHNSON | PA*****.org |
| LINDA | WILLIAMS | LI*****.org |
| BARBARA | JONES | BA*****.org |
| ELIZABETH | BROWN | EL*****.org |
...
| ENRIQUE | FORSYTHE | EN*****.org |
| FREDDIE | DUGGAN | FR*****.org |
| WADE | DELVALLE | WA*****.org |
| AUSTIN | CINTRON | AU*****.org |
+-------------+--------------+-------------+
599 rows in set (0.00 sec)

La consulta queda más expresiva: en lugar de repetir el cálculo del email en cada reporte, centralizamos esa lógica en una vista.

Si necesitas inspeccionar la estructura de una vista, puedes usar DESCRIBE o su forma corta DESC:

mysql> describe customer_vw;
+-------------+----------------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------------+----------------------+------+-----+---------+-------+
| customer_id | smallint(5) unsigned | NO | | 0 | |
| first_name | varchar(45) | NO | | NULL | |
| last_name | varchar(45) | NO | | NULL | |
| email | varchar(11) | YES | | NULL | |
+-------------+----------------------+------+-----+---------+-------+
4 rows in set (0.00 sec)

Tip

Puedes usar en vistas gran parte de lo que ya conoces de SQL: WHERE, ORDER BY, GROUP BY, funciones, expresiones calculadas e incluso JOIN. La vista encapsula la consulta; no elimina la necesidad de diseñarla correctamente.

Por qué usar vistas

Las vistas son útiles cuando necesitas definir una capa de acceso estable entre las tablas reales y los consumidores de datos. Esa capa puede servir para seguridad, reporting, simplificación de consultas o unificación de datos.

Seguridad de los datos

Cuando los usuarios consultan directamente las tablas base, pueden quedar expuestas columnas sensibles que no deberían estar disponibles para todos los perfiles. Una vista permite publicar solo las columnas necesarias y, si hace falta, transformar datos antes de mostrarlos.

El ejemplo de customer_vw aplica este patrón: el email se expone enmascarado. En una aplicación interna, podrías conceder permisos sobre la vista y evitar permisos directos sobre customer. Así reduces superficie de exposición sin duplicar datos.

Este enfoque también estabiliza contratos. Si la tabla base contiene más columnas en el futuro, los consumidores de la vista no las reciben automáticamente.

Agregar datos

Las vistas también funcionan bien para reportes o consultas agregadas. Si un equipo necesita revisar ventas por categoría de película, no tiene que escribir todos los JOIN cada vez.

CREATE VIEW sales_by_film_category
AS
SELECT
 c.name AS category,
 SUM(p.amount) AS total_sales
FROM payment AS p
 INNER JOIN rental AS r ON p.rental_id = r.rental_id
 INNER JOIN inventory AS i ON r.inventory_id = i.inventory_id
 INNER JOIN film AS f ON i.film_id = f.film_id
 INNER JOIN film_category AS fc ON f.film_id = fc.film_id
 INNER JOIN category AS c ON fc.category_id = c.category_id
GROUP BY c.name
ORDER BY total_sales DESC;

Esta vista encapsula una agregación de pagos por categoría. El consumidor puede ejecutar SELECT * FROM sales_by_film_category; y enfocarse en el resultado, no en la mecánica de las relaciones.

Info

Una vista con agregaciones no materializa necesariamente el resultado. En muchos motores, la consulta se evalúa al leer la vista. Si el reporte es costoso y se consulta con alta frecuencia, analiza índices, planes de ejecución o alternativas como vistas materializadas cuando tu motor las soporte.

Esconder complejidad

Otra ventaja importante es ocultar consultas complejas detrás de un nombre claro. Analicemos una vista que resume estadísticas de películas usando subconsultas:

CREATE VIEW film_stats
AS
SELECT f.film_id, f.title, f.description, f.rating,
 (SELECT c.name
 FROM category c
 INNER JOIN film_category fc
 ON c.category_id = fc.category_id
 WHERE fc.film_id = f.film_id) category_name,
 (SELECT count(*)
 FROM film_actor fa
 WHERE fa.film_id = f.film_id
 ) num_actors,
 (SELECT count(*)
 FROM inventory i
 WHERE i.film_id = f.film_id
 ) inventory_cnt,
 (SELECT count(*)
 FROM inventory i
 INNER JOIN rental r
 ON i.inventory_id = r.inventory_id
 WHERE i.film_id = f.film_id
 ) num_rentals
FROM film f;

Esta consulta mezcla columnas directas, subqueries correlacionadas y conteos derivados. Usar film_stats como interfaz simplifica el consumo y reduce errores de copia al reutilizar la lógica.

También mejora la comunicación técnica. Un nombre como film_stats expresa intención de negocio mejor que una consulta extensa pegada en múltiples servicios, dashboards o scripts.

Datos distribuidos o particionados

Las vistas pueden ayudar a unificar datos que viven en diferentes tablas. Si una tabla está particionada por año, por región o por tipo de entidad, una vista puede presentar una estructura más simple para quien consulta.

El objetivo no es ocultar decisiones arquitectónicas críticas, sino evitar que cada consumidor tenga que conocer todos los detalles físicos del modelo. Una vista puede funcionar como una API interna de lectura dentro de la base de datos.

Vistas actualizables

Hasta ahora hemos usado vistas para leer datos. Sin embargo, algunos motores permiten ejecutar UPDATE, INSERT o DELETE a través de una vista, siempre que la base de datos pueda mapear la operación de forma inequívoca hacia las tablas base.

No todas las vistas son actualizables. Mientras más transformación tenga una vista, más difícil será determinar qué fila y qué columna real debe modificarse.

Para que una vista sea actualizable, considera estas restricciones típicas:

No se usan funciones de agregación como max(), min(), avg(), sum() o similares.
La vista no utiliza cláusulas GROUP BY ni HAVING.
No existen subconsultas en el SELECT ni en el FROM; y las subconsultas en el WHERE, si existen, no hacen referencia a tablas del FROM.
La vista no utiliza UNION, UNION ALL ni DISTINCT.
La cláusula FROM incluye al menos una tabla o una vista actualizable.
Si hay más de una tabla o vista en el FROM, se usan únicamente INNER JOIN.

Warning

Las reglas exactas dependen del motor de base de datos. MySQL, PostgreSQL, SQL Server y Oracle tienen diferencias en sintaxis, permisos y casos soportados. Antes de depender de escrituras sobre vistas en producción, valida el comportamiento en tu motor específico.

Actualizando vistas simples

Supongamos nuevamente la vista customer_vw:

CREATE VIEW customer_vw
 (customer_id,
 first_name,
 last_name,
 email
 )
AS
SELECT
 customer_id,
 first_name,
 last_name,
 concat(substr(email,1,2), '*****', substr(email, -4)) email
FROM customer;

Podemos actualizar una columna directa de la tabla base, como last_name, usando la vista:

mysql> UPDATE customer_vw
 -> SET last_name = 'SMITH-ALLEN'
 -> WHERE customer_id = 1;
Query OK, 1 row affected (0.11 sec)
Rows matched: 1 Changed: 1 Warnings: 0

La operación funciona porque last_name corresponde directamente a una columna actualizable de customer. La vista actúa como una capa de acceso, pero el motor sabe qué valor modificar.

En cambio, si intentamos actualizar email, la operación falla:

mysql> UPDATE customer_vw
 -> SET email = 'MARY.SMITH-ALLEN@sakilacustomer.org'
 -> WHERE customer_id = 1;
ERROR 1348 (HY000): Column 'email' is not updatable

La razón es que email en la vista no es la columna original; es una expresión calculada con concat() y substr(). El motor no puede inferir cómo convertir el valor nuevo en una actualización válida de la columna base.

También debes tener cuidado con INSERT. Insertar a través de una vista falla cuando la vista no expone todas las columnas NOT NULL de la tabla base, por lo que el INSERT no puede proporcionar valores para ellas. Si esas columnas no tienen DEFAULT, el motor no tiene forma segura de completar la fila.

Conclusión

Las vistas en SQL son una herramienta de diseño para crear interfaces de datos más limpias. Con CREATE VIEW puedes encapsular consultas repetidas, proteger columnas sensibles, construir reportes agregados y esconder complejidad sin duplicar información.

También es importante reconocer sus límites. Una vista no reemplaza un buen diseño de índices, no siempre mejora rendimiento y no siempre permite escritura. Cuando una vista incluye agregaciones, expresiones calculadas, DISTINCT, UNION o subconsultas complejas, normalmente debes tratarla como una interfaz de lectura.

Como siguiente paso de la serie, analizaremos cómo proteger la consistencia y el rendimiento de operaciones más críticas con transacciones, índices y constraints.

SQL: Subqueries y Tipos de JOIN Avanzados

Dacadev — Sat, 20 Jun 2026 00:00:00 -0500

Tabla de Contenido

Cuando tus consultas SQL empiezan a mezclar filtros, agregaciones y relaciones entre tablas, los JOIN básicos dejan de ser suficientes para expresar ciertas reglas de negocio con claridad. Las subqueries o subconsultas en SQL permiten encapsular una consulta dentro de otra, reutilizar resultados intermedios y construir filtros más precisos sin mover lógica innecesaria a la aplicación. En el artículo anterior vimos consultas a múltiples tablas con JOINs; ahora vamos a extender esa base con subconsultas, EXISTS y tipos de JOIN más avanzados.

Note

En este artículo aprenderás a usar subqueries escalares, subconsultas de múltiples filas, subqueries correlacionadas, el operador EXISTS, LEFT OUTER JOIN, CROSS JOIN y NATURAL JOIN.

Qué es una subquery en SQL

Una subquery es una consulta contenida dentro de otra sentencia SQL. A la sentencia externa la llamaremos consulta contenedora o consulta principal. La subquery siempre va entre paréntesis y, en muchos motores, se evalúa antes de que la consulta principal termine de resolver su filtro o su conjunto de datos.

Como cualquier consulta, una subquery puede retornar diferentes formas de resultado:

Una sola fila con una sola columna.
Múltiples filas con una sola columna.
Múltiples filas con múltiples columnas.

Analicemos un primer ejemplo. Queremos obtener el cliente con el customer_id más alto:

mysql> SELECT customer_id, first_name, last_name
 -> FROM customer
 -> WHERE customer_id = (SELECT MAX(customer_id) FROM customer);
+-------------+------------+-----------+
| customer_id | first_name | last_name |
+-------------+------------+-----------+
| 599 | AUSTIN | CINTRON |
+-------------+------------+-----------+
1 row in set (0.27 sec)

La subquery (SELECT MAX(customer_id) FROM customer) retorna un único valor. Por eso podemos compararla con = en el WHERE de la consulta principal.

Info

Cuando una subquery retorna una fila y una sola columna, se comporta como una subquery escalar. Puedes usarla con operadores como =, <>, !=, >, >=, < y <=.

Tipos de subqueries

No todas las subconsultas tienen el mismo comportamiento. La diferencia más importante está en si la subquery depende o no de la consulta principal.

Subqueries no correlacionadas

Las subqueries no correlacionadas no dependen directamente de la consulta contenedora. Puedes ejecutarlas por separado, inspeccionar su resultado y luego entender cómo ese resultado alimenta el WHERE, HAVING o incluso el FROM de la consulta principal.

El ejemplo anterior es una subquery no correlacionada. Observemos otro caso: obtener todas las ciudades cuyo país no sea India.

mysql> SELECT city_id, city
 -> FROM city
 -> WHERE country_id <> 
 -> (SELECT country_id FROM country WHERE country = 'India');
+---------+----------------------------+
| city_id | city |
+---------+----------------------------+
| 1 | A Corua (La Corua) |
| 2 | Abha |
| 3 | Abu Dhabi |
| 4 | Acua |
...
| 599 | Zhoushan |
| 600 | Ziguinchor |
+---------+----------------------------+
540 rows in set (0.02 sec)

Aquí la subquery retorna el country_id asociado a India. La consulta principal usa ese valor para excluir todas las ciudades que pertenezcan a ese país.

Warning

Si usas = con una subquery que retorna más de un valor, el motor no puede comparar un valor escalar contra un conjunto de filas. En ese caso necesitas operadores como IN, ANY, ALL o reestructurar la consulta.

Subqueries de múltiples filas y una columna

Cuando una subquery retorna varias filas pero una sola columna, IN suele ser el operador adecuado. Este operador compara el valor del lado izquierdo contra el conjunto de valores retornado por la subquery.

Consideremos una consulta para obtener ciudades de Canadá o México:

mysql> SELECT city_id, city
 -> FROM city
 -> WHERE country_id IN
 -> (SELECT country_id
 -> FROM country
 -> WHERE country IN ('Canada','Mexico'));
+---------+----------------------------+
| city_id | city |
+---------+----------------------------+
| 179 | Gatineau |
| 196 | Halifax |
| 300 | Lethbridge |
| 313 | London |
...
| 556 | Uruapan |
| 595 | Zapopan |
+---------+----------------------------+
37 rows in set (0.00 sec)

La subquery retorna los country_id de ambos países. Luego IN filtra las ciudades cuyo country_id esté dentro de ese conjunto.

Subqueries multicolumna

Las subqueries multicolumna retornan más de una columna y son útiles cuando necesitas comparar combinaciones de valores o enriquecer la lógica de selección. En SQL también es común resolver este tipo de necesidad con varias subqueries coordinadas, especialmente cuando cada filtro opera sobre una dimensión diferente.

Observemos este caso: queremos encontrar pares actor_id y film_id donde el actor tenga apellido MONROE y la película tenga clasificación PG.

mysql> SELECT fa.actor_id, fa.film_id
 -> FROM film_actor fa
 -> WHERE fa.actor_id IN
 -> (SELECT actor_id FROM actor WHERE last_name = 'MONROE')
 -> AND fa.film_id IN
 -> (SELECT film_id FROM film WHERE rating = 'PG');
+----------+---------+
| actor_id | film_id |
+----------+---------+
| 120 | 63 |
| 120 | 144 |
| 120 | 414 |
...
| 178 | 983 |
+----------+---------+
11 rows in set (0.00 sec)

Esta consulta combina dos filtros independientes: uno sobre actores y otro sobre películas. El resultado final sale de la tabla intermedia film_actor, que representa la relación muchos-a-muchos.

Subqueries correlacionadas

Hasta ahora, las subqueries han sido independientes. Una subquery correlacionada, en cambio, depende de la consulta principal porque referencia una o más columnas de la fila que se está evaluando afuera.

Esto cambia el modelo mental: la subquery no se ejecuta una sola vez para producir un conjunto estático, sino que puede evaluarse por cada fila candidata de la consulta externa. Por eso conviene revisar su costo, especialmente en tablas grandes.

Analicemos una consulta que obtiene clientes con exactamente 20 rentas:

mysql> SELECT c.first_name, c.last_name
 -> FROM customer c
 -> WHERE 20 =
 -> (SELECT count(*) FROM rental r
 -> WHERE r.customer_id = c.customer_id);
+------------+-------------+
| first_name | last_name |
+------------+-------------+
| LAUREN | HUDSON |
| JEANETTE | GREENE |
| TARA | RYAN |
| WILMA | RICHARDS |
...
| ALFREDO | MCADAMS |
+------------+-------------+
15 rows in set (0.01 sec)

La parte clave es r.customer_id = c.customer_id. La subquery necesita el customer_id de la fila actual de customer, por eso está correlacionada.

El operador EXISTS

El operador EXISTS valida si la subquery retorna al menos una fila. No importa qué columnas seleccione la subquery; lo relevante es la existencia de registros que cumplan la condición.

Por convención, muchas consultas usan SELECT 1 dentro de EXISTS para indicar que el valor retornado no es importante:

mysql> SELECT c.first_name, c.last_name
 -> FROM customer c
 -> WHERE EXISTS
 -> (SELECT 1 FROM rental r
 -> WHERE r.customer_id = c.customer_id
 -> AND date(r.rental_date) < '2005-05-25');
+------------+-------------+
| first_name | last_name |
+------------+-------------+
| CHARLOTTE | HUNTER |
| DELORES | HANSEN |
| MINNIE | ROMERO |
...
| NELSON | CHRISTENSON |
+------------+-------------+
8 rows in set (0.03 sec)

EXISTS es especialmente expresivo cuando la pregunta de negocio es binaria: “incluye esta fila si existe al menos una relación que cumple la condición”.

Tip

Usa EXISTS cuando quieras comprobar existencia y IN cuando quieras comparar contra un conjunto concreto de valores. Ambos pueden ser optimizados por el motor, pero expresan intenciones distintas.

JOINs avanzados: revisitando las uniones

Hasta este punto de la serie hemos trabajado principalmente con INNER JOIN. Ese tipo de unión retorna únicamente las filas que cumplen la condición en ambas tablas. Sin embargo, SQL ofrece variantes útiles para preservar filas sin coincidencias, generar combinaciones cartesianas o delegar la condición de unión al motor.

Outer joins

Los outer joins retornan las filas que cumplen la condición de unión y, además, conservan filas de una tabla aunque no tengan coincidencias del otro lado. En un LEFT OUTER JOIN, se preservan todas las filas de la tabla de la izquierda.

Observemos un conteo de copias por película:

mysql> SELECT f.film_id, f.title, count(i.inventory_id) num_copies
 -> FROM film f
 -> LEFT OUTER JOIN inventory i
 -> ON f.film_id = i.film_id
 -> GROUP BY f.film_id, f.title;
+---------+-----------------------------+------------+
| film_id | title | num_copies |
+---------+-----------------------------+------------+
| 1 | ACADEMY DINOSAUR | 8 |
| 2 | ACE GOLDFINGER | 3 |
| 3 | ADAPTATION HOLES | 4 |
| 4 | AFFAIR PREJUDICE | 7 |
...
| 14 | ALICE FANTASIA | 0 |
...
| 999 | ZOOLANDER FICTION | 5 |
| 1000 | ZORRO ARK | 8 |
+---------+-----------------------------+------------+
1000 rows in set (0.01 sec)

ALICE FANTASIA aparece con 0 copias porque no tiene registros asociados en inventory. Aun así, el LEFT OUTER JOIN conserva la película porque film está a la izquierda.

Veamos la misma situación sin agregación:

mysql> SELECT f.film_id, f.title, i.inventory_id
 -> FROM film f
 -> LEFT OUTER JOIN inventory i
 -> ON f.film_id = i.film_id
 -> WHERE f.film_id BETWEEN 13 AND 15;
+---------+----------------+--------------+
| film_id | title | inventory_id |
+---------+----------------+--------------+
| 13 | ALI FOREVER | 67 |
| 13 | ALI FOREVER | 68 |
| 13 | ALI FOREVER | 69 |
| 13 | ALI FOREVER | 70 |
| 14 | ALICE FANTASIA | NULL |
| 15 | ALIEN CENTER | 71 |
| 15 | ALIEN CENTER | 72 |
| 15 | ALIEN CENTER | 73 |
| 15 | ALIEN CENTER | 74 |
| 15 | ALIEN CENTER | 75 |
| 15 | ALIEN CENTER | 76 |
+---------+----------------+--------------+
11 rows in set (0.00 sec)

El NULL en inventory_id indica que no existe fila relacionada en la tabla derecha.

Outer joins de tres tablas

Puedes encadenar OUTER JOIN para preservar filas a través de varias relaciones. En este tipo de consulta, el orden importa porque define qué conjunto de filas se conserva en cada paso.

mysql> SELECT f.film_id, f.title, i.inventory_id, r.rental_date
 -> FROM film f
 -> LEFT OUTER JOIN inventory i
 -> ON f.film_id = i.film_id
 -> LEFT OUTER JOIN rental r
 -> ON i.inventory_id = r.inventory_id
 -> WHERE f.film_id BETWEEN 13 AND 15;
+---------+----------------+--------------+---------------------+
| film_id | title | inventory_id | rental_date |
+---------+----------------+--------------+---------------------+
| 13 | ALI FOREVER | 67 | 2005-07-31 18:11:17 |
| 13 | ALI FOREVER | 67 | 2005-08-22 21:59:29 |
| 13 | ALI FOREVER | 68 | 2005-07-28 15:26:20 |
...
| 14 | ALICE FANTASIA | NULL | NULL |
| 15 | ALIEN CENTER | 71 | 2005-05-28 02:06:37 |
...
| 15 | ALIEN CENTER | 76 | 2005-08-17 07:26:47 |
+---------+----------------+--------------+---------------------+
32 rows in set (0.01 sec)

Tip

Aunque existe RIGHT OUTER JOIN, en muchos equipos se prefiere estandarizar en LEFT OUTER JOIN. Mantiene la lectura de izquierda a derecha y reduce cambios mentales al revisar consultas complejas.

Cross joins

Un CROSS JOIN produce un producto cartesiano: combina cada fila de la primera tabla con cada fila de la segunda. Es útil para generar matrices de combinaciones, calendarios, catálogos base o escenarios de prueba, pero puede crecer muy rápido.

mysql> SELECT c.name category_name, l.name language_name
 -> FROM category c
 -> CROSS JOIN language l;
+---------------+---------------+
| category_name | language_name |
+---------------+---------------+
| Action | English |
| Action | Italian |
| Action | Japanese |
...
| Travel | English |
| Travel | German |
+---------------+---------------+
96 rows in set (0.00 sec)

Si category tiene 16 filas y language tiene 6, el resultado tendrá 96 filas. Esa multiplicación es exactamente el comportamiento esperado.

Natural joins

NATURAL JOIN deja que el motor determine las columnas de unión usando columnas con el mismo nombre en ambas tablas. Es importante conocerlo, pero no suele ser buena práctica en consultas de producción porque oculta la condición real del JOIN.

El siguiente ejemplo no retorna filas:

mysql> SELECT c.first_name, c.last_name, date(r.rental_date)
 -> FROM customer c
 -> NATURAL JOIN rental r;
Empty set (0.04 sec)

El problema es que customer y rental pueden compartir más columnas de las que realmente queremos usar como condición natural. Al proyectar únicamente las columnas necesarias desde customer, el NATURAL JOIN puede comportarse como esperamos:

mysql> SELECT cust.first_name, cust.last_name, date(r.rental_date)
 -> FROM
 -> (SELECT customer_id, first_name, last_name
 -> FROM customer
 -> ) cust
 -> NATURAL JOIN rental r;
+------------+-----------+---------------------+
| first_name | last_name | date(r.rental_date) |
+------------+-----------+---------------------+
| MARY | SMITH | 2005-05-25 |
| MARY | SMITH | 2005-05-28 |
| MARY | SMITH | 2005-06-15 |
...
| AUSTIN | CINTRON | 2005-08-23 |
+------------+-----------+---------------------+
16044 rows in set (0.03 sec)

Warning

Prefiere JOIN ... ON ... cuando la consulta debe ser mantenible. La condición explícita documenta la intención y evita cambios inesperados si el esquema gana nuevas columnas con nombres compartidos.

Conclusión

Las subqueries en SQL te permiten expresar reglas de negocio que dependen de resultados intermedios sin salir del motor de base de datos. Las subconsultas no correlacionadas son ideales para filtros basados en conjuntos estáticos; las correlacionadas son útiles cuando cada fila externa necesita una evaluación específica; y EXISTS comunica con claridad validaciones de existencia.

En el lado de los JOIN, LEFT OUTER JOIN conserva filas sin coincidencias, CROSS JOIN genera combinaciones cartesianas y NATURAL JOIN delega la condición al motor, aunque conviene usarlo con cuidado. La clave es elegir la herramienta que haga más explícita la intención de la consulta.

En el siguiente artículo de la serie vamos a trabajar con Vistas (Views), una forma práctica de encapsular consultas y exponer modelos de lectura reutilizables dentro de la base de datos.

Estilos CSS: Animaciones con @keyframes

Dacadev — Thu, 18 Jun 2026 00:00:00 -0500

Tabla de Contenido

Una transición anima el salto entre dos estados; pero cuando necesitas movimiento continuo, varios pasos intermedios o una secuencia que se repite —un spinner de carga, un latido, un texto que aparece— necesitas algo más expresivo. Ahí entran las animaciones con @keyframes, el sistema de CSS para describir secuencias de movimiento complejas de forma declarativa, sin una sola línea de JavaScript.

Esta entrega extiende la serie Estilos CSS, retomando justo donde lo dejaron las transiciones y transformaciones. Cubriremos la regla @keyframes, todas las subpropiedades de animation, y las consideraciones de accesibilidad y rendimiento que separan una animación profesional de una que marea al usuario.

Note

Aprenderás a definir secuencias con @keyframes, a controlarlas con la propiedad animation y sus ocho subpropiedades, y a respetar las preferencias de movimiento del usuario con prefers-reduced-motion.

Transición vs. animación

Aunque ambas producen movimiento, resuelven problemas distintos:

Una transición (transition) interpola entre el estado actual y uno nuevo. Necesita un disparador —un :hover, un cambio de clase— y va de un punto A a un punto B.
Una animación (animation) ejecuta una secuencia definida en @keyframes. No necesita disparador: puede arrancar sola, repetirse indefinidamente y pasar por múltiples estados intermedios.

Info

Regla práctica: usa transition para cambios de estado provocados por interacción; usa animation para movimiento autónomo, cíclico o multipaso.

La regla @keyframes

Una animación se define en dos partes: la secuencia (con @keyframes) y su aplicación (con la propiedad animation). La regla @keyframes recibe un nombre y describe los estados de la animación en distintos momentos, expresados como porcentajes del 0% al 100% (o con las palabras clave from y to).

@keyframes aparecer {
 from { opacity: 0; transform: translateY(1rem); }
 to { opacity: 1; transform: translateY(0); }
}

.elemento {
 animation: aparecer 0.6s ease-out;
}

Aparezco con fade + desplazamiento

La secuencia se repite para que puedas observarla.

Múltiples pasos con porcentajes

El verdadero poder de @keyframes aparece con pasos intermedios. Cada porcentaje es una “foto” del estado en ese momento de la animación:

@keyframes latido {
 0% { transform: scale(1); }
 15% { transform: scale(1.25); }
 30% { transform: scale(1); }
 45% { transform: scale(1.15); }
 60% { transform: scale(1); }
}

♥

La propiedad animation y sus subpropiedades

animation es una propiedad abreviada que agrupa ocho subpropiedades. Conviene conocerlas por separado para tener control fino:

Subpropiedad	Función	Ejemplo
`animation-name`	Nombre del `@keyframes` a ejecutar	`aparecer`
`animation-duration`	Duración de un ciclo	`0.6s`
`animation-timing-function`	Curva de progreso	`ease-in-out`
`animation-delay`	Espera antes de iniciar	`200ms`
`animation-iteration-count`	Número de repeticiones	`infinite`
`animation-direction`	Sentido de reproducción	`alternate`
`animation-fill-mode`	Estilos antes/después de animar	`forwards`
`animation-play-state`	Reproducir o pausar	`paused`

La forma abreviada las combina en una sola declaración:

.spinner {
 animation: girar 1s linear infinite;
 /* name | duration | timing-function | iteration-count */
}

iteration-count y direction

animation-iteration-count define cuántas veces se ejecuta (infinite para un bucle perpetuo). animation-direction controla el sentido:

normal — siempre de 0% a 100%.
reverse — siempre de 100% a 0%.
alternate — alterna ida y vuelta en cada ciclo.
alternate-reverse — igual, pero empezando al revés.

El caso clásico es un spinner de carga, que combina rotación infinita con velocidad constante:

@keyframes girar { to { transform: rotate(360deg); } }

.spinner { animation: girar 0.8s linear infinite; }

fill-mode: el estado antes y después

Por defecto, un elemento vuelve a su estilo original en cuanto la animación termina. animation-fill-mode cambia ese comportamiento:

none (por defecto) — no conserva estilos fuera de la ejecución.
forwards — mantiene el estado del último keyframe al terminar.
backwards — aplica el primer keyframe durante el delay, antes de arrancar.
both — combina forwards y backwards.

forwards es esencial cuando quieres que el elemento permanezca en su estado final (por ejemplo, un mensaje que aparece y se queda visible):

.toast {
 animation: aparecer 0.5s ease-out forwards;
}

play-state y delay

animation-play-state permite pausar (paused) y reanudar (running) una animación, típicamente al combinarla con :hover. Aquí, la barra de progreso se anima sola pero se congela al pasar el cursor:

@keyframes cargar { from { width: 0; } to { width: 100%; } }

.barra__relleno { animation: cargar 3s ease-in-out infinite; }
.barra:hover .barra__relleno { animation-play-state: paused; }

Pasa el cursor sobre la barra para pausar la animación.

Encadenar varias animaciones

Puedes aplicar varias animaciones a un mismo elemento separándolas con comas. Cada una mantiene su propia duración, retraso y curva, lo que permite componer comportamientos independientes:

.elemento {
 animation:
 aparecer 0.5s ease-out,
 flotar 3s ease-in-out 0.5s infinite alternate;
}

Floto suavemente

Accesibilidad: respeta prefers-reduced-motion

El movimiento excesivo puede causar mareos o malestar a personas con sensibilidad vestibular. Los sistemas operativos exponen una preferencia de “reducir movimiento”, y CSS la consulta con la media query prefers-reduced-motion. Es una responsabilidad profesional desactivar o atenuar las animaciones no esenciales cuando el usuario lo solicita:

@media (prefers-reduced-motion: reduce) {
 *,
 *::before,
 *::after {
 animation-duration: 0.01ms !important;
 animation-iteration-count: 1 !important;
 transition-duration: 0.01ms !important;
 }
}

Warning

Ignorar prefers-reduced-motion es un fallo de accesibilidad real. Reserva las animaciones llamativas para lo decorativo y asegúrate de que la interfaz siga siendo plenamente funcional cuando el movimiento se reduce.

Rendimiento: anima en la capa de composición

La misma regla de oro de las transiciones aplica aquí: anima propiedades que solo afecten la etapa de composición del navegador —transform y opacity— en lugar de propiedades que disparen layout o paint (width, height, top, left, margin).

/* ❌ Costoso: recalcula layout en cada frame */
@keyframes mover-malo { to { left: 200px; } }

/* ✅ Eficiente: solo composición, fluido a 60 fps */
@keyframes mover-bien { to { transform: translateX(200px); } }

Tip

Si una animación se ve entrecortada, lo primero que debes revisar es qué propiedades estás animando. Reescribir un left/top como transform: translate() suele eliminar el jank de inmediato.

Conclusión

Las animaciones con @keyframes te dan un lenguaje declarativo para describir movimiento complejo: secuencias multipaso, bucles infinitos y comportamientos compuestos, todo en CSS puro. Dominar la propiedad animation y sus subpropiedades —especialmente fill-mode, iteration-count y play-state— te permite construir spinners, indicadores de carga y microinteracciones pulidas. Y recuerda: anima transform y opacity, y respeta siempre prefers-reduced-motion.

Note

🚀 Con esta entrega completas el recorrido de la serie Estilos CSS: desde la cascada y los selectores hasta el layout, el posicionamiento, los fondos, las transformaciones y, ahora, las animaciones. Tienes el repertorio completo para escribir CSS expresivo, accesible y de alto rendimiento.

SQL: Consultas a Múltiples Tablas con JOINs

Dacadev — Wed, 17 Jun 2026 00:00:00 -0500

Tabla de Contenido

Cuando una aplicación modela procesos reales, una sola tabla rara vez contiene todo el contexto. Clientes requieren direcciones, películas requieren actores y reportes operativos combinan varias entidades. Por eso, dominar consultas a múltiples tablas y entender cada JOIN en SQL es clave para escribir consultas correctas, expresivas y mantenibles.

En el artículo anterior trabajamos agrupamiento y funciones agregadas. Ahora conectaremos ese análisis con relaciones entre tablas.

Note

Aprenderás a usar INNER JOIN, unir tres o más tablas, reutilizar tablas con alias, aplicar SELF JOIN y combinar resultados con UNION, INTERSECT y EXCEPT.

Producto cartesiano

El producto cartesiano aparece cuando haces un JOIN entre dos tablas sin definir la condición que relaciona sus filas. SQL combina cada fila de la primera tabla con cada fila de la segunda.

mysql> SELECT c.first_name, c.last_name, a.address
 -> FROM customer c JOIN address a;
+------------+-----------+----------------------+
| first_name | last_name | address |
+------------+-----------+----------------------+
| MARY | SMITH | 47 MySakila Drive |
| PATRICIA | JOHNSON | 47 MySakila Drive |
| LINDA | WILLIAMS | 47 MySakila Drive |
...
| FREDDIE | DUGGAN | 1325 Fukuyama Street |
| WADE | DELVALLE | 1325 Fukuyama Street |
| AUSTIN | CINTRON | 1325 Fukuyama Street |
+------------+-----------+----------------------+
361197 rows in set (0.03 sec)

El resultado tiene 361,197 filas porque customer tiene 599 registros y address tiene 603: 599 * 603 = 361197. Normalmente esto indica que falta una condición ON.

Warning

Un JOIN sin condición explícita puede multiplicar el volumen de datos y degradar el rendimiento. Revisa siempre que exista una relación clara entre las tablas.

Inner Join

El INNER JOIN retorna solo las filas que tienen coincidencia en ambas tablas según la condición definida en ON.

mysql> SELECT c.first_name, c.last_name, a.address
 -> FROM customer c JOIN address a
 -> ON c.address_id = a.address_id;
+-------------+--------------+----------------------------------------+
| first_name | last_name | address |
+-------------+--------------+----------------------------------------+
| MARY | SMITH | 1913 Hanoi Way |
| PATRICIA | JOHNSON | 1121 Loja Avenue |
| LINDA | WILLIAMS | 692 Joliet Street |
...
| FREDDIE | DUGGAN | 1103 Quilmes Boulevard |
| WADE | DELVALLE | 1331 Usak Boulevard |
| AUSTIN | CINTRON | 1325 Fukuyama Street |
+-------------+--------------+----------------------------------------+
599 rows in set (0.00 sec)

Aunque muchos motores interpretan JOIN como INNER JOIN, escribirlo explícitamente mejora la legibilidad cuando aparecen otros tipos de unión.

SELECT c.first_name, c.last_name, a.address
FROM customer c INNER JOIN address a
 ON c.address_id = a.address_id;

Unir 3 o más tablas

Para unir más de dos tablas, repetimos el patrón: otro INNER JOIN y otra condición ON.

mysql> SELECT c.first_name, c.last_name, ct.city
 -> FROM customer c
 -> INNER JOIN address a
 -> ON c.address_id = a.address_id
 -> INNER JOIN city ct
 -> ON a.city_id = ct.city_id;
+-------------+--------------+----------------------------+
| first_name | last_name | city |
+-------------+--------------+----------------------------+
| JULIE | SANCHEZ | A Corua (La Corua) |
| PEGGY | MYERS | Abha |
| TOM | MILNER | Abu Dhabi |
...
| BYRON | BOX | Zhezqazghan |
| GUY | BROWNLEE | Zhoushan |
| RONNIE | RICKETTS | Ziguinchor |
+-------------+--------------+----------------------------+
599 rows in set (0.03 sec)

Info

SQL es declarativo: describes qué resultado necesitas y el optimizador decide cómo ejecutarlo. El orden textual de las tablas no necesariamente define el orden físico del plan.

Subqueries como tablas

Una subquery puede actuar como tabla derivada dentro de un JOIN.

SELECT c.first_name, c.last_name, addr.address, addr.city
 -> FROM customer c
 -> INNER JOIN
 -> (SELECT a.address_id, a.address, ct.city
 -> FROM address a
 -> INNER JOIN city ct
 -> ON a.city_id = ct.city_id
 -> WHERE a.district = 'California'
 -> ) addr
 -> ON c.address_id = addr.address_id;
+------------+-----------+------------------------+----------------+
| first_name | last_name | address | city |
+------------+-----------+------------------------+----------------+
| PATRICIA | JOHNSON | 1121 Loja Avenue | San Bernardino |
| BETTY | WHITE | 770 Bydgoszcz Avenue | Citrus Heights |
| ALICE | STEWART | 1135 Izumisano Parkway | Fontana |
...
| JACOB | LANCE | 1866 al-Qatif Avenue | El Monte |
| RENE | MCALISTER | 1895 Zhezqazghan Drive | Garden Grove |
+------------+-----------+------------------------+----------------+
9 rows in set (0.00 sec)

Aquí addr contiene direcciones de California junto con su ciudad, y luego se une con customer mediante address_id.

Misma tabla dos veces

Algunas consultas necesitan aplicar condiciones distintas sobre la misma entidad. Para eso usamos alias diferentes, incluso si la tabla física es la misma.

mysql> SELECT f.title
 -> FROM film f
 -> INNER JOIN film_actor fa1
 -> ON f.film_id = fa1.film_id
 -> INNER JOIN actor a1
 -> ON fa1.actor_id = a1.actor_id
 -> INNER JOIN film_actor fa2
 -> ON f.film_id = fa2.film_id
 -> INNER JOIN actor a2
 -> ON fa2.actor_id = a2.actor_id
 -> WHERE (a1.first_name = 'CATE' AND a1.last_name = 'MCQUEEN')
 -> AND (a2.first_name = 'CUBA' AND a2.last_name = 'BIRCH');
+------------------+
| title |
+------------------+
| BLOOD ARGONAUTS |
| TOWERS HURRICANE |
+------------------+
2 rows in set (0.00 sec)

Esta consulta busca películas donde participaron ambos actores. Si declaramos la tabla una sola vez y usamos OR, el significado cambia: buscamos películas donde participó cualquiera de los dos.

mysql> SELECT f.title
 -> FROM film f
 -> INNER JOIN film_actor fa
 -> ON f.film_id = fa.film_id
 -> INNER JOIN actor a
 -> ON fa.actor_id = a.actor_id
 -> WHERE ((a.first_name = 'CATE' AND a.last_name = 'MCQUEEN')
 -> OR (a.first_name = 'CUBA' AND a.last_name = 'BIRCH'));
+----------------------+
| title |
+----------------------+
| ATLANTIS CAUSE |
| BLOOD ARGONAUTS |
| COMMANDMENTS EXPRESS |
...
| VOLCANO TEXAS |
| WATERSHIP FRONTIER |
+----------------------+
54 rows in set (0.00 sec)

Self join

Un self join ocurre cuando una tabla se une consigo misma. Es común en relaciones autorreferenciales: empleados y managers, categorías padre e hijas, o películas y precuelas.

mysql> SELECT f.title, f_prnt.title prequel
 -> FROM film f
 -> INNER JOIN film f_prnt
 -> ON f_prnt.film_id = f.prequel_film_id
 -> WHERE f.prequel_film_id IS NOT NULL;
+-----------------+--------------+
| title | prequel |
+-----------------+--------------+
| FIDDLER LOST II | FIDDLER LOST |
+-----------------+--------------+
1 row in set (0.00 sec)

f representa la película actual y f_prnt representa la película relacionada como precuela. Los alias son obligatorios para evitar ambigüedad.

Teoría de conjuntos

SQL también trabaja con conjuntos completos de filas. Estas operaciones combinan resultados de múltiples consultas, siempre que las columnas sean compatibles.

La unión combina los elementos de A y B.

La intersección conserva únicamente los elementos presentes en ambos conjuntos.

La diferencia retorna los elementos de A que no están en B.

Note

Para aplicar operaciones de conjuntos, ambas consultas deben retornar el mismo número de columnas y columnas compatibles por posición.

UNION

UNION combina resultados y elimina duplicados. UNION ALL conserva todos los registros, por lo que suele ser más eficiente cuando no necesitas deduplicar.

mysql> SELECT 'CUST' typ, c.first_name, c.last_name
 -> FROM customer c
 -> UNION ALL
 -> SELECT 'ACTR' typ, a.first_name, a.last_name
 -> FROM actor a;
+------+------------+-------------+
| typ | first_name | last_name |
+------+------------+-------------+
| CUST | MARY | SMITH |
| CUST | PATRICIA | JOHNSON |
| CUST | LINDA | WILLIAMS |
...
| ACTR | MARY | KEITEL |
| ACTR | JULIA | FAWCETT |
| ACTR | THORA | TEMPLE |
+------+------------+-------------+
799 rows in set (0.00 sec)

Si duplicamos la misma consulta contra actor, UNION ALL devuelve dos copias de cada fila.

mysql> SELECT 'ACTR' typ, a.first_name, a.last_name
 -> FROM actor a
 -> UNION ALL
 -> SELECT 'ACTR' typ, a.first_name, a.last_name
 -> FROM actor a;
+------+-------------+--------------+
| typ | first_name | last_name |
+------+-------------+--------------+
| ACTR | PENELOPE | GUINESS |
| ACTR | NICK | WAHLBERG |
| ACTR | ED | CHASE |
...
| ACTR | MARY | KEITEL |
| ACTR | JULIA | FAWCETT |
| ACTR | THORA | TEMPLE |
+------+-------------+--------------+
400 rows in set (0.00 sec)

Un ejemplo más claro muestra duplicados al combinar clientes y actores con patrones similares:

mysql> SELECT c.first_name, c.last_name
 -> FROM customer c
 -> WHERE c.first_name LIKE 'J%' AND c.last_name LIKE 'D%'
 -> UNION ALL
 -> SELECT a.first_name, a.last_name
 -> FROM actor a
 -> WHERE a.first_name LIKE 'J%' AND a.last_name LIKE 'D%';
+------------+-----------+
| first_name | last_name |
+------------+-----------+
| JENNIFER | DAVIS |
| JENNIFER | DAVIS |
| JUDY | DEAN |
| JODIE | DEGENERES |
| JULIANNE | DENCH |
+------------+-----------+
5 rows in set (0.00 sec)

INTERSECT

INTERSECT retorna únicamente las filas presentes en ambos conjuntos. Dependiendo del motor, puede existir INTERSECT ALL, que conserva duplicados según sus reglas.

Es útil para encontrar coincidencias entre fuentes: identificadores compartidos, productos presentes en dos catálogos o usuarios existentes en dos procesos.

EXCEPT

EXCEPT retorna las filas del primer conjunto que no aparecen en el segundo. También puede existir EXCEPT ALL, según el motor.

Esta operación es práctica para auditoría y reconciliación de datos.

Warning

Algunos motores no implementan INTERSECT, EXCEPT o sus variantes ALL. En esos casos puedes modelar equivalentes con JOIN, NOT EXISTS o LEFT JOIN.

Reglas de operaciones de conjuntos

Las operaciones de conjuntos son estrictas: mismo número de columnas, tipos compatibles y mismo orden.

Ordenar resultados con alias válidos

Si ordenas el resultado final, usa los nombres expuestos por el primer SELECT. En este ejemplo, last_name y first_name ya no son etiquetas válidas porque fueron renombradas como lname y fname.

-- ERROR
mysql> SELECT a.first_name fname, a.last_name lname
 -> FROM actor a
 -> WHERE a.first_name LIKE 'J%' AND a.last_name LIKE 'D%'
 -> UNION ALL
 -> SELECT c.first_name, c.last_name
 -> FROM customer c
 -> WHERE c.first_name LIKE 'J%' AND c.last_name LIKE 'D%'
 -> ORDER BY last_name, first_name;
ERROR 1054 (42S22): Unknown column 'last_name' in 'order clause'

-- WORKS
mysql> SELECT a.first_name fname, a.last_name lname
 -> FROM actor a
 -> WHERE a.first_name LIKE 'J%' AND a.last_name LIKE 'D%'
 -> UNION ALL
 -> SELECT c.first_name, c.last_name
 -> FROM customer c
 -> WHERE c.first_name LIKE 'J%' AND c.last_name LIKE 'D%'
 -> ORDER BY lname, fname;
+----------+-----------+
| fname | lname |
+----------+-----------+
| JENNIFER | DAVIS |
| JENNIFER | DAVIS |
| JUDY | DEAN |
| JODIE | DEGENERES |
| JULIANNE | DENCH |
+----------+-----------+
5 rows in set (0.00 sec)

El orden de las operaciones importa

Las uniones se evalúan según el orden y la precedencia del motor. Cuando mezcles UNION, INTERSECT y EXCEPT, usa paréntesis para expresar intención y evitar resultados ambiguos.

Reglas prácticas:

Los alias visibles provienen del primer SELECT.
UNION elimina duplicados; UNION ALL los conserva.
ORDER BY se aplica al conjunto final, salvo que uses subqueries.
El orden de operaciones puede cambiar el resultado.

Cierre

Los JOINs y las operaciones de conjuntos resuelven problemas complementarios. INNER JOIN conecta filas relacionadas; UNION, INTERSECT y EXCEPT combinan resultados compatibles.

Dominar ambos enfoques mejora la semántica de reportes, filtros e integraciones. En el siguiente artículo avanzaremos hacia Subqueries, donde veremos subconsultas para construir lógica SQL modular.

Estilos CSS: Modularización y patrones de diseño

Dacadev — Tue, 16 Jun 2026 00:00:00 -0500

Tabla de Contenido

En un proyecto pequeño cualquier organización de CSS funciona. El problema aparece al escalar: hojas de estilo de miles de líneas donde tocar una regla rompe tres componentes que parecían no tener relación. La causa casi siempre es la misma: estilos acoplados que se pisan entre sí. La solución es arquitectónica —modularizar— y existen metodologías probadas para lograrlo.

Esta es la octava y última entrega de la serie Estilos CSS. Veremos cómo estructurar estilos en módulos independientes, la metodología BEM, las clases de utilidad y cómo documentar tus componentes con una librería de patrones.

Note

Aprenderás a dividir tus estilos en componentes desacoplados, a nombrar clases con BEM, a usar utility classes con criterio y a mantener una librería de patrones como fuente única de verdad del diseño.

Qué es la modularización

Modularizar CSS consiste en dividir los estilos en archivos donde cada uno representa un módulo: un único componente con todo su estilo encapsulado. Un módulo button.css contiene todo lo necesario para renderizar un botón y sus variantes, y nada más.

Tip

La regla de oro: un módulo no debe interferir con los estilos de otros. Solo se ocupa de su propio componente. Así, modificar un módulo nunca produce efectos colaterales inesperados en el resto de la página.

Estilos base

Antes de los módulos conviene tener un archivo de estilos base: no es un componente, sino la configuración inicial del documento (reset, tipografía global, box-sizing).

:root { box-sizing: border-box; }

*, *::before, *::after { box-sizing: inherit; }

body { font-family: Helvetica, Arial, sans-serif; }

Para no reinventar la rueda, paquetes como Normalize.css homogeneizan las diferencias entre navegadores de forma sensata.

Componentes y BEM

La idea central de un módulo es que los estilos y modificadores de un componente vivan en un solo lugar. La metodología BEM (Block, Element, Modifier) propone una convención de nombres que hace explícita la estructura y evita colisiones:

Block — el componente raíz: .button.
Element — una parte del componente, con __: .button__icon.
Modifier — una variante, con --: .button--success.

.button {
 padding: 0.5em 0.8em;
 border: 1px solid #265559;
 border-radius: 0.2em;
 background-color: transparent;
 font-size: 1rem;
}

.button--success { color: #fff; background-color: #2f5926; border-color: #cfe8c9; }
.button--danger { color: #fff; background-color: #a92323; border-color: #e8c9c9; }
.button--small { font-size: 0.8rem; }
.button--large { font-size: 1.2rem; }

<button class="button">Normal</button>
<button class="button button--success">Éxito</button>
<button class="button button--danger">Peligro</button>
<button class="button button--large">Grande</button>

Posicionamiento del componente

Por buena práctica, el bloque raíz de un componente debería declarar position: relative. Así estableces un contexto de posicionamiento controlado para cualquier elemento absoluto interno (un menú desplegable, un badge, un tooltip), sin depender de ancestros externos.

Estado de los componentes

Es común reflejar el estado de un componente con clases, ya sea para estilizarlo o para manipularlo desde JavaScript. La convención recomendada usa verbos o estados con prefijo: is-loading, has-error, is-active.

Warning

No mezcles las clases de estado con los modificadores BEM. Evita nombres como block__element--modifier-is-loading. El estado es una capa transversal y dinámica; mantenlo separado de la variante estática del componente.

Utility classes

Las clases de utilidad aplican un estilo único y específico. Suelen usar !important para garantizar que se apliquen por encima de los estilos del componente:

.text-center { text-align: center !important; }
.float-left { float: left; }
.hidden { display: none !important; }

.clearfix::before,
.clearfix::after { content: " "; display: table; }
.clearfix::after { clear: both; }

Son útiles para ajustes puntuales, pero abusar de ellas reintroduce el acoplamiento que la modularización busca evitar. Úsalas con criterio.

Metodologías de arquitectura CSS

BEM no es la única opción. Las metodologías más establecidas para organizar CSS a escala son:

OOCSS — Object-Oriented CSS, de Nicole Sullivan: separa estructura de apariencia.
SMACSS — Scalable and Modular Architecture for CSS, de Jonathan Snook: categoriza las reglas en capas.
BEM — Block, Element, Modifier, de Yandex: convención de nombres explícita.
ITCSS — Inverted Triangle CSS, de Harry Roberts: organiza por especificidad creciente.

No son excluyentes; muchos equipos combinan ITCSS para la estructura de archivos con BEM para la nomenclatura.

Librerías de patrones

En proyectos grandes, los componentes se documentan en una librería de patrones (o style guide): una web accesible para todo el equipo que muestra cómo se ve y se comporta cada componente. Es la fuente única de verdad del diseño y reduce las inconsistencias.

Existen generadores de style guides; uno open source muy conocido es KSS. Documenta los componentes a partir de comentarios estructurados en el propio CSS:

/*
Buttons

Botones disponibles en varios tamaños y colores.

Markup:
<button class="button {{modifier_class}}">click here</button>

.button--success - Botón verde de éxito
.button--danger - Botón rojo de peligro
.button--large - Botón grande

Styleguide Buttons
*/
.button { /* ... */ }

KSS lee esos comentarios y genera automáticamente una página de documentación con el componente renderizado y todas sus variantes. El bloque incluye un título, una descripción, el Markup de ejemplo (con el marcador {{modifier_class}}), la lista de modificadores y una referencia Styleguide para ubicarlo en la jerarquía.

Info

Mantener la documentación junto al código —en comentarios del propio CSS— reduce el riesgo de que la librería de patrones quede desactualizada respecto a la implementación real.

Conclusión

Escribir CSS que escale es, ante todo, un problema de arquitectura. Modularizar en componentes desacoplados, nombrar con una convención consistente como BEM, reservar las utility classes para ajustes puntuales y documentar todo en una librería de patrones es lo que mantiene una hoja de estilos sana a medida que el proyecto crece.

Con esta entrega cerramos la serie Estilos CSS. Recorrimos desde los fundamentos de la cascada hasta la arquitectura de estilos a gran escala, pasando por selectores, el modelo de caja, layouts, posicionamiento, fondos y animaciones. Tienes ahora un modelo mental completo para escribir CSS profesional, predecible y mantenible.

Note

🚀 Repasa las entregas anteriores para consolidar cada concepto: los fundamentos sostienen los selectores, el modelo de caja sostiene los layouts, y la modularización une todo en un sistema coherente.

Estilos CSS: Transiciones, transformaciones y rendimiento

Dacadev — Sun, 14 Jun 2026 00:00:00 -0500

Tabla de Contenido

Las transiciones y transformaciones son la puerta de entrada a las interfaces animadas. Una transición suaviza el cambio entre dos estados; una transformación altera la geometría visual de un elemento sin afectar el layout. Bien aplicadas, mejoran la percepción de calidad y guían la atención del usuario. Mal aplicadas, generan jank y consumen batería. La diferencia está en entender qué propiedades son baratas de animar y por qué.

Esta es la séptima entrega de la serie Estilos CSS. Cubriremos la propiedad transition y sus timing functions, las funciones de transform en 2D y 3D, y el pipeline de renderizado que explica por qué transform y opacity son las propiedades óptimas para animar.

Note

Aprenderás a construir transiciones fluidas con curvas de Bézier, a aplicar y combinar transformaciones, y a entender el pipeline layout → paint → composición para escribir animaciones eficientes.

Transiciones

Una transición interpola el cambio de una propiedad entre su valor inicial y final a lo largo del tiempo. Suele combinarse con pseudo-clases como :hover o :active. Se controla con cuatro propiedades:

transition-property: background-color, transform;
transition-duration: 0.3s, 0.6s;
transition-timing-function: ease, linear;
transition-delay: 0s, 100ms;

transition-property — qué propiedades se animan (usa all para todas).
transition-duration — cuánto dura la interpolación.
transition-timing-function — cómo se distribuye el movimiento en el tiempo.
transition-delay — cuánto espera antes de empezar (opcional).

.boton { transition: background-color 0.3s ease, transform 0.3s ease; }
.boton:hover { background-color: #16828d; transform: translateY(-3px); }

Timing functions

La timing function define cómo se reparte el movimiento en el tiempo. Existen valores predefinidos —linear, ease, ease-in, ease-out, ease-in-out— donde el eje X representa el tiempo y el eje Y el progreso del cambio.

Todas son curvas de Bézier, y puedes definir la tuya con la función cubic-bezier():

.box { transition: transform 0.6s cubic-bezier(0.45, 0.05, 0.55, 0.95); }

También puedes hacer el cambio en pasos discretos con steps(), útil para animaciones tipo sprite o efectos de “tecleo”:

.box { transition: all 1s steps(3); }

Tip

Existen editores visuales de curvas de Bézier que te permiten ajustar la animación y copiar el valor exacto. Experimentar con ellos es la forma más rápida de afinar la sensación de una transición.

Transformaciones

La propiedad transform altera la geometría visual de un elemento mediante cuatro operaciones:

scale() — escala el tamaño.
rotate() — rota el elemento.
translate() — lo desplaza.
skew() — lo inclina/estira.

Warning

Las transformaciones solo alteran la representación visual del elemento, no su comportamiento en el layout. El hueco original que ocupaba se conserva, y los elementos vecinos no se reorganizan.

Rotación

rotate() gira el elemento. Los valores positivos giran en sentido horario; los negativos, antihorario.

.giro { transform: rotate(15deg); }

Traslación

translate(x, y) mueve el elemento en ambos ejes sin afectar el flujo. Los valores positivos lo desplazan a la derecha y hacia abajo.

.mover { transform: translate(40px, 10px); }

Escala

scale() redimensiona: valores entre 0 y 1 encogen, mayores que 1 agrandan.

.crecer { transform: scale(1.3); }

Inclinación

skew(x, y) deforma el elemento inclinándolo respecto a los ejes.

.inclinar { transform: skew(-12deg); }

rotate translate scale skew

Punto de referencia: transform-origin

Toda transformación se aplica desde un punto de referencia, que por defecto es el centro del elemento. transform-origin lo reubica:

.giro { transform-origin: left center; } /* equivale a 0% 50% */

Combinar transformaciones

Puedes encadenar varias funciones separándolas por espacios. Se aplican de derecha a izquierda, lo que afecta el resultado final:

.tarjeta { transform: rotate(15deg) translate(20px, 0); }

El pipeline de renderizado

Para escribir animaciones eficientes hay que entender cómo el navegador dibuja una página. El proceso tiene tres etapas clave:

Layout — el navegador calcula las dimensiones y posiciones de todos los elementos. Cualquier cambio de tamaño o posición dispara un recálculo completo (reflow).
Paint — pinta en memoria los píxeles de cada elemento (colores, bordes, sombras), posiblemente en capas separadas.
Composición — combina las capas pintadas para mostrarlas en pantalla.

flowchart LR
 A[JS / CSS] --> B[Layout]
 B --> C[Paint]
 C --> D[Composición]

La clave del rendimiento: algunas propiedades, como transform y opacity, solo afectan la etapa de composición. No requieren recalcular el layout ni repintar, por lo que son las propiedades óptimas para animar de forma fluida a 60 fps.

Tip

Prefiere animar transform y opacity en lugar de width, height, top o left. Estas últimas disparan layout y paint en cada frame, lo que produce animaciones entrecortadas.

Transformaciones en 3D

transform también opera en tres dimensiones. Puedes rotar sobre cualquier eje con rotateX(), rotateY() y rotateZ(). El efecto depende de la perspectiva: la distancia simulada entre el observador y el elemento. A menor perspectiva, más pronunciado el efecto 3D.

Hay dos formas de aplicarla:

/* 1. Función dentro de transform (afecta solo a ese elemento) */
.box { transform: perspective(200px) rotateX(30deg); }

/* 2. Propiedad en el contenedor (perspectiva compartida) */
.row { perspective: 200px; }
.box { transform: rotateX(30deg); }

rotateX(35deg)

rotateY(35deg)

Una rotación de 180° voltea el elemento como un espejo. La propiedad backface-visibility controla si la cara trasera es visible, lo que habilita efectos como las tarjetas que se voltean. Un recurso clásico para profundizar es Intro to CSS 3D transforms.

Conclusión

Las transiciones suavizan los cambios de estado y las transformaciones manipulan la geometría sin tocar el layout. La regla de oro del rendimiento es animar transform y opacity, que solo afectan la etapa de composición. Con curvas de Bézier afinadas y un uso consciente del pipeline, tus animaciones serán fluidas y eficientes.

Note

🚀 La entrega final de la serie aborda la modularización y los patrones de diseño en CSS: cómo organizar tus estilos en componentes mantenibles con metodologías como BEM.

SQL: Agrupamiento y Funciones Agregadas con GROUP BY

Dacadev — Sun, 14 Jun 2026 00:00:00 -0500

Tabla de Contenido

Cuando una tabla empieza a acumular miles o millones de filas, consultar registros individuales deja de ser suficiente. En análisis, reportes y validaciones operativas necesitamos resumir datos: cuántas rentas hizo cada cliente, cuánto pagó en total, cuál fue el monto máximo o qué categorías concentran más actividad. Para eso usamos agrupamiento en SQL con GROUP BY y funciones agregadas como COUNT, SUM, AVG, MIN y MAX.

Este es el artículo 4 de la serie SQL. Venimos de trabajar con lógica condicional con CASE, y ahora vamos a convertir filas transaccionales en resultados agregados listos para análisis.

Note

En este artículo aprenderás a usar GROUP BY, ordenar grupos con ORDER BY, filtrar agregaciones con HAVING, contar valores distintos con DISTINCT y crear agrupaciones por una columna, múltiples columnas o expresiones.

Conceptos de agrupamiento en SQL

GROUP BY toma filas que comparten el mismo valor en una o más expresiones y las compacta en un grupo lógico. Si seleccionamos únicamente customer_id desde rental, SQL puede devolver cada cliente una sola vez:

mysql> SELECT customer_id
 -> FROM rental
 -> GROUP BY customer_id;
+-------------+
| customer_id |
+-------------+
| 1 |
| 2 |
| 3 |
| 4 |
| 5 |
| 6 |
...
| 594 |
| 595 |
| 596 |
| 597 |
| 598 |
| 599 |
+-------------+
599 rows in set (0.00 sec)

El resultado ya no representa rentas individuales, sino el conjunto de clientes que aparecen en la tabla. El siguiente paso natural es medir cuántas filas contiene cada grupo. Para eso usamos COUNT(*):

mysql> SELECT customer_id, count(*)
 -> FROM rental
 -> GROUP BY customer_id;
+-------------+----------+
| customer_id | count(*) |
+-------------+----------+
| 1 | 32 |
| 2 | 27 |
| 3 | 26 |
| 4 | 22 |
| 5 | 38 |
| 6 | 28 |
...
| 594 | 27 |
| 595 | 30 |
| 596 | 28 |
| 597 | 25 |
| 598 | 22 |
| 599 | 19 |
+-------------+----------+
599 rows in set (0.01 sec)

Info

COUNT(*) le indica a SQL que cuente todas las filas contenidas dentro de cada grupo definido por GROUP BY. No cuenta clientes únicos; cuenta filas dentro del grupo actual.

Ordenar resultados agregados con `ORDER BY`

Una agregación suele ser más útil cuando puedes priorizarla. Por ejemplo, para identificar los clientes con más rentas, ordenamos por la segunda columna del SELECT, que en este caso es count(*):

mysql> SELECT customer_id, count(*)
 -> FROM rental
 -> GROUP BY customer_id
 -> ORDER BY 2 DESC;
+-------------+----------+
| customer_id | count(*) |
+-------------+----------+
| 148 | 46 |
| 526 | 45 |
| 236 | 42 |
| 144 | 42 |
| 75 | 41 |
...
| 248 | 15 |
| 110 | 14 |
| 281 | 14 |
| 61 | 14 |
| 318 | 12 |
+-------------+----------+
599 rows in set (0.01 sec)

Tip

ORDER BY puede usar el nombre de una columna, un alias o la posición de la columna dentro del SELECT. Aun así, en consultas mantenibles suele ser más claro usar alias explícitos.

Filtrar grupos con `HAVING`

WHERE filtra filas antes de que ocurra el agrupamiento. HAVING, en cambio, filtra grupos después de calcular las agregaciones. Esta diferencia es crítica: no puedes usar WHERE count(*) >= 40 porque count(*) todavía no existe en esa fase lógica de la consulta.

Consideremos clientes con al menos 40 rentas:

mysql> SELECT customer_id, count(*)
 -> FROM rental
 -> GROUP BY customer_id
 -> HAVING count(*) >= 40;
+-------------+----------+
| customer_id | count(*) |
+-------------+----------+
| 75 | 41 |
| 144 | 42 |
| 148 | 46 |
| 197 | 40 |
| 236 | 42 |
| 469 | 40 |
| 526 | 45 |
+-------------+----------+
7 rows in set (0.01 sec)

Analicemos el flujo conceptual: FROM obtiene las filas, WHERE descarta filas individuales, GROUP BY crea grupos, las funciones agregadas calculan métricas y HAVING descarta grupos completos. Por último, ORDER BY organiza el resultado final.

Funciones agregadas comunes

Las bases de datos implementan distintas funciones agregadas, pero estas aparecen prácticamente en cualquier motor SQL:

Función	Qué devuelve
`MAX()`	El valor máximo dentro de un conjunto
`MIN()`	El valor mínimo dentro de un conjunto
`AVG()`	El promedio de los valores del conjunto
`SUM()`	La suma total de los valores del conjunto
`COUNT()`	La cantidad de valores o filas del conjunto

Sin GROUP BY, estas funciones operan sobre toda la tabla o sobre el conjunto filtrado por WHERE. Observemos un resumen global de pagos:

mysql> SELECT MAX(amount) max_amt,
 -> MIN(amount) min_amt,
 -> AVG(amount) avg_amt,
 -> SUM(amount) tot_amt,
 -> COUNT(*) num_payments
 -> FROM payment;
+---------+---------+----------+----------+--------------+
| max_amt | min_amt | avg_amt | tot_amt | num_payments |
+---------+---------+----------+----------+--------------+
| 11.99 | 0.00 | 4.200667 | 67416.51 | 16049 |
+---------+---------+----------+----------+--------------+
1 row in set (0.09 sec)

Aquí SQL devuelve una sola fila porque existe un grupo implícito: todo el resultado de payment.

Grupos implícitos vs grupos explícitos

Cuando usamos una función agregada sin GROUP BY, SQL resume todo el conjunto como un único grupo. Eso es útil para métricas globales, pero no sirve si necesitamos una métrica por cliente, actor, categoría o periodo.

Para obtener métricas por cliente, definimos el grupo explícitamente:

mysql> SELECT customer_id,
 -> MAX(amount) max_amt,
 -> MIN(amount) min_amt,
 -> AVG(amount) avg_amt,
 -> SUM(amount) tot_amt,
 -> COUNT(*) num_payments
 -> FROM payment
 -> GROUP BY customer_id;
+-------------+---------+---------+----------+---------+--------------+
| customer_id | max_amt | min_amt | avg_amt | tot_amt | num_payments |
+-------------+---------+---------+----------+---------+--------------+
| 1 | 9.99 | 0.99 | 3.708750 | 118.68 | 32 |
| 2 | 10.99 | 0.99 | 4.767778 | 128.73 | 27 |
| 3 | 10.99 | 0.99 | 5.220769 | 135.74 | 26 |
| 4 | 8.99 | 0.99 | 3.717273 | 81.78 | 22 |
| 5 | 9.99 | 0.99 | 3.805789 | 144.62 | 38 |
| 6 | 7.99 | 0.99 | 3.347143 | 93.72 | 28 |
...
| 594 | 8.99 | 0.99 | 4.841852 | 130.73 | 27 |
| 595 | 10.99 | 0.99 | 3.923333 | 117.70 | 30 |
| 596 | 6.99 | 0.99 | 3.454286 | 96.72 | 28 |
| 597 | 8.99 | 0.99 | 3.990000 | 99.75 | 25 |
| 598 | 7.99 | 0.99 | 3.808182 | 83.78 | 22 |
| 599 | 9.99 | 0.99 | 4.411053 | 83.81 | 19 |
+-------------+---------+---------+----------+---------+--------------+
599 rows in set (0.04 sec)

La regla práctica es directa: cualquier columna no agregada en el SELECT debe representar la granularidad del resultado y, por lo tanto, debe estar en el GROUP BY.

Warning

Algunos motores permiten seleccionar columnas que no están agrupadas ni agregadas, pero el resultado puede ser ambiguo o depender de configuraciones del motor. Para consultas portables y correctas, declara explícitamente la granularidad.

Contar valores distintos con `COUNT(DISTINCT ...)`

COUNT(*) cuenta filas. COUNT(columna) cuenta valores no nulos de esa columna. COUNT(DISTINCT columna) cuenta valores únicos, ignorando duplicados.

Esto permite diferenciar entre el número de pagos registrados y el número de clientes distintos que hicieron pagos:

mysql> SELECT COUNT(customer_id) num_rows,
 -> COUNT(DISTINCT customer_id) num_customers
 -> FROM payment;
+----------+---------------+
| num_rows | num_customers |
+----------+---------------+
| 16049 | 599 |
+----------+---------------+
1 row in set (0.01 sec)

Observemos que num_rows refleja eventos de pago, mientras num_customers refleja entidades únicas. Esa distinción evita errores frecuentes en reportes, especialmente cuando mezclamos métricas transaccionales con métricas de negocio.

Generar grupos según la granularidad requerida

La calidad de una consulta agregada depende de elegir la granularidad correcta. No es lo mismo agrupar por cliente, por cliente y mes, por actor y clasificación, o por una expresión derivada de una fecha.

Agrupamiento por una columna

Agrupar por una sola columna es el caso base. En este ejemplo obtenemos cuántas películas tiene asociadas cada actor:

mysql> SELECT actor_id, count(*)
 -> FROM film_actor
 -> GROUP BY actor_id;
+----------+----------+
| actor_id | count(*) |
+----------+----------+
| 1 | 19 |
| 2 | 25 |
| 3 | 22 |
| 4 | 22 |
...
| 197 | 33 |
| 198 | 40 |
| 199 | 15 |
| 200 | 20 |
+----------+----------+
200 rows in set (0.11 sec)

Info

En este resultado cada fila representa un actor y el conteo de películas en las que participa. La consulta ya no describe relaciones individuales actor-película, sino un resumen por actor.

Agrupamiento por múltiples columnas

En algunos casos necesitamos generar grupos que combinen más de una columna. Por ejemplo, contar cuántas películas tiene cada actor por clasificación (G, PG, PG-13, R, NC-17):

mysql> SELECT fa.actor_id, f.rating, count(*)
 -> FROM film_actor fa
 -> INNER JOIN film f
 -> ON fa.film_id = f.film_id
 -> GROUP BY fa.actor_id, f.rating
 -> ORDER BY 1,2;
+----------+--------+----------+
| actor_id | rating | count(*) |
+----------+--------+----------+
| 1 | G | 4 |
| 1 | PG | 6 |
| 1 | PG-13 | 1 |
| 1 | R | 3 |
| 1 | NC-17 | 5 |
| 2 | G | 7 |
| 2 | PG | 6 |
| 2 | PG-13 | 2 |
| 2 | R | 2 |
| 2 | NC-17 | 8 |
...
| 199 | G | 3 |
| 199 | PG | 4 |
| 199 | PG-13 | 4 |
| 199 | R | 2 |
| 199 | NC-17 | 2 |
| 200 | G | 5 |
| 200 | PG | 3 |
| 200 | PG-13 | 2 |
| 200 | R | 6 |
| 200 | NC-17 | 4 |
+----------+--------+----------+
996 rows in set (0.01 sec)

Aquí la granularidad ya no es “actor”, sino “actor + clasificación”. Cada combinación única genera su propio grupo. Esta técnica es la base para reportes multidimensionales y pivotes posteriores en herramientas de BI.

Agrupamiento mediante expresiones

GROUP BY no está limitado a columnas físicas. También puede agrupar por expresiones, funciones o transformaciones calculadas. Esto es especialmente útil con fechas.

El siguiente ejemplo agrupa rentas por año:

mysql> SELECT extract(YEAR FROM rental_date) year,
 -> COUNT(*) how_many
 -> FROM rental
 -> GROUP BY extract(YEAR FROM rental_date);
+------+----------+
| year | how_many |
+------+----------+
| 2005 | 15862 |
| 2006 | 182 |
+------+----------+
2 rows in set (0.01 sec)

En lugar de agrupar por cada rental_date exacto, reducimos la fecha al año con EXTRACT(YEAR FROM rental_date). El resultado responde una pregunta distinta: volumen anual, no eventos individuales.

Buenas prácticas al trabajar con `GROUP BY`

Para mantener consultas claras y confiables, considera estas reglas:

Define primero la granularidad: una fila por cliente, por cliente y mes, por actor y rating, etc.
Usa alias descriptivos para agregaciones: num_payments, total_amount, avg_amount.
Aplica WHERE para filtrar filas antes de agrupar y HAVING para filtrar grupos.
Evita depender de posiciones como ORDER BY 2 en consultas de producción si un alias mejora la legibilidad.
Verifica si necesitas contar filas (COUNT(*)), valores no nulos (COUNT(columna)) o valores únicos (COUNT(DISTINCT columna)).

Conclusión

GROUP BY cambia la forma en que lees una tabla: pasas de inspeccionar filas individuales a construir resúmenes por la granularidad que necesita tu análisis. Combinado con funciones agregadas, HAVING, DISTINCT y expresiones, se convierte en una herramienta central para reportes, dashboards y validaciones de datos.

En el siguiente artículo de la serie vamos a conectar datos distribuidos entre tablas con consultas a múltiples tablas usando JOINs.

Estilos CSS: Fondos, gradientes y sombras

Dacadev — Fri, 12 Jun 2026 00:00:00 -0500

Tabla de Contenido

Los fondos y las sombras son las herramientas con las que CSS aporta profundidad, textura y jerarquía visual sin necesidad de imágenes externas. Un gradiente bien construido reemplaza un archivo PNG; una sombra sutil comunica que un botón es interactivo. Dominar estas propiedades te permite crear interfaces ricas con código puro, ligero y escalable.

Esta es la sexta entrega de la serie Estilos CSS. Recorreremos la familia de propiedades background, los gradientes lineales y radiales, los modos de mezcla y las sombras de caja y de texto.

Note

Aprenderás a generar gradientes y patrones sin imágenes, a combinar varias capas de fondo y a usar box-shadow y text-shadow para dar realismo y feedback a tus componentes.

La familia background

background es una propiedad abreviada que agrupa ocho propiedades individuales:

background-image — una imagen o un gradiente generado.
background-position — la posición inicial del fondo.
background-size — el tamaño de renderizado (cover, contain, valores explícitos).
background-repeat — si la imagen se repite en mosaico.
background-origin — respecto a qué caja se posiciona (border, padding o content).
background-clip — hasta qué caja se extiende el fondo.
background-attachment — si el fondo se desplaza con el contenido o queda fijo.
background-color — un color sólido que se renderiza detrás de la imagen.

Gradientes lineales

Un gradiente es una transición de colores generada por una función de CSS, sin archivos. linear-gradient() crea una transición a lo largo de una dirección.

.fade { background-image: linear-gradient(to right, #fff, #2a9da9); }

La función acepta una dirección (to right, 90deg, etc.) y una lista de colores. Puedes incluir más de dos colores y fijar su posición con porcentajes:

.fade { background-image: linear-gradient(90deg, #c0392b 0%, #fff 50%, #2a9da9 100%); }

Gradientes lineales repetitivos

repeating-linear-gradient() crea patrones que se repiten, útil para texturas como rayas:

.rayas {
 background-image: repeating-linear-gradient(-45deg,
 #2a9da9, #2a9da9 10px, #16828d 10px, #16828d 20px);
}

Gradientes radiales

radial-gradient() genera una transición circular o elíptica que irradia desde un punto, en lugar de seguir una dirección lineal.

.brillo { background-image: radial-gradient(#fff, #2a9da9); }

Combinar múltiples fondos

Puedes apilar varias capas de fondo separándolas con comas. La primera capa queda al frente. Esto permite, por ejemplo, superponer un gradiente sobre una imagen:

.heroe {
 background-image:
 linear-gradient(to bottom, rgba(42,157,169,0.6), rgba(22,130,141,0.9)),
 url(foto.jpg);
 background-size: cover;
}

Gradiente sobre una textura de fondo

Texturas con blend modes

La propiedad background-blend-mode mezcla las capas de fondo entre sí (con modos como multiply, soft-light, overlay), añadiendo textura a una imagen sin editarla en un programa externo:

.textura {
 background-image: url(rayones.png), url(foto.jpg);
 background-blend-mode: soft-light;
}

Sombras: box-shadow y text-shadow

CSS permite añadir sombras tanto a las cajas (box-shadow) como al texto (text-shadow). Ambas reciben los mismos parámetros básicos:

Desplazamiento horizontal y vertical (offset-x, offset-y).
El radio de difuminado (blur).
(opcional) El radio de expansión (spread).
El color de la sombra.

.tarjeta { box-shadow: 0 0.2em 0.5em rgba(0, 0, 0, 0.25); }
.titulo { text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.4); }

Tarjeta con box-shadow

Texto con text-shadow

Sombras interiores para feedback

La palabra clave inset convierte la sombra en interior, perfecta para simular que un botón está presionado. Combinada con pseudo-clases como :active, crea componentes con feedback táctil:

.boton {
 background-image: linear-gradient(to bottom, #2a9da9, #16828d);
 box-shadow: 0.1em 0.1em 0.5em rgba(0,0,0,0.4);
 color: #fff;
}

.boton:active {
 box-shadow: inset 0 0 0.5em #0d4f56,
 inset 0 0.5em 1em rgba(0,0,0,0.4);
}

Al pulsarlo, la sombra interior simula el hundido físico.

Tip

Las sombras se renderizan en la capa de composición y son baratas de animar. Una transición sutil de box-shadow en :hover comunica interactividad con un costo de rendimiento mínimo.

Conclusión

Los gradientes y las sombras te permiten construir interfaces con profundidad y textura usando solo CSS, evitando peticiones de red y archivos de imagen. Apilar capas de fondo, mezclarlas con blend modes y aplicar sombras interiores son técnicas que elevan la calidad visual de cualquier componente.

Note

🚀 La próxima entrega cubre transiciones y transformaciones: cómo animar cambios de estado de forma fluida y manipular la geometría de los elementos con transform.

SQL: Lógica Condicional con la Expresión CASE

Dacadev — Thu, 11 Jun 2026 00:00:00 -0500

Tabla de Contenido

Cuando una consulta necesita clasificar registros, calcular valores derivados o protegerse de casos límite, la lógica condicional en SQL evita mover decisiones simples a la capa de aplicación. Después de trabajar con filtrado de datos con WHERE, el siguiente paso natural es usar la expresión CASE para transformar resultados directamente dentro del query.

Note

En este artículo analizaremos cómo usar CASE en SQL con condiciones múltiples, validaciones de existencia, protección contra división por cero, actualizaciones condicionales y manejo explícito de valores NULL.

La expresión CASE cumple un rol similar a if / else if / else o switch / case en lenguajes de programación. Su valor está en que opera dentro del motor de base de datos: puedes derivar columnas, etiquetar estados y condicionar cálculos sin postprocesar cada fila en tu backend.

Observemos un primer ejemplo directo. A partir de una columna active, convertimos 1 y 0 en etiquetas más legibles:

mysql> SELECT first_name, last_name,
 -> CASE
 -> WHEN active = 1 THEN 'ACTIVE'
 -> ELSE 'INACTIVE'
 -> END activity_type
 -> FROM customer;
+-------------+--------------+---------------+
| first_name | last_name | activity_type |
+-------------+--------------+---------------+
| MARY | SMITH | ACTIVE |
| PATRICIA | JOHNSON | ACTIVE |
| LINDA | WILLIAMS | ACTIVE |
| BARBARA | JONES | ACTIVE |
| ELIZABETH | BROWN | ACTIVE |
| JENNIFER | DAVIS | ACTIVE |
...
| KENT | ARSENAULT | ACTIVE |
| TERRANCE | ROUSH | INACTIVE |
| RENE | MCALISTER | ACTIVE |
| EDUARDO | HIATT | ACTIVE |
| TERRENCE | GUNDERSON | ACTIVE |
| ENRIQUE | FORSYTHE | ACTIVE |
| FREDDIE | DUGGAN | ACTIVE |
| WADE | DELVALLE | ACTIVE |
| AUSTIN | CINTRON | ACTIVE |
+-------------+--------------+---------------+
599 rows in set (0.00 sec)

La expresión CASE

La expresión CASE evalúa una o varias condiciones y retorna un valor según la primera coincidencia encontrada. En SQL, CASE no es solo una herramienta cosmética; también permite modelar reglas de negocio dentro de consultas, reportes y operaciones UPDATE.

Existen dos variantes principales:

Searched CASE: cada WHEN contiene una condición completa.
Simple CASE: se evalúa una expresión base contra valores específicos.

Info

Si ninguna condición coincide y no defines ELSE, el resultado de CASE será NULL. Conviene declarar ELSE explícitamente cuando el consumidor del dato espera una categoría estable.

Searched CASE

El Searched CASE es la forma más flexible porque cada rama puede evaluar una condición distinta. Su estructura general es:

CASE
 WHEN C1 THEN E1
 WHEN C2 THEN E2
 ...
 WHEN CN THEN EN
 [ELSE ED]
END

En este patrón, C1, C2 y CN representan condiciones booleanas. Cuando una condición se cumple, CASE retorna su expresión asociada (E1, E2, EN) y deja de evaluar las siguientes ramas.

Analicemos una clasificación de categorías de películas:

CASE
 WHEN category.name IN ('Children','Family','Sports','Animation')
 THEN 'All Ages'
 WHEN category.name = 'Horror'
 THEN 'Adult'
 WHEN category.name IN ('Music','Games')
 THEN 'Teens'
 ELSE 'Other'
END

Esta variante permite mezclar operadores como IN, =, comparaciones numéricas, subconsultas y funciones. También se puede usar para evitar cálculos innecesarios en ciertas filas.

Consideremos el siguiente caso: si un cliente está inactivo, queremos retornar 0; si está activo, contamos sus rentas:

mysql> SELECT c.first_name, c.last_name,
 -> CASE
 -> WHEN active = 0 THEN 0
 -> ELSE
 -> (SELECT count(*) FROM rental r
 -> WHERE r.customer_id = c.customer_id)
 -> END num_rentals
 -> FROM customer c;
+-------------+--------------+-------------+
| first_name | last_name | num_rentals |
+-------------+--------------+-------------+
| MARY | SMITH | 32 |
| PATRICIA | JOHNSON | 27 |
| LINDA | WILLIAMS | 26 |
| BARBARA | JONES | 22 |
| ELIZABETH | BROWN | 38 |
| JENNIFER | DAVIS | 28 |
...
| TERRANCE | ROUSH | 0 |
| RENE | MCALISTER | 26 |
| EDUARDO | HIATT | 27 |
| TERRENCE | GUNDERSON | 30 |
| ENRIQUE | FORSYTHE | 28 |
| FREDDIE | DUGGAN | 25 |
| WADE | DELVALLE | 22 |
| AUSTIN | CINTRON | 19 |
+-------------+--------------+-------------+
599 rows in set (0.01 sec)

Simple CASE

El Simple CASE es útil cuando todas las ramas comparan la misma expresión contra valores concretos. En lugar de repetir category.name = ..., colocamos category.name una sola vez después de CASE.

CASE category.name
 WHEN 'Children' THEN 'All Ages'
 WHEN 'Family' THEN 'All Ages'
 WHEN 'Sports' THEN 'All Ages'
 WHEN 'Animation' THEN 'All Ages'
 WHEN 'Horror' THEN 'Adult'
 WHEN 'Music' THEN 'Teens'
 WHEN 'Games' THEN 'Teens'
 ELSE 'Other'
END

Esta forma es más compacta y legible cuando la decisión depende de una única columna o expresión. Su limitación es que no permite condiciones heterogéneas por rama; para eso conviene usar Searched CASE.

Tip

Usa Simple CASE cuando estás mapeando valores discretos de una misma columna. Usa Searched CASE cuando necesitas rangos, IN, EXISTS, comparaciones entre columnas o reglas más compuestas.

Comprobar la existencia

Uno de los usos más prácticos de CASE es combinarlo con EXISTS. Esta técnica permite crear columnas tipo bandera (Y / N, true / false, 1 / 0) según la existencia de filas relacionadas.

Observemos una consulta que marca si un actor participó en películas con ciertas clasificaciones:

mysql> SELECT a.first_name, a.last_name,
 -> CASE
 -> WHEN EXISTS (SELECT 1 FROM film_actor fa
 -> INNER JOIN film f ON fa.film_id = f.film_id
 -> WHERE fa.actor_id = a.actor_id
 -> AND f.rating = 'G') THEN 'Y'
 -> ELSE 'N'
 -> END g_actor,
 -> CASE
 -> WHEN EXISTS (SELECT 1 FROM film_actor fa
 -> INNER JOIN film f ON fa.film_id = f.film_id
 -> WHERE fa.actor_id = a.actor_id
 -> AND f.rating = 'PG') THEN 'Y'
 -> ELSE 'N'
 -> END pg_actor,
 -> CASE
 -> WHEN EXISTS (SELECT 1 FROM film_actor fa
 -> INNER JOIN film f ON fa.film_id = f.film_id
 -> WHERE fa.actor_id = a.actor_id
 -> AND f.rating = 'NC-17') THEN 'Y'
 -> ELSE 'N'
 -> END nc17_actor
 -> FROM actor a
 -> WHERE a.last_name LIKE 'S%' OR a.first_name LIKE 'S%';
+------------+-------------+---------+----------+------------+
| first_name | last_name | g_actor | pg_actor | nc17_actor |
+------------+-------------+---------+----------+------------+
| JOE | SWANK | Y | Y | Y |
| SANDRA | KILMER | Y | Y | Y |
| CAMERON | STREEP | Y | Y | Y |
| SANDRA | PECK | Y | Y | Y |
| SISSY | SOBIESKI | Y | Y | N |
| NICK | STALLONE | Y | Y | Y |
| SEAN | WILLIAMS | Y | Y | Y |
| GROUCHO | SINATRA | Y | Y | Y |
| SCARLETT | DAMON | Y | Y | Y |
| SPENCER | PECK | Y | Y | Y |
| SEAN | GUINESS | Y | Y | Y |
| SPENCER | DEPP | Y | Y | Y |
| SUSAN | DAVIS | Y | Y | Y |
| SIDNEY | CROWE | Y | Y | Y |
| SYLVESTER | DERN | Y | Y | Y |
| SUSAN | DAVIS | Y | Y | Y |
| DAN | STREEP | Y | Y | Y |
| SALMA | NOLTE | Y | N | Y |
| SCARLETT | BENING | Y | Y | Y |
| JEFF | SILVERSTONE | Y | Y | Y |
| JOHN | SUVARI | Y | Y | Y |
| JAYNE | SILVERSTONE | Y | Y | Y |
+------------+-------------+---------+----------+------------+
22 rows in set (0.00 sec)

También podemos usar CASE con una subconsulta escalar. Aquí se clasifica la disponibilidad de una película según la cantidad de copias en inventario:

mysql> SELECT f.title,
 -> CASE (SELECT count(*) FROM inventory i 
 -> WHERE i.film_id = f.film_id)
 -> WHEN 0 THEN 'Out Of Stock'
 -> WHEN 1 THEN 'Scarce'
 -> WHEN 2 THEN 'Scarce'
 -> WHEN 3 THEN 'Available'
 -> WHEN 4 THEN 'Available'
 -> ELSE 'Common'
 -> END film_availability
 -> FROM film f
 -> ;
+-----------------------------+-------------------+
| title | film_availability |
+-----------------------------+-------------------+
| ACADEMY DINOSAUR | Common |
| ACE GOLDFINGER | Available |
| ADAPTATION HOLES | Available |
| AFFAIR PREJUDICE | Common |
| AFRICAN EGG | Available |
| AGENT TRUMAN | Common |
| AIRPLANE SIERRA | Common |
| AIRPORT POLLOCK | Available |
| ALABAMA DEVIL | Common |
| ALADDIN CALENDAR | Common |
| ALAMO VIDEOTAPE | Common |
| ALASKA PHANTOM | Common |
| ALI FOREVER | Available |
| ALICE FANTASIA | Out Of Stock |
...
| YOUNG LANGUAGE | Scarce |
| YOUTH KICK | Scarce |
| ZHIVAGO CORE | Scarce |
| ZOOLANDER FICTION | Common |
| ZORRO ARK | Common |
+-----------------------------+-------------------+
1000 rows in set (0.01 sec)

Errores de división por cero

La división por cero no está definida matemáticamente y los motores de base de datos deben tratarla como un caso especial. En MySQL, por ejemplo, una división directa entre cero puede retornar NULL:

mysql> SELECT 100 / 0;
+---------+
| 100 / 0 |
+---------+
| NULL |
+---------+
1 row in set (0.00 sec)

En reportes, un NULL inesperado puede contaminar cálculos posteriores o romper supuestos del consumidor. CASE permite controlar el denominador antes de ejecutar la división.

mysql> SELECT c.first_name, c.last_name,
 -> sum(p.amount) tot_payment_amt,
 -> count(p.amount) num_payments,
 -> sum(p.amount) /
 -> CASE WHEN count(p.amount) = 0 THEN 1
 -> ELSE count(p.amount)
 -> END avg_payment
 -> FROM customer c
 -> LEFT OUTER JOIN payment p
 -> ON c.customer_id = p.customer_id
 -> GROUP BY c.first_name, c.last_name;
+------------+------------+-----------------+--------------+-------------+
| first_name | last_name | tot_payment_amt | num_payments | avg_payment |
+------------+------------+-----------------+--------------+-------------+
| MARY | SMITH | 118.68 | 32 | 3.708750 |
| PATRICIA | JOHNSON | 128.73 | 27 | 4.767778 |
| LINDA | WILLIAMS | 135.74 | 26 | 5.220769 |
| BARBARA | JONES | 81.78 | 22 | 3.717273 |
| ELIZABETH | BROWN | 144.62 | 38 | 3.805789 |
...
| EDUARDO | HIATT | 130.73 | 27 | 4.841852 |
| TERRENCE | GUNDERSON | 117.70 | 30 | 3.923333 |
| ENRIQUE | FORSYTHE | 96.72 | 28 | 3.454286 |
| FREDDIE | DUGGAN | 99.75 | 25 | 3.990000 |
| WADE | DELVALLE | 83.78 | 22 | 3.808182 |
| AUSTIN | CINTRON | 83.81 | 19 | 4.411053 |
+------------+------------+-----------------+--------------+-------------+
599 rows in set (0.07 sec)

Warning

Esta técnica evita el error o el NULL, pero no siempre significa que dividir entre 1 sea semánticamente correcto. En métricas financieras o analíticas, valida si conviene retornar 0, NULL controlado o una etiqueta explícita.

Actualizaciones condicionales

CASE también puede usarse dentro de UPDATE. Esto permite modificar registros según reglas calculadas al momento de la escritura.

El siguiente ejemplo desactiva clientes activos si su última renta ocurrió hace 90 días o más; en caso contrario, mantiene el registro activo:

UPDATE customer
SET active =
 CASE
 WHEN 90 <= (SELECT datediff(now(), max(rental_date))
 FROM rental r
 WHERE r.customer_id = customer.customer_id)
 THEN 0
 ELSE 1
 END
WHERE active = 1;

Esta aproximación concentra la regla en una sola sentencia SQL. Antes de ejecutar un UPDATE de este tipo en producción, conviene probar el mismo CASE en un SELECT, revisar cuántas filas cambiarán y ejecutar la operación dentro de una transacción si el motor lo permite.

Manejo de valores NULL

Los valores NULL aparecen con frecuencia cuando usamos LEFT OUTER JOIN, porque no siempre existe una fila relacionada. CASE nos permite reemplazarlos por un valor controlado para reportes o interfaces.

SELECT c.first_name, c.last_name,
 CASE
 WHEN a.address IS NULL THEN 'Unknown'
 ELSE a.address
 END address,
 CASE
 WHEN ct.city IS NULL THEN 'Unknown'
 ELSE ct.city
 END city,
 CASE
 WHEN cn.country IS NULL THEN 'Unknown'
 ELSE cn.country
 END country
FROM customer c
 LEFT OUTER JOIN address a
 ON c.address_id = a.address_id
 LEFT OUTER JOIN city ct
 ON a.city_id = ct.city_id
 LEFT OUTER JOIN country cn
 ON ct.country_id = cn.country_id;

En varios motores también existen funciones como COALESCE, útiles para este caso específico. Aun así, CASE sigue siendo preferible cuando la lógica depende de más de una condición o cuando el valor de salida no es simplemente el primer dato no nulo.

Cierre

La expresión CASE convierte SQL en una herramienta más expresiva para preparar datos cerca de donde viven. Con ella puedes clasificar filas, derivar columnas, controlar casos límite, ejecutar actualizaciones condicionales y normalizar valores faltantes.

Como regla práctica, usa CASE para reglas de presentación, clasificación y cálculo que pertenecen naturalmente al resultado de la consulta. Si la lógica empieza a depender de múltiples procesos externos o de reglas de dominio altamente cambiantes, evalúa moverla a una capa de aplicación o a una vista bien documentada.

En el siguiente artículo de la serie vamos a trabajar con agrupamiento y funciones agregadas, donde GROUP BY, COUNT, SUM y otras funciones nos permitirán resumir datos de manera consistente.

Estilos CSS: Posicionamiento, z-index y diseño responsive

Dacadev — Wed, 10 Jun 2026 00:00:00 -0500

Tabla de Contenido

Hasta ahora hemos trabajado con elementos que viven en el flujo normal del documento. El posicionamiento rompe ese flujo: te permite anclar una cabecera al viewport, superponer un modal, desplegar un menú o fijar una barra lateral mientras el usuario hace scroll. Combinado con z-index y las media queries, el posicionamiento es la base de las interacciones dinámicas y del diseño adaptable.

Esta es la quinta entrega de la serie Estilos CSS. Cubriremos los cinco valores de position, los contextos de apilamiento con z-index y los fundamentos del diseño responsive.

Note

Entenderás cuándo usar cada tipo de posicionamiento, por qué z-index a veces “no funciona” por culpa de los contextos de apilamiento, y cómo escribir media queries con un enfoque mobile first.

La propiedad position

La propiedad position acepta cinco valores que cambian cómo se ubica un elemento:

static (por defecto) — el elemento permanece en el flujo normal.
relative — se desplaza respecto a su posición original sin salir del flujo.
absolute — se extrae del flujo y se posiciona respecto a su ancestro posicionado más cercano.
fixed — se extrae del flujo y se posiciona respecto al viewport.
sticky — combina relative y fixed según el scroll.

Las propiedades top, right, bottom y left controlan la ubicación (y, en algunos casos, el tamaño) de los elementos posicionados.

Fixed: anclado al viewport

position: fixed extrae el elemento del flujo normal —los demás se reorganizan como si no existiera— y lo ancla a una posición relativa al viewport, donde permanece aunque el usuario haga scroll. Es la base de los modales: un fondo semitransparente que cubre toda la pantalla y un cuerpo centrado encima.

.modal-backdrop {
 position: fixed;
 top: 0; right: 0; bottom: 0; left: 0;
 background-color: rgba(0, 0, 0, 0.5);
}

.modal-body {
 position: fixed;
 top: 3em; bottom: 3em; right: 20%; left: 20%;
 background-color: white;
 overflow: auto;
}

Tip

Al posicionar no estás obligado a declarar los cuatro lados. Si omites bottom y height, la altura la determina el contenido de forma natural. Combinar lados con width/height te da control total sobre el tamaño.

Absolute: relativo al ancestro posicionado

position: absolute también extrae el elemento del flujo, pero se posiciona respecto al primer ancestro que tenga una posición distinta de static. Si ningún ancestro está posicionado, usa el bloque contenedor inicial (el tamaño del viewport).

Este es el patrón para colocar un botón de cierre en la esquina de un modal: el padre se marca como position: relative y el botón como position: absolute.

.modal-body { position: relative; }
.modal-close { position: absolute; top: 0.3em; right: 0.3em; }

✕ Cuerpo del modal

El botón de cierre está posicionado en la esquina con absolute respecto a este contenedor relative.

Relative: desplazamiento sin salir del flujo

A diferencia de los anteriores, position: relative no extrae el elemento del flujo; lo traslada respecto a su posición original, dejando su hueco intacto. Tampoco permite redimensionarlo con la combinación de lados.

Su uso más frecuente es establecer un bloque contenedor para descendientes absolutos. Es la base de un menú desplegable: el contenedor es relative y el menú es absolute, mostrándose con :hover.

.dropdown { position: relative; display: inline-block; }

.dropdown-menu { position: absolute; top: 100%; left: 0; display: none; }

.dropdown:hover .dropdown-menu { display: block; }

Menú principal ▾

Pasa el cursor sobre el botón para desplegar el menú.

Sticky: lo mejor de relative y fixed

position: sticky mantiene el elemento en su posición normal hasta que, al hacer scroll, alcanza el umbral definido por top/bottom; en ese momento se “pega” como si fuera fixed. Cuando el contenido vuelve, recupera su comportamiento relativo. Es ideal para barras laterales y cabeceras de sección que deben permanecer visibles.

.afijo { position: sticky; top: 1em; }

Stacking contexts y z-index

Cuando varios elementos posicionados se solapan, z-index controla el orden de apilamiento en el eje Z. Acepta enteros positivos y negativos: a mayor valor, más al frente.

.uno { position: relative; z-index: 1; }
.dos { position: relative; z-index: 2; } /* queda por encima de .uno */

Aquí está la trampa que confunde a muchos: cada elemento posicionado con z-index crea su propio contexto de apilamiento. Un hijo dentro de un contexto con z-index: 1 nunca podrá superar a un elemento de un contexto hermano con z-index: 2, aunque el hijo tenga z-index: 99999.

Warning

z-index tiene dos “gotchas”: solo funciona sobre elementos posicionados (cualquier position distinto de static), y al usarlo creas un nuevo contexto de apilamiento. Si un z-index enorme “no funciona”, casi siempre es porque su elemento está atrapado en un contexto de apilamiento de menor prioridad.

Responsive: estilos que se adaptan

La enorme variedad de pantallas obliga a diseñar interfaces que respondan a distintos tamaños. La filosofía mobile first consiste en escribir primero los estilos para móvil y luego ampliarlos progresivamente hacia tablets y escritorio.

Media queries

Una media query aplica un bloque de CSS solo cuando se cumple una condición sobre el viewport. Conviene usar em en los umbrales para que respeten el zoom y la configuración del usuario.

@media (min-width: 35em) {
 .titulo { font-size: 2.25rem; }
}

Puedes combinar condiciones con lógica:

/* AND: ambas condiciones */
@media (min-width: 20em) and (max-width: 35em) { /* ... */ }

/* OR: cualquiera de las dos */
@media (max-width: 20em), (min-width: 35em) { /* ... */ }

Entre las características consultables están min-width, max-width, min-height, orientation: landscape | portrait y min-resolution: 2dppx (para pantallas retina). El catálogo completo está en la documentación de @media en MDN.

Breakpoints con mobile first

Los breakpoints son los puntos donde el diseño cambia de un tamaño a otro. Con el enfoque mobile first, los estilos base sirven al móvil y cada media query añade ajustes para pantallas mayores:

.titulo { font-size: 1.5rem; } /* móvil (base) */

@media (min-width: 35em) { /* tablet */
 .titulo { font-size: 2rem; }
}

@media (min-width: 50em) { /* escritorio */
 .titulo { font-size: 2.5rem; }
}

Este título cambia de tamaño según el ancho

Redimensiona la ventana para cruzar los breakpoints de 35em y 50em.

Estilos para impresión

Las media queries también cubren el medio de impresión. @media print aplica reglas cuando el usuario imprime o exporta a PDF:

@media print {
 * { color: black !important; background: none !important; }
}

Conclusión

El posicionamiento te da control fino sobre dónde vive cada elemento: fixed para modales, absolute para tooltips y menús, relative como ancla, y sticky para elementos que acompañan el scroll. Sumado a un manejo consciente de los contextos de apilamiento y a media queries con enfoque mobile first, tienes las piezas para construir interfaces dinámicas y adaptables.

Note

🚀 La próxima entrega explora los fondos y las sombras: gradientes, modos de mezcla y las propiedades box-shadow y text-shadow para dar profundidad a tus componentes.

Estilos CSS: Layouts con Float, Flexbox y Grid

Dacadev — Mon, 08 Jun 2026 00:00:00 -0500

Tabla de Contenido

Maquetar es componer la estructura visual de una página: columnas, rejillas, barras laterales, galerías. Durante años se hizo con herramientas que no se diseñaron para ello —float nació para envolver texto alrededor de imágenes— hasta que llegaron Flexbox y CSS Grid, dos sistemas pensados específicamente para layout. Conocer los tres te permite entender el código heredado y elegir la herramienta correcta para cada problema.

Esta es la cuarta entrega de la serie Estilos CSS. Recorreremos float y la técnica clearfix, el modelo unidimensional de Flexbox y el sistema bidimensional de Grid, con ejemplos que puedes ver renderizados.

Note

Aprenderás cuándo sigue siendo útil float, cómo controlar el tamaño de los ítems con flex, y cómo posicionar elementos en una rejilla con grid-template.

Float: el origen y el clearfix

float extrae un elemento del flujo normal y lo desplaza hacia un lado de su contenedor; el contenido adyacente fluye a su alrededor. Ese fue su propósito original: envolver texto alrededor de una imagen.

.imagen { float: left; margin-right: 1em; }

float

Este párrafo fluye alrededor del bloque flotado. El texto se ajusta al margen del elemento extraído del flujo, exactamente el caso de uso para el que float fue concebido: envolver contenido alrededor de una figura.

Cuando usas float, necesitas limpiar el flujo para que el contenedor vuelva a comportarse con normalidad. El patrón estándar es el clearfix, implementado con un pseudo-elemento:

.clearfix::before,
.clearfix::after {
 display: table;
 content: " ";
}

.clearfix::after {
 clear: both;
}

Tip

Para layouts modernos, float casi siempre se reemplaza por Flexbox o Grid. Resérvalo para su propósito original: envolver texto alrededor de un elemento.

Flexbox: layout en una dimensión

Al aplicar display: flex a un contenedor, este se convierte en un flex container y sus hijos en flex items. Flexbox organiza los ítems a lo largo de un eje principal y los alinea en el eje transversal, ajustando tamaños de forma flexible.

Un contenedor flex tiene dos ejes:

Eje principal (main) — la dirección en la que se colocan los ítems (horizontal por defecto).
Eje transversal (cross) — perpendicular al principal.

Alinear ítems con justify-content y align-items

justify-content controla la distribución a lo largo del eje principal: flex-start, flex-end, center, space-between, space-around.
align-items controla la alineación en el eje transversal: stretch (por defecto), flex-start, flex-end, center, baseline.

.barra {
 display: flex;
 justify-content: space-between;
 align-items: center;
}

Logo Menú Perfil

Controlar el tamaño: flex-grow, flex-shrink y flex-basis

La propiedad abreviada flex agrupa tres propiedades que gobiernan el tamaño de cada ítem:

flex-basis — el tamaño base (de partida) del ítem antes de crecer o encoger. Su valor inicial es auto.
flex-grow — el factor de crecimiento para repartir el espacio sobrante. 0 no crece.
flex-shrink — el factor de encogimiento cuando falta espacio.

.col-a { flex: 1; } /* crece para ocupar el espacio sobrante */
.col-b { flex: 2; } /* crece al doble que col-a */

flex: 1

flex: 2 (el doble de ancho)

Dirección y envoltura

flex-direction cambia el eje principal: row (por defecto), row-reverse, column, column-reverse.
flex-wrap permite que los ítems salten a una nueva línea cuando no caben: nowrap (por defecto), wrap, wrap-reverse.
flex-flow es la abreviatura de ambas: flex-flow: row wrap.

Propiedades del ítem

align-self — sobrescribe align-items para un ítem concreto.
order — reordena los ítems sin tocar el HTML; el valor inicial es 0.

Info

Flexbox crea automáticamente columnas de igual altura y es la herramienta ideal para centrar un elemento. Para un catálogo de bugs conocidos y sus soluciones, consulta flexbugs.

CSS Grid: layout en dos dimensiones

Mientras Flexbox trabaja en un solo eje, CSS Grid organiza el contenido en filas y columnas simultáneamente. Antes de usarlo conviene fijar su vocabulario:

Grid line — las líneas que forman la estructura de la rejilla.
Grid track — el espacio entre dos líneas adyacentes (una fila o una columna).
Grid cell — la intersección de una fila y una columna.
Grid area — un rectángulo formado por una o más celdas.

Una rejilla básica

Se activa con display: grid y se definen las pistas con grid-template-columns y grid-template-rows. La unidad fr representa una fracción del espacio disponible.

.grid {
 display: grid;
 grid-template-columns: 1fr 1fr 1fr;
 gap: 0.5em;
}

La función repeat() evita la repetición: grid-template-columns: repeat(3, 1fr) equivale a 1fr 1fr 1fr.

Posicionar ítems por líneas

Cada línea de la rejilla tiene un número. Con grid-column y grid-row indicas dónde empieza y termina un ítem usando la sintaxis inicio / fin:

.destacado {
 grid-column: 1 / 3; /* abarca de la línea 1 a la 3 */
 grid-row: span 2; /* abarca dos pistas verticales */
}

grid-column: 1 / 3

Áreas con nombre

La forma más legible de componer un layout es nombrar las áreas con grid-template-areas y asignar cada elemento con grid-area:

.contenedor {
 display: grid;
 grid-template-areas:
 "titulo titulo"
 "nav nav"
 "main aside";
 grid-template-columns: 2fr 1fr;
 gap: 1em;
}

header { grid-area: titulo; }
nav { grid-area: nav; }
.main { grid-area: main; }
.aside { grid-area: aside; }

titulo

nav

main

aside

Rejilla implícita y galerías responsivas

Cuando no conoces de antemano la cantidad de ítems —por ejemplo, datos que vienen de una API— la rejilla implícita crece automáticamente para acomodarlos. La combinación de auto-fill con minmax() produce galerías que se adaptan al ancho disponible sin media queries:

.galeria {
 display: grid;
 grid-template-columns: repeat(auto-fill, minmax(180px, 1fr));
 gap: 1em;
}

Redimensiona la ventana: las columnas se reorganizan solas.

Warning

Con Grid solo puedes formar rectángulos. No se pueden crear formas en L o U directamente; se simulan dejando celdas vacías (con . en grid-template-areas) o combinando áreas.

Flexbox y Grid: complementarios, no rivales

No tienes que elegir uno. La combinación más potente es usar Grid para la estructura macro de la página (cabecera, contenido, barra lateral, pie) y Flexbox para alinear el contenido dentro de cada zona (una barra de navegación, una tarjeta, un grupo de botones).

Conclusión

float resuelve el envolvimiento de texto; Flexbox domina el layout en una dimensión y el centrado; Grid organiza estructuras bidimensionales complejas. Elegir la herramienta adecuada para cada problema —y combinarlas— es lo que distingue una maquetación robusta de una llena de parches.

Note

🚀 En la próxima entrega abordamos el posicionamiento (relative, absolute, fixed, sticky), los contextos de apilamiento con z-index y el diseño responsive con media queries.

SQL: Filtrado de Datos con la Cláusula WHERE

Dacadev — Mon, 08 Jun 2026 00:00:00 -0500

Tabla de Contenido

El filtrado de datos en SQL es una operación diaria cuando trabajas con bases relacionales: rara vez necesitas todas las filas de una tabla. La cláusula WHERE expresa condiciones precisas para reducir resultados, evitar lecturas innecesarias y alinear la consulta con la lógica de negocio. Este es el artículo #2 de la serie SQL; si necesitas repasar SELECT, FROM y el modelo general de consulta, revisa Fundamentos de SQL.

Note

Aprenderás a usar WHERE con igualdad, desigualdad, rangos, BETWEEN, IN, subconsultas, LIKE, expresiones regulares y NULL, tanto en lectura como en modificación.

La cláusula WHERE y las condiciones booleanas

La cláusula WHERE filtra filas evaluando una o más condiciones. Cada condición produce un resultado lógico que el motor de base de datos usa para decidir si una fila entra o no en el resultado final.

En la práctica, esas condiciones suelen combinar varios tipos de operadores:

Operadores de comparación: =, !=, <, >, <>, LIKE, IN, BETWEEN.
Operadores aritméticos: +, -, *, /, cuando necesitas comparar expresiones calculadas.
Operadores lógicos: AND, OR, NOT, para componer filtros más específicos.

Aunque WHERE es el punto central para filtrar filas, también existe HAVING, que se utiliza después de agrupar datos con GROUP BY. La diferencia es importante: WHERE filtra filas antes de la agregación; HAVING filtra grupos después de calcular agregados.

Condiciones de igualdad

La condición de igualdad compara una columna contra una expresión. Esa expresión puede ser un literal, un número, una fecha o incluso el resultado de una subconsulta.

title = 'RIVER OUTLAW'
fed_id = '111-11-1111'
amount = 375.25
film_id = (SELECT film_id FROM film WHERE title = 'RIVER OUTLAW')

Observemos un caso concreto usando la base de datos de ejemplo Sakila. La consulta obtiene los correos de clientes que rentaron películas el 2005-06-14:

mysql> SELECT c.email
 -> FROM customer c
 -> INNER JOIN rental r
 -> ON c.customer_id = r.customer_id
 -> WHERE date(r.rental_date) = '2005-06-14';
+---------------------------------------+
| email |
+---------------------------------------+
| CATHERINE.CAMPBELL@sakilacustomer.org |
| JOYCE.EDWARDS@sakilacustomer.org |
...
| TERRENCE.GUNDERSON@sakilacustomer.org |
+---------------------------------------+
16 rows in set (0.03 sec)

Aquí date(r.rental_date) transforma el DATETIME a fecha antes de comparar. En producción, aplicar funciones sobre columnas puede limitar el uso eficiente de índices.

Condiciones de desigualdad

La desigualdad expresa el caso contrario: queremos excluir filas que coinciden con un valor. En SQL puedes escribirla con <>, != o usando NOT según el motor y el estilo del equipo.

mysql> SELECT c.email
 -> FROM customer c
 -> INNER JOIN rental r
 -> ON c.customer_id = r.customer_id
 -> WHERE date(r.rental_date) <> '2005-06-14';

+-----------------------------------+
| email |
+-----------------------------------+
...
| AUSTIN.CINTRON@sakilacustomer.org |
| AUSTIN.CINTRON@sakilacustomer.org |
| AUSTIN.CINTRON@sakilacustomer.org |
| AUSTIN.CINTRON@sakilacustomer.org |
+-----------------------------------+
16028 rows in set (0.03 sec)

La diferencia semántica es directa: en lugar de seleccionar rentas del día indicado, excluimos ese día.

Modificación de datos con condiciones de igualdad

WHERE no solo aparece en SELECT. También es crítico en UPDATE y DELETE, donde define exactamente qué filas serán modificadas o eliminadas.

DELETE FROM rental
WHERE year(rental_date) = 2004;

DELETE FROM rental
WHERE year(rental_date) <> 2005 AND year(rental_date) <> 2006;

El primer caso elimina rentas del año 2004; el segundo elimina rentas que no pertenecen ni a 2005 ni a 2006.

Warning

Antes de ejecutar un DELETE o UPDATE con WHERE, valida la condición con un SELECT equivalente. Un filtro demasiado amplio puede modificar más filas de las esperadas.

Condiciones de rango

Para filtrar rangos puedes combinar operadores como <, <=, > y >= con AND u OR. Esto funciona con fechas, números y otros tipos comparables.

mysql> SELECT customer_id, rental_date
 -> FROM rental
 -> WHERE rental_date < '2005-05-25';
+-------------+---------------------+
| customer_id | rental_date |
+-------------+---------------------+
| 130 | 2005-05-24 22:53:30 |
| 459 | 2005-05-24 22:54:33 |
...
| 239 | 2005-05-24 23:31:46 |
+-------------+---------------------+
8 rows in set (0.00 sec)

mysql> SELECT customer_id, rental_date
 -> FROM rental
 -> WHERE rental_date <= '2005-06-16'
 -> AND rental_date >= '2005-06-14';
+-------------+---------------------+
| customer_id | rental_date |
+-------------+---------------------+
| 416 | 2005-06-14 22:53:33 |
| 516 | 2005-06-14 22:55:13 |
...
| 148 | 2005-06-15 23:20:26 |
| 237 | 2005-06-15 23:36:37 |
| 155 | 2005-06-15 23:55:27 |
| 341 | 2005-06-15 23:57:20 |
| 149 | 2005-06-15 23:58:53 |
+-------------+---------------------+
364 rows in set (0.00 sec)

Usando BETWEEN

BETWEEN permite expresar un rango con una sintaxis más compacta. El valor menor va a la izquierda, el mayor a la derecha, y ambos límites son inclusivos.

mysql> SELECT customer_id, rental_date
 -> FROM rental
 -> WHERE rental_date BETWEEN '2005-06-14' AND '2005-06-16';
+-------------+---------------------+
| customer_id | rental_date |
+-------------+---------------------+
| 416 | 2005-06-14 22:53:33 |
| 516 | 2005-06-14 22:55:13 |
...
| 148 | 2005-06-15 23:20:26 |
| 237 | 2005-06-15 23:36:37 |
| 155 | 2005-06-15 23:55:27 |
| 341 | 2005-06-15 23:57:20 |
| 149 | 2005-06-15 23:58:53 |
+-------------+---------------------+
364 rows in set (0.00 sec)

Tip

BETWEEN puede usarse con fechas, horas, números y strings. Recuerda que los límites son inclusivos, así que valida cuidadosamente rangos de tiempo cuando trabajes con columnas DATETIME.

Condiciones de pertenencia con IN

Las condiciones de pertenencia permiten verificar si un valor existe dentro de una lista. Primero, analicemos la versión con OR:

mysql> SELECT title, rating
 -> FROM film
 -> WHERE rating = 'G' OR rating = 'PG';
+---------------------------+--------+
| title | rating |
+---------------------------+--------+
| ACADEMY DINOSAUR | PG |
| ACE GOLDFINGER | G |
...
| WEDDING APOLLO | PG |
| WEREWOLF LOLA | G |
| WEST LION | G |
...
| YOUNG LANGUAGE | G |
+---------------------------+--------+
372 rows in set (0.00 sec)

La misma condición puede escribirse de forma más clara con IN:

SELECT title, rating
FROM film
WHERE rating IN ('G','PG');

También puedes combinar pertenencia y negación usando NOT IN:

SELECT title, rating
FROM film
WHERE rating NOT IN ('PG-13','R', 'NC-17');

IN mejora la legibilidad cuando comparas una columna contra múltiples valores discretos y evita repetir la misma columna.

Subconsultas dentro de IN

IN no está limitado a listas escritas manualmente. También puedes usar una subconsulta para calcular dinámicamente los valores válidos de comparación.

mysql> SELECT title, rating
 -> FROM film
 -> WHERE rating IN (SELECT rating FROM film WHERE title LIKE '%PET%');
+---------------------------+--------+
| title | rating |
+---------------------------+--------+
| ACADEMY DINOSAUR | PG |
| ACE GOLDFINGER | G |
...
| WEDDING APOLLO | PG |
| WEREWOLF LOLA | G |
| WEST LION | G |
...
| YOUNG LANGUAGE | G |
+---------------------------+--------+
372 rows in set (0.00 sec)

La subconsulta obtiene los rating de películas cuyo título contiene PET; la consulta externa recupera las películas con esos ratings.

Condiciones de coincidencia con LIKE

Las condiciones de coincidencia permiten buscar patrones de texto en lugar de valores exactos. Con LIKE, SQL ofrece dos comodines principales:

Comodín	Significado
`_`	Exactamente un carácter
`%`	Cualquier cantidad de caracteres, incluyendo cero

Consideremos este patrón: _A_T%S. Significa: un carácter cualquiera, luego A, luego un carácter cualquiera, luego T, luego cualquier secuencia, y finalmente S.

mysql> SELECT last_name, first_name
 -> FROM customer
 -> WHERE last_name LIKE '_A_T%S';
+-----------+------------+
| last_name | first_name |
+-----------+------------+
| MATTHEWS | ERICA |
| WALTERS | CASSANDRA |
| WATTS | SHELLY |
+-----------+------------+
3 rows in set (0.00 sec)

LIKE es útil para búsquedas simples. Un patrón que inicia con %, como '%PET%', suele ser más costoso porque limita el uso de índices tradicionales.

Expresiones regulares

Algunos motores permiten filtrar texto con expresiones regulares. En MySQL, por ejemplo, se usa REGEXP. Otros motores tienen variantes propias, así que siempre valida la sintaxis de tu base de datos.

mysql> SELECT last_name, first_name
 -> FROM customer
 -> WHERE last_name REGEXP '^[QY]';
+-------------+------------+
| last_name | first_name |
+-------------+------------+
| YOUNG | CYNTHIA |
| QUALLS | STEPHEN |
| QUINTANILLA | ROGER |
| YANEZ | LUIS |
| YEE | MARVIN |
| QUIGLEY | TROY |
+-------------+------------+
6 rows in set (0.16 sec)

El patrón ^[QY] indica que el apellido debe iniciar con Q o Y. Las expresiones regulares son más expresivas que LIKE, pero menos portables entre motores.

Filtrado de valores NULL

NULL es un caso especial en SQL. No representa false, cero ni una cadena vacía; representa ausencia de valor o valor desconocido. Por esa razón, no debes comparar NULL con =.

Para consultar valores nulos se usa IS NULL, y para excluirlos se usa IS NOT NULL.

mysql> SELECT rental_id, customer_id
 -> FROM rental
 -> WHERE return_date IS NULL;
+-----------+-------------+
| rental_id | customer_id |
+-----------+-------------+
| 11496 | 155 |
| 11541 | 335 |
...
| 15867 | 505 |
| 15875 | 41 |
| 15894 | 168 |
| 15966 | 374 |
+-----------+-------------+
183 rows in set (0.01 sec)

Info

NULL = NULL no se evalúa como verdadero en SQL estándar. Cuando una comparación involucra NULL, el resultado puede ser desconocido; por eso IS NULL y IS NOT NULL son operadores específicos para este caso.

Cierre

La cláusula WHERE convierte una tabla completa en un conjunto de filas relevante. Dominar igualdad, desigualdad, rangos, pertenencia, patrones y NULL te permite escribir consultas más precisas y seguras.

Como regla práctica, diseña filtros explícitos, valida condiciones destructivas con SELECT, y considera el impacto de funciones, comodines y expresiones regulares sobre los índices. En el siguiente artículo abordaremos Lógica condicional con CASE, una herramienta clave para transformar valores dentro de tus consultas.

Estilos CSS: Dominando el modelo de caja

Dacadev — Sat, 06 Jun 2026 00:00:00 -0500

Tabla de Contenido

El modelo de caja es el sistema con el que CSS calcula el tamaño y el espaciado de cada elemento. Parece trivial, pero es la fuente número uno de layouts impredecibles: un width: 50% que termina midiendo más de la mitad, dos columnas que no encajan, márgenes que desaparecen sin razón aparente. Todos esos síntomas se explican entendiendo cómo el navegador compone una caja.

Esta es la tercera entrega de la serie Estilos CSS. Analizaremos las cuatro regiones de una caja, el cambio de comportamiento que introduce box-sizing, el control de overflow, el manejo de alturas, el centrado vertical y el colapso de márgenes.

Note

Comprenderás por qué box-sizing: border-box debería ser tu valor por defecto y aprenderás a resolver los problemas clásicos de altura, centrado vertical y colapso de márgenes.

Las cuatro regiones de una caja

Todo elemento HTML se compone, de adentro hacia afuera, de cuatro capas:

content — el área donde vive el contenido (texto, imágenes).
padding — el espacio interno entre el contenido y el borde.
border — el borde que rodea el padding.
margin — el espacio externo que separa la caja de sus vecinos.

<div class="caja">content + padding + border + margin</div>

content

El área azul es el content; el beige es el padding; el trazo turquesa es el border; el espacio punteado exterior es el margin.

`box-sizing`: content-box vs border-box

La propiedad box-sizing decide qué incluye el width y el height que declaras.

content-box (valor por defecto) — width y height miden solo el contenido. El padding y el border se suman por fuera, agrandando el tamaño final.
border-box — width y height miden el conjunto de contenido + padding + border. El tamaño que declaras es el tamaño real renderizado.

Mira dos cajas con width: 200px y padding: 20px, una con cada modelo:

.content-box { box-sizing: content-box; } /* ancho real: 200 + 40 = 240px */
.border-box { box-sizing: border-box; } /* ancho real: 200px */

content-box → mide 246px en total

border-box → mide 200px en total

Por eso es práctica recomendada activar border-box de forma global, heredándolo para no romper estilos de terceros:

:root { box-sizing: border-box; }

*, ::before, ::after { box-sizing: inherit; }

Warning

Evita los números mágicos: valores arbitrarios (margin-top: 37px) que “cuadran” un diseño por casualidad. Haz que el contenido se adapte al contenedor, no al revés.

Alturas: el flujo normal manda

La altura de un contenedor es orgánica por defecto: la define su contenido, no el contenedor. Esto tiene dos consecuencias prácticas:

Definir height en porcentaje rara vez funciona, porque se refiere a la altura del padre, que a su vez depende de su contenido.
Para que un height: 100% funcione, el padre necesita una altura explícita en unidades absolutas.

En lugar de fijar alturas, prefiere restringir el rango con min-height y max-height, dejando que el contenido fluya:

.panel { min-height: 6em; max-height: 12em; }

`overflow`: qué hacer cuando el contenido se desborda

Cuando el contenido excede el tamaño de su caja, overflow define el comportamiento:

Valor	Comportamiento
`visible` (por defecto)	El contenido se desborda y permanece visible.
`hidden`	El contenido que se sale se recorta.
`scroll`	Siempre añade barras de desplazamiento.
`auto`	Añade barras solo si hace falta.

.recorte { overflow: auto; max-height: 5em; }

Este contenedor tiene overflow: auto y una altura máxima.

Cuando el contenido supera esa altura, aparece una barra de desplazamiento.

Línea adicional para forzar el desbordamiento.

Y una más para asegurar el scroll.

Puedes controlar cada eje por separado con overflow-x y overflow-y, aunque mezclar valores distintos suele dar resultados poco predecibles.

Centrado vertical

Centrar verticalmente fue durante años un dolor de cabeza en CSS. La propiedad vertical-align no sirve para esto: solo aplica a elementos inline y a celdas de tabla. Hoy tenemos varias soluciones según el escenario:

¿Puedes usar la altura natural? Aplica un padding igual arriba y abajo.
¿Necesitas altura fija? Usa display: table-cell con vertical-align: middle.
El caso general: usa flexbox.
¿Una sola línea de texto? Usa line-height igual a la altura del contenedor.

La solución moderna por excelencia es flexbox, que centra en ambos ejes con tres declaraciones:

.centro {
 display: flex;
 align-items: center; /* eje vertical */
 justify-content: center; /* eje horizontal */
 min-height: 8em;
}

Centrado en ambos ejes

Márgenes negativos

A diferencia de padding y border, los márgenes admiten valores negativos, lo que te permite tirar de un elemento hacia afuera de su posición natural o solaparlo con su vecino.

.solapado { margin-top: -1.5em; }

Bloque base

Bloque con margin-top negativo que se solapa

Colapso de márgenes (margin collapsing)

Cuando dos márgenes verticales se encuentran, no se suman: se colapsan, quedando solo el de mayor valor. Si un párrafo tiene margin-bottom: 30px y el siguiente margin-top: 20px, la separación entre ambos será de 30px, no 50px.

Info

El colapso de márgenes solo ocurre con márgenes verticales (arriba y abajo). Los márgenes horizontales (izquierda y derecha) nunca colapsan.

Hay varias formas de impedir el colapso cuando no lo deseas:

Aplicar overflow: auto (o cualquier valor distinto de visible) al contenedor.
Añadir un border o un padding entre los dos márgenes.
Usar un contenedor flotado, inline-block o con posición absoluta/fija.
Usar flexbox o grid: los márgenes entre ítems del layout no colapsan.
Los elementos con display: table-cell no tienen margen, así que no colapsan.

Conclusión

El modelo de caja deja de ser un misterio cuando interiorizas que box-sizing controla la aritmética del tamaño, que la altura es orgánica por naturaleza y que los márgenes verticales colapsan. Activar border-box de forma global y apoyarte en flexbox para el centrado elimina la mayoría de los problemas clásicos de maquetación.

Note

🚀 La siguiente entrega cubre los sistemas de layout: float, flexbox y CSS Grid, las herramientas con las que componemos la estructura completa de una página.

SQL: Fundamentos de SELECT, FROM y WHERE

Dacadev — Fri, 05 Jun 2026 00:00:00 -0500

Tabla de Contenido

Cuando trabajas con una base de datos relacional, la calidad del sistema depende de consultas legibles y precisas. Las sentencias básicas de SQL como SELECT, FROM y WHERE definen qué datos recuperas, desde dónde los tomas y bajo qué condiciones entran al resultado final. Este es el primer artículo de la serie de SQL.

Note

En este artículo aprenderás cómo se organiza una consulta SQL, qué rol cumplen SELECT, FROM, WHERE, GROUP BY, HAVING y ORDER BY, y cómo usar alias, tablas derivadas, tablas temporales y vistas para construir consultas más claras.

Qué es una base de datos y cómo se estructura una consulta SQL

Info

Una base de datos no es más que un conjunto de información relacionada. En SQL trabajamos sobre esa información mediante sentencias que describen qué datos queremos leer, filtrar, agrupar u ordenar.

SQL permite expresar consultas declarativas: describes el resultado esperado y el motor decide el plan de ejecución, aplica optimizaciones y devuelve un result set.

Las cláusulas principales de una consulta suelen aparecer en este orden lógico:

Cláusula	Propósito
`select`	Determina qué columnas incluir en el result set de la consulta
`from`	Identifica las tablas de las que se extraen los datos y cómo se unen
`where`	Filtra los registros no deseados
`group by`	Agrupa filas por valores de columna comunes
`having`	Filtra los grupos no deseados
`order by`	Ordena las filas del resultado final por una o más columnas

`SELECT`: definir las columnas del resultado

Tip

La cláusula SELECT determina cuáles columnas, expresiones o valores calculados se incluyen en el resultado de la consulta.

SELECT es la parte visible de la consulta. Ahí defines columnas, valores constantes, expresiones calculadas o resultados procesados por funciones integradas.

Consideremos este ejemplo usando language:

mysql> SELECT language_id,
 -> 'COMMON' language_usage,
 -> language_id * 3.1415927 lang_pi_value,
 -> upper(name) language_name
 -> FROM language;
+-------------+----------------+---------------+---------------+
| language_id | language_usage | lang_pi_value | language_name |
+-------------+----------------+---------------+---------------+
| 1 | COMMON | 3.1415927 | ENGLISH |
| 2 | COMMON | 6.2831854 | ITALIAN |
| 3 | COMMON | 9.4247781 | JAPANESE |
| 4 | COMMON | 12.5663708 | MANDARIN |
| ... | ... | ... | ... |
+-------------+----------------+---------------+---------------+
6 rows in set (0.04 sec)

Este SELECT combina una columna real, un literal, una expresión aritmética y una función. Cada expresión forma una columna del resultado.

Reglas prácticas:

Usa * solo cuando realmente necesitas todas las columnas.
Selecciona columnas específicas para reducir ruido y transferencia de datos.
Usa AS para alias explícitos en columnas calculadas o renombradas.
Aplica operaciones, funciones integradas o expresiones cuando aporte claridad.
Usa DISTINCT para eliminar duplicados según las columnas seleccionadas.

Warning

Evita usar SELECT * por defecto en consultas que respaldan APIs, reportes o procesos críticos. Cuando el esquema cambia, el resultado también cambia, y eso puede romper consumidores que esperan columnas específicas.

`FROM`: declarar el origen de los datos

Tip

La cláusula FROM define las tablas usadas por la consulta y también la forma en que esas tablas se relacionan entre sí.

FROM indica de dónde salen las filas. Puede apuntar a tablas permanentes, derivadas, temporales o vistas.

Tablas permanentes

Las tablas permanentes son creadas con CREATE TABLE: datos persistentes, definidos en el esquema y disponibles entre sesiones.

Ejemplo mínimo:

SELECT language_id, name
FROM language;

Tablas derivadas

Una tabla derivada es una subconsulta usada dentro de FROM. Vive solo durante la ejecución y permite aislar una etapa intermedia.

mysql> SELECT concat(cust.last_name, ', ', cust.first_name) full_name
 -> FROM
 -> (SELECT first_name, last_name, email
 -> FROM customer
 -> WHERE first_name = 'JESSIE'
 -> ) cust;
+---------------+
| full_name |
+---------------+
| BANKS, JESSIE |
| MILAM, JESSIE |
+---------------+
2 rows in set (0.00 sec)

La subconsulta filtra clientes llamados JESSIE. La consulta externa usa ese conjunto como cust y construye full_name.

Tablas temporales

Las tablas temporales materializan datos intermedios durante una sesión, transacción o proceso puntual.

Info

Las tablas temporales se comportan como tablas normales, pero los datos insertados desaparecen en algún momento, usualmente al cerrar la sesión de base de datos o finalizar la transacción, según el motor utilizado.

mysql> CREATE TEMPORARY TABLE actors_j
 -> (actor_id smallint(5),
 -> first_name varchar(45),
 -> last_name varchar(45)
 -> );
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO actors_j
 -> SELECT actor_id, first_name, last_name
 -> FROM actor
 -> WHERE last_name LIKE 'J%';
Query OK, 7 rows affected (0.03 sec)
Records: 7 Duplicates: 0 Warnings: 0

mysql> SELECT * FROM actors_j;
+----------+------------+-----------+
| actor_id | first_name | last_name |
+----------+------------+-----------+
| 119 | WARREN | JACKMAN |
| 131 | JANE | JACKMAN |
| 8 | MATTHEW | JOHANSSON |
| 64 | RAY | JOHANSSON |
| ... | ... | ... |
+----------+------------+-----------+
7 rows in set (0.00 sec)

Este patrón es práctico cuando un proceso reutiliza un subconjunto de datos varias veces. Conviene medir su impacto porque materializar datos tiene costo.

Vistas

Una vista es una tabla virtual creada con CREATE VIEW. Normalmente encapsula una consulta y la expone como fuente reutilizable.

mysql> CREATE VIEW cust_vw AS
 -> SELECT customer_id, first_name, last_name, active
 -> FROM customer;
Query OK, 0 rows affected (0.12 sec)

mysql> SELECT first_name, last_name
 -> FROM cust_vw
 -> WHERE active = 0;
+------------+-----------+
| first_name | last_name |
+------------+-----------+
| SANDRA | MARTIN |
| JUDITH | COX |
| SHEILA | WELLS |
| ERICA | MATTHEWS |
| HEIDI | LARSON |
| ... | ... |
| TERRANCE | ROUSH |
+------------+-----------+
15 rows in set (0.00 sec)

Las vistas encapsulan lógica compartida y pueden exponer solo ciertas columnas a consumidores internos.

Alias: mejorar legibilidad sin cambiar el modelo

Los alias permiten referenciar tablas y columnas con nombres más cortos. Esto evita redundancia y mejora la lectura, especialmente cuando hay joins o nombres de tabla largos.

Observemos este ejemplo:

SELECT c.first_name, c.last_name,
 time(r.rental_date) rental_time
FROM customer c
 INNER JOIN rental r
 ON c.customer_id = r.customer_id
WHERE date(r.rental_date) = '2005-06-14';

En este caso, customer se referencia como c y rental como r. La consulta queda compacta y cada columna mantiene un origen explícito.

`WHERE`: filtrar filas antes del resultado final

Tip

La cláusula WHERE es el mecanismo para excluir filas no deseadas del result set.

WHERE concentra buena parte de la lógica de una consulta. Ahí combinas operadores, comparaciones, funciones y paréntesis para expresar condiciones precisas.

mysql> SELECT title, rating, rental_duration
 -> FROM film
 -> WHERE (rating = 'G' AND rental_duration >= 7)
 -> OR (rating = 'PG-13' AND rental_duration < 4);
+-------------------------+--------+-----------------+
| title | rating | rental_duration |
+-------------------------+--------+-----------------+
| ALABAMA DEVIL | PG-13 | 3 |
| BACKLASH UNDEFEATED | PG-13 | 3 |
| BILKO ANONYMOUS | PG-13 | 3 |
| BLANKET BEVERLY | G | 7 |
| BORROWERS BEDAZZLED | G | 7 |
| BRIDE INTRIGUE | G | 7 |
| CASPER DRAGONFLY | PG-13 | 3 |
| ... | ... | ... |
| WAR NOTTING | G | 7 |
| WORLD LEATHERNECKS | PG-13 | 3 |
+-------------------------+--------+-----------------+
68 rows in set (0.00 sec)

La condición usa dos grupos lógicos. Los paréntesis hacen explícita la intención y reducen ambigüedad cuando se combinan AND y OR.

Warning

Cuando mezclas AND y OR, usa paréntesis aunque el motor tenga reglas de precedencia. La consulta queda más legible y disminuye el riesgo de devolver más filas de las esperadas.

`GROUP BY` y `HAVING`: agrupar datos y filtrar agregados

GROUP BY agrupa filas por valores comunes de una o más columnas y permite aplicar agregados como count, sum, avg, min o max. HAVING opera después de la agrupación: filtra grupos, no filas individuales.

mysql> SELECT c.first_name, c.last_name, count(*)
 -> FROM customer c
 -> INNER JOIN rental r
 -> ON c.customer_id = r.customer_id
 -> GROUP BY c.first_name, c.last_name
 -> HAVING count(*) >= 40;
+------------+-----------+----------+
| first_name | last_name | count(*) |
+------------+-----------+----------+
| TAMMY | SANDERS | 41 |
| CLARA | SHAW | 42 |
| ELEANOR | HUNT | 46 |
| SUE | PETERS | 40 |
| ... | ... | ... |
+------------+-----------+----------+
7 rows in set (0.03 sec)

Aquí agrupamos rentas por cliente y dejamos solo clientes con 40 o más rentas. WHERE count(*) >= 40 no aplica porque WHERE se evalúa antes de calcular agregados.

`ORDER BY`: ordenar el resultado final

ORDER BY define el orden de las filas devueltas. Sin esta cláusula, no debes asumir un orden estable.

mysql> SELECT c.first_name, c.last_name,
 -> time(r.rental_date) rental_time
 -> FROM customer c
 -> INNER JOIN rental r
 -> ON c.customer_id = r.customer_id
 -> WHERE date(r.rental_date) = '2005-06-14'
 -> ORDER BY c.last_name;
+------------+-----------+-------------+
| first_name | last_name | rental_time |
+------------+-----------+-------------+
| DANIEL | CABRAL | 23:09:38 |
| CATHERINE | CAMPBELL | 23:17:03 |
| HERMAN | DEVORE | 23:35:09 |
| AMBER | DIXON | 23:42:56 |
| JOYCE | EDWARDS | 23:16:26 |
| ... | ... | ... |
+------------+-----------+-------------+
16 rows in set (0.01 sec)

En este caso, el resultado queda ordenado por last_name. También puedes ordenar por múltiples columnas y controlar la dirección con ASC o DESC.

Cierre

Las cláusulas básicas de SQL forman una cadena clara: SELECT define qué mostrar, FROM de dónde leer, WHERE filtra filas, GROUP BY agrupa, HAVING filtra grupos y ORDER BY estabiliza el orden final.

En el siguiente artículo de la serie profundizaremos en Filtrado de datos con la cláusula WHERE, donde analizaremos operadores, rangos, patrones, valores nulos y composición de condiciones con más detalle.

Estilos CSS: Selectores, combinadores y pseudo-clases

Dacadev — Thu, 04 Jun 2026 00:00:00 -0500

Tabla de Contenido

Un selector es el mecanismo con el que CSS apunta a los elementos que vas a estilizar. Elegir el selector correcto no es solo cuestión de que “funcione”: impacta directamente en la especificidad, en el acoplamiento de tus estilos y en la facilidad para mantenerlos. CSS ofrece un catálogo amplio de selectores, y conocerlos a fondo te evita escribir reglas frágiles.

Este artículo es la segunda entrega de la serie Estilos CSS. Recorreremos los selectores básicos, los combinadores, las pseudo-clases, los pseudo-elementos y los selectores de atributo, con ejemplos que puedes ver renderizados aquí mismo.

Note

Repasaremos cada familia de selectores con su especificidad y demostraciones en vivo, para que puedas elegir siempre la opción más precisa y de menor acoplamiento.

Selectores básicos

Son los cuatro selectores fundamentales sobre los que se construye todo lo demás:

Selector de tipo (p, h1) — apunta por nombre de etiqueta. Especificidad 0,0,1.
Selector de clase (.media) — apunta a los elementos con esa clase. Especificidad 0,1,0.
Selector de ID (#sidebar) — apunta al elemento con ese id. Especificidad 1,0,0.
Selector universal (*) — apunta a todos los elementos. Especificidad 0,0,0.

Combinadores

Los combinadores unen selectores simples para describir una relación entre elementos.

Combinador	Símbolo	Significado	Ejemplo
Descendiente	(espacio)	Cualquier descendiente	`.menu li`
Hijo directo	`>`	Hijo inmediato	`.lista > li`
Hermano adyacente	`+`	El elemento inmediatamente siguiente	`p + h2`
Hermano general	`~`	Todos los hermanos posteriores	`li.activo ~ li`

El combinador de hijo directo (>) solo afecta al primer nivel de descendientes. Observa la diferencia con el descendiente:

.lista > li { font-weight: bold; } /* solo hijos directos */

<ul class="lista">
 <li>Hijo directo (en negrita)</li>
 <li>Hijo directo (en negrita)
 <ul>
 <li>Nieto (sin negrita)</li>
 </ul>
 </li>
</ul>

Hijo directo (en negrita)
Hijo directo (en negrita)
- Nieto (sin negrita)

Selectores compuestos

Varios selectores simples se pueden unir sin espacios para formar un selector compuesto que exige que el elemento cumpla todas las condiciones. Por ejemplo, .dropdown.is-active apunta a <div class="dropdown is-active"> pero no a <div class="dropdown">.

Pseudo-clases

Las pseudo-clases apuntan a elementos según un estado: interacción del usuario o posición respecto a sus hermanos. Empiezan con un solo dos puntos (:) y tienen la especificidad de una clase (0,1,0).

Posición estructural

:first-child, :last-child, :only-child — primero, último o único hijo.
:nth-child(an + b) — apunta según una fórmula posicional entre sus hermanos.
:nth-last-child() — igual, pero contando desde el final.
:first-of-type, :last-of-type, :nth-of-type() — equivalentes, pero solo cuentan elementos del mismo tipo.
:not(<selector>) — apunta a lo que no coincide con el selector interno.
:empty — elementos sin hijos.

Un patrón clásico: aplicar un fondo alterno con :nth-child(even) para crear filas tipo “cebra”.

.zebra li:nth-child(even) { background: #ecf0f1; }

Fila 1
Fila 2 (resaltada)
Fila 3
Fila 4 (resaltada)

Estado e interacción

:hover — mientras el cursor está sobre el elemento.
:focus — cuando el elemento recibe foco (clic, toque o tabulación).
:root — el elemento raíz del documento.

Campos de formulario

Varias pseudo-clases describen el estado de los controles: :disabled, :enabled, :checked, :invalid, :valid, :required, :optional. Aquí, :invalid cambia el borde cuando el valor no es un correo válido:

input:invalid { border-color: #c0392b; }
input:valid { border-color: #27ae60; }

Escribe un correo:

Tip

La lista de pseudo-clases es extensa y evoluciona con cada nivel de la especificación. Consulta la documentación de MDN sobre pseudo-clases para el catálogo completo y el soporte por navegador.

Pseudo-elementos

Los pseudo-elementos no apuntan a un elemento existente, sino a una parte del documento que no tiene marcado propio, o inyectan contenido nuevo. Usan doble dos puntos (::) y tienen la especificidad de un selector de tipo (0,0,1).

::before — inserta un primer hijo virtual. Requiere la propiedad content.
::after — inserta un último hijo virtual. Requiere content.
::first-letter — estiliza la primera letra del texto.
::first-line — estiliza la primera línea.
::selection — estiliza el texto que el usuario resalta.

.nota::before { content: "★ "; color: #f39c12; }
.capitular::first-letter { font-size: 2.5em; font-weight: bold; color: #2a9da9; }

★ Texto precedido por un pseudo-elemento ::before.

Lorem ipsum con la primera letra estilizada como capitular.

Selectores de atributo

Apuntan a elementos según sus atributos HTML. Tienen la especificidad de una clase (0,1,0).

Selector	Coincide cuando el atributo…	Ejemplo
`[attr]`	existe	`input[disabled]`
`[attr="valor"]`	es exactamente igual	`input[type="radio"]`
`[attr^="valor"]`	empieza con el valor	`a[href^="https"]`
`[attr$="valor"]`	termina con el valor	`a[href$=".pdf"]`
`[attr*="valor"]`	contiene el valor	`[class*="sprite-"]`
`[attr~="valor"]`	es una lista separada por espacios que incluye el valor	`a[rel~="author"]`
`[attr\|="valor"]`	es igual o empieza con `valor-`	`[lang\|="es"]`

Por ejemplo, podemos marcar visualmente los enlaces externos y los que apuntan a un PDF:

a[href^="https"]::after { content: " ↗"; }
a[href$=".pdf"]::after { content: " (PDF)"; color: #c0392b; }

Enlace externo ↗ · Documento (PDF)

Info

Los selectores de atributo distinguen mayúsculas y minúsculas por defecto. La especificación nivel 4 añade un modificador i antes del corchete de cierre —input[value="search" i]— para hacerlos insensibles a mayúsculas. Verifica el soporte antes de usarlo en producción.

Conclusión

El catálogo de selectores de CSS es amplio y cada familia resuelve un problema distinto. La clave está en elegir el selector más preciso con la menor especificidad posible: eso mantiene tus estilos desacoplados y fáciles de sobrescribir cuando lo necesites.

Note

🚀 En la siguiente entrega abordamos el modelo de caja: cómo margin, border, padding y content definen el tamaño real de cada elemento y cómo box-sizing cambia las reglas del juego.

Estilos CSS: Cascada, especificidad, herencia y unidades

Dacadev — Tue, 02 Jun 2026 00:00:00 -0500

Tabla de Contenido

Cuando dos reglas de estilo compiten por el mismo elemento, el resultado no es aleatorio: el navegador aplica un algoritmo determinista para decidir cuál gana. Comprender ese algoritmo —la cascada, la especificidad y la herencia— es la diferencia entre pelear contra CSS a punta de !important y escribir hojas de estilo predecibles y mantenibles.

Este artículo abre la serie Estilos CSS. Analizaremos cómo el navegador resuelve conflictos, cómo se calcula el peso de un selector y cómo aprovechar las unidades relativas para construir interfaces que escalan.

Note

Al terminar entenderás el modelo mental que rige toda hoja de estilos: origen de los estilos, especificidad, orden del código, herencia y el sistema de unidades relativas (em, rem, vw) junto con las variables CSS.

La cascada: cómo el navegador resuelve conflictos

CSS significa Cascading Style Sheets. La cascada es precisamente el conjunto de reglas que determina qué declaración prevalece cuando varias apuntan a la misma propiedad de un elemento. El navegador evalúa tres criterios en orden:

Origen de la hoja de estilos — de dónde provienen los estilos.
Especificidad del selector — qué selector es más “específico”.
Orden en el código — cuál se declaró de último.

Origen de los estilos

Existen tres orígenes posibles, con prioridad creciente:

User agent styles — los estilos por defecto del navegador (por ejemplo, el margin de un <h1> o el subrayado de un enlace).
Author styles — los estilos que tú defines en tus archivos .css.
User styles — estilos configurados por el propio usuario en el navegador (accesibilidad, tamaños de fuente). Tienen prioridad sobre los anteriores.

Tus estilos (author) pisan a los del navegador, que es justo lo que esperas al escribir una hoja de estilos.

Especificidad: el peso de un selector

La especificidad se representa con la notación 0,0,0,0, donde cada posición cuenta, de izquierda a derecha: estilos inline, IDs, clases y nombres de etiqueta.

Componente	Ejemplo	Peso
Selector de etiqueta	`p`, `h1`	`0,0,0,1`
Selector de clase	`.nav-menu`	`0,0,1,0`
Selector de ID	`#sidebar`	`0,1,0,0`
Estilo inline	`style="..."`	`1,0,0,0`

Las reglas de desempate son sencillas:

Una declaración con !important gana por encima de todo (úsala con prudencia).
Gana el selector con más IDs.
Si hay empate, gana el que tenga más clases.
Si persiste el empate, gana el que tenga más etiquetas.

Tip

Las pseudo-clases (:hover) y los selectores de atributo ([type="text"]) cuentan como una clase (0,0,1,0). El selector universal * y los combinadores (>, +, ~) no aportan especificidad.

Observa cómo dos reglas compiten por el color del párrafo. La clase .destacado gana al selector de etiqueta p, aunque la regla de p se declare después:

p { color: #555; }
.destacado { color: #c0392b; }

<p>Texto con el color por defecto del selector de etiqueta.</p>
<p class="destacado">Este párrafo gana por especificidad de clase.</p>

Texto con el color por defecto del selector de etiqueta.

Este párrafo gana por especificidad de clase.

Orden del código: el último en hablar gana

Cuando dos declaraciones tienen el mismo origen y la misma especificidad, el navegador aplica la que aparece de última en el código fuente. Este comportamiento es crítico al ordenar las pseudo-clases de un enlace.

a:link { color: #2a7ae2; }
a:visited { color: #8e44ad; }
a:hover { text-decoration: underline; }
a:active { color: #c0392b; }

Como las cuatro pseudo-clases tienen la misma especificidad, su orden importa. La regla mnemotécnica es LoVe/HAte — link, visited, hover, active. Si inviertes :hover y :link, el :hover nunca se aplicaría.

Pasa el cursor sobre este enlace para ver el efecto del orden del código.

Herencia: propiedades que viajan hacia abajo

La herencia permite que ciertas propiedades de un elemento padre se transmitan a sus hijos. No todas las propiedades heredan: lo hacen principalmente las relacionadas con texto (color, font-family, line-height, text-align), mientras que las de caja (margin, padding, border) no.

.tarjeta { color: #1a5276; font-family: Georgia, serif; }

<div class="tarjeta">
 <h4>Título heredado</h4>
 <p>Este párrafo hereda <em>color</em> y <em>font-family</em> del contenedor.</p>
</div>

Título heredado

Este párrafo hereda color y font-family del contenedor.

Valores especiales: `inherit` e `initial`

Dos palabras clave te dan control explícito sobre la herencia:

inherit — fuerza a una propiedad a tomar el valor del padre, incluso en propiedades que normalmente no heredan.
initial — restablece la propiedad a su valor inicial según la especificación, ignorando la herencia.

Unidades absolutas vs. relativas

El píxel (px) es la unidad absoluta más común. Existen otras (pt, cm, in) con equivalencias fijas: 1in = 96px = 72pt. Sin embargo, las unidades relativas son las que permiten construir interfaces que escalan con el contexto.

`em`: relativo al elemento

Un em equivale al font-size del propio elemento. Es ideal para padding, margin y border-radius, porque estos escalan junto con el tamaño de fuente.

.caja { padding: 1em; border-radius: 1em; background: #ecf0f1; }
.caja--pequena { font-size: 12px; }
.caja--grande { font-size: 20px; }

padding 1em · 12px padding 1em · 20px

El padding de ambas cajas es 1em, pero al cambiar el font-size el espaciado escala proporcionalmente sin tocar la propiedad padding.

Info

Para convertir un tamaño en píxeles a em, divide el tamaño deseado entre el tamaño heredado: si quieres 16px y el padre tiene 12px, entonces 16 / 12 = 1.333em.

`rem`: relativo a la raíz

rem (root em) siempre toma como referencia el font-size del elemento raíz (<html> o :root). Esto te da un punto de control global: cambiar el tamaño de la raíz redimensiona todo el documento de forma coherente.

:root { font-size: 0.875em; }

@media (min-width: 800px) { :root { font-size: 1em; } }
@media (min-width: 1200px) { :root { font-size: 1.125em; } }

Una práctica habitual: usar rem para tipografía, px para bordes y em para padding, margin y border-radius.

Unidades relativas al viewport

vw — 1% del ancho del viewport.
vh — 1% del alto del viewport.
vmin — 1% de la dimensión más pequeña entre ancho y alto.
vmax — 1% de la dimensión más grande.

`calc()` para combinar unidades

calc() permite operar entre unidades de distinta naturaleza, algo imposible de otra forma. Es muy útil para tipografía fluida:

:root { font-size: calc(0.5em + 1vw); }

Números sin unidad y `line-height`

Si declaras un número sin unidad en line-height, este actúa como un factor multiplicador del font-size del elemento. Es la forma recomendada, porque cada descendiente calcula su propia altura de línea a partir de su tamaño de fuente.

body { line-height: 1.5; }

Custom properties (variables CSS)

Las variables CSS se declaran con el prefijo -- y se consumen con la función var(). A diferencia de las variables de un preprocesador, son dinámicas: viven en el DOM y respetan la cascada y la herencia.

:root {
 --color-marca: #2a9da9;
 --color-texto: #1c2833;
}

.panel {
 color: var(--color-texto);
 border-left: 4px solid var(--color-marca);
}

var() acepta un segundo argumento como valor de respaldo: var(--color-secundario, #888) usará #888 si la variable no está definida.

Redefinir variables por contexto

Como las variables respetan la cascada, puedes sobrescribirlas dentro de un bloque para crear temas locales. Aquí el mismo componente .panel se reconfigura dentro de .tema-oscuro cambiando solo las variables:

:root { --fondo: #fff; --texto: #111; }
.tema-oscuro { --fondo: #2c3e50; --texto: #ecf0f1; }

.panel {
 background: var(--fondo);
 color: var(--texto);
 padding: 1em;
 border-radius: .5em;
}

Panel claro

Usa las variables por defecto de :root.

Panel oscuro

Las mismas reglas, con las variables redefinidas.

El componente no cambió ni una línea: solo redefinimos las variables en un contenedor superior. Ese es el poder de combinar herencia y custom properties.

Conclusión

La cascada, la especificidad y la herencia forman el núcleo conceptual de CSS. Dominarlos te permite predecir qué regla gana sin recurrir a parches. Sumado a un buen uso de unidades relativas y variables, tienes la base para escribir estilos escalables y mantenibles.

Note

🚀 Próximo en la serie: los selectores de CSS, la herramienta con la que apuntamos con precisión a los elementos que queremos estilizar.

GitHub Copilot: Beneficios, Desventajas y Precauciones

Dacadev — Mon, 27 May 2024 00:00:00 -0500

Tabla de Contenido

Note

Este artículo nace como una iniciativa para centralizar el conocimiento que he adquirido en el manejo de la herramienta de GitHub Copilot gracias a su uso diario, cursos y consejos que he encontrado en diversos recursos.

La herramienta la puedes encontrar en el siguiente enlace: GitHub Copilot

GitHub Copilot es una herramienta de inteligencia artificial que nos ofrece toda la potencia de los modelos de lenguaje a gran escala (LLM, por sus siglas en inglés) enfocada específicamente en el campo del desarrollo de software y programación. Es una herramienta que ha revolucionado la manera de escribir código y aún tiene mucho más por aportar. Veamos algunas de sus funcionalidades y beneficios, así como desventajas y riesgos de usar esta herramienta.

¿Qué es GitHub Copilot?

Mi definición de lo que es Copilot sería:

GitHub Copilot es una herramienta de programación de pair programming que extiende las habilidades de los desarrolladores permitiendo enfocarse en el diseño, delegando la “carpintería” al copiloto.

Adicionalmente, si queremos ser un poco más técnicos al respecto y definir qué es Copilot técnicamente, debemos decir que Copilot trabaja sobre las mismas bases de los LLMs como ChatGPT, con la salvedad de que fue afinado para que su enfoque sea 100% en la escritura de código.

Los datos usados para ajustar el modelo que alimenta a GitHub Copilot fueron todos los repositorios públicos que se encuentran en GitHub, siendo esta la plataforma más usada para alojar proyectos alrededor del mundo. Esto significa que el conjunto de datos de entrenamiento es inmenso y muy completo.

Por último, como Copilot está basado en la tecnología de los LLMs, en general lo que busca es predecir, a partir de probabilidades, cuál sería el código que seguiría a medida que vas escribiendo.

¿Debo preocuparme por el manejo de datos?

Una de las principales dudas al momento de usar Copilot, incluso podría pensar que la primera duda, es ¿Copilot usará mis datos y mi código para futuras sugerencias? o en palabras más simples ¿Copilot va a robar mi código?

La respuesta es un NO rotundo. Copilot no usará tu código o el código generado con la herramienta para reentrenar el modelo, ya que, como mencioné antes, esta herramienta solo es entrenada con datos públicos que se obtienen de los repositorios públicos de GitHub.

Además, el código generado a partir de Copilot no es alojado para realizar una futura realimentación del modelo, por lo que puedes estar seguro de la privacidad de tu código y de tu negocio a fin de cuentas.

Note

En este punto debo mencionar algo y es la propiedad intelectual. Puede que Copilot no respete la propiedad intelectual si esta es en un repositorio público, por lo que si quieres tener este tipo de protección y a la vez tener un código abierto, es mejor asesorarte.

¿Cuáles son los alcances de Copilot?

Como mencionamos antes, Copilot es tu compañero de programación en pareja, esto significa que te ayudará a escribir código brindando sugerencias durante la escritura del mismo, pero aquí puede surgir una pregunta muy importante: ¿Puede Copilot ayudarme sin importar el lenguaje?

La respuesta a esta pregunta es ambigua, sí y no. Es un sí porque recuerda que el modelo fue entrenado usando todo el código público alojado en GitHub, y entre estos encontramos una diversidad inmensa de lenguajes, frameworks, estilos, prácticas, etc. Sin embargo, también debemos tener en cuenta que los lenguajes más populares como JavaScript o Python son los que más proyectos tienen alojados en GitHub, lo que significa que el modelo aprendió más de estos lenguajes, haciéndolo mucho más eficiente para estos tipos de lenguajes o frameworks.

Si intentas utilizar Copilot con algún lenguaje que no es tan popular como COBOL, es posible que Copilot no haga un muy buen trabajo, pero lo intentará.

Tip

Si tienes miedo de que la IA te pueda arrebatar el trabajo, tiene sentido buscar aquello en lo que la IA no es realmente buena… ¿aún? Esto es solo una opinión que podría ser una buena discusión, ¿qué opinas?

¿Es acertado Copilot en sus predicciones?

Esta es una pregunta que muchas personas se hacen, sin importar el nivel de experiencia que tengan, y volviendo a retomar la idea de antes, sus predicciones mejorarán a medida que sea usado para escribir código de lenguajes o contextos populares, ya que tendrá más conocimiento de dónde echar mano.

Dado lo anterior, es MUY IMPORTANTE que tú, como desarrollador, supervises siempre el resultado de Copilot. No importa qué tan sencillo o simple sea, hazlo como una nueva práctica para el uso de esta herramienta ya que Copilot solo predice, no piensa realmente… ¿aún? 🤔

Aquí quiero hacer un énfasis que es mandatorio, y es el de la supervisión. Tu responsabilidad como programador es supervisar el resultado de Copilot, y esto se puede hacer eficientemente solamente si:

Conoces la tecnología, lenguaje, frameworks, etc. que Copilot te está ayudando a construir.
Entiendes lo que estás construyendo y el propósito, la lógica de negocio.
Entiendes a nivel macro el impacto de tu trabajo, Copilot te ayudará con lo micro.

Tip

Debes ser siempre consciente de lo que estás construyendo, siempre recuérdalo porque con el uso de Copilot es fácil caer en la tentación de dejar pasar algunas cosas.

Beneficios de usar Copilot

Hablemos ahora de cuáles son los beneficios de usar Copilot. ¡Hay muchos!

Incrementa la productividad, ya que no gastarás tiempo escribiendo y reescribiendo código, sobre todo si son piezas pequeñas pero tediosas.
Reduce los errores en el código, aunque debamos supervisar el resultado de Copilot, este siempre nos ayudará a reducir errores comunes como los typos o referencias mal realizadas.
Permite tener una gran diversidad de código, ya que puedes pedirle a Copilot que te dé no solo una, sino más sugerencias, permitiéndonos ahondar en múltiples estilos o diseños de código.
Soporta múltiples lenguajes, con mejor rendimiento en unos más que en otros.
Te permite aprender y desarrollar al mismo tiempo. Cuando Copilot te ayuda a escribir código, puede implementar técnicas o ideas nuevas para ti y te permitirá aprender de ellas. Para ello, debes ser consciente y supervisar el resultado, no confíes 100% en su respuesta. Valida en la documentación o en recursos de confianza.
Copilot se ajustará a tu tipo de código. A medida que lo uses, entenderá cuál es el estilo de código en base a lo ya escrito en el proyecto. Tú lo orientas en base a cómo escribas código. Esto significa que si cambias de proyecto y este tiene otras reglas, Copilot se adaptará. Él no aprende de ti.

Precauciones y desventajas de Copilot

Su precisión es variable dependiendo del contexto del prompt y del mismo código que tienes en ese archivo. Esto depende del tiempo de trabajo en el proyecto con Copilot, los archivos abiertos y el código de referencia.
Riesgos de seguridad potenciales. Debes supervisar el resultado, sobre todo si trabajas con partes sensibles del código como SQL, ORMs, código de lógica de negocio, etc. Valida el código que propone Copilot y, si no lo conocías, valida su uso en la documentación o un recurso de confianza.
Depender demasiado de la herramienta. Para que esto no suceda, debes conocer bien la tecnología, lenguaje y sistema que estás construyendo, para tener el criterio y confianza de que lo que estás haciendo lo podrías hacer sin ayuda de Copilot.
Una “desventaja” es que tiene un costo, no tiene opción de uso gratuito o similar, y es más costoso a medida que se implementa en organizaciones. Esto, en algunos casos como personas/empresas que están empezando, puede ser un valor difícil de asumir. Debes tener claro el valor que agrega en el equipo y ese gasto adicional incluirlo en tus cuentas.
Límite en el contexto de la herramienta. Esta es una desventaja de los LLMs en general y, aunque es algo que está en constante mejora, es muy difícil (por lo menos hasta ahora) incluir todo un proyecto en el contexto de un LLM y adicionalmente compartir qué es lo que se busca hacer. Por lo que para tareas muy grandes con un código fuente enorme, tiende a no ser tan preciso.

Conclusión

GitHub Copilot ha revolucionado la forma en que los desarrolladores escriben código, ofreciendo beneficios significativos como el aumento de la productividad y la reducción de errores. Sin embargo, es crucial supervisar sus sugerencias y estar consciente de sus limitaciones y riesgos. A medida que la tecnología avanza, Copilot seguirá mejorando, pero siempre será necesario el criterio humano para garantizar la calidad y la seguridad del código.

Info

Este artículo se actualiza periódicamente conforme evolucionan las funcionalidades de GitHub Copilot. Si tienes experiencias o consejos adicionales, no dudes en compartirlos a través de la página de contacto.

Patrones de Diseño: Decorador

Dacadev — Wed, 21 Feb 2024 21:25:17 +0000

Tabla de Contenido

Objetivo del patrón decorador

Note

El patrón decorador agrega dinamismo a la extensión de funcionalidades.

El objetivo del patrón decorador es crear una clase abstracta, la cual usaremos para crear (a través de herencia) los objetos base. Los decoradores serán clases especiales que extienden las funcionalidades de la clase abstracta, agregando un campo que contendrá una instancia de la clase abstracta, o en su defecto, un hijo de la misma.

Veamos un ejemplo de cómo los decoradores pueden funcionar. Supongamos que estamos creando una aplicación para llevar el control de costos de bebidas, donde el costo de estas bebidas depende de los ingredientes adicionales que le añadamos, como por ejemplo, chocolate rallado, crema, etc.

Ejemplo de uso

Ahora, supongamos que tenemos una clase base café a la cual queremos agregar dos ingredientes nuevos: chocolate y crema chantilly. Gráficamente, se vería algo como

De este ejemplo, podemos ver que para calcular el costo total de la bebida debemos sumar el valor de costo de cada uno de los decoradores o de las clases decoradoras. Para ello, la clase base debe tener la capacidad de identificar si tiene un hijo para retornar su valor de costo por defecto y así encadenar la suma.

Antes de pasar al código de implementación, veamos algunas características que debemos tener en cuenta para este patrón.

Características del patrón decorador

El decorador debe tener el mismo supertipo que el objeto que están decorando; es decir, ambas clases, la clase decoradora y la que se está decorando, deben heredar de la misma clase.
Puedes usar uno o más decoradores para encapsular un objeto, lo que significa que no hay límite en la cantidad de objetos decoradores que se utilicen sobre un objeto.
Cuando se le da el mismo supertipo al decorado y a la clase que está decorando, podemos pasar dicho elemento decorado en lugar del objeto original encapsulado.
El decorador agrega su propio comportamiento antes o después de que el objeto decorado realice su trabajo.
Los objetos pueden ser decorados en cualquier momento, lo que permite que sean decorados de manera dinámica en tiempo de ejecución.

Note

🚀 El patrón decorador adiciona responsabilidades de manera dinámica a un objeto, ofreciendo flexibilidad y una alternativa al uso de subclases.

Implementación del ejemplo en código

Teoría

Para la implementación de nuestro ejemplo, veamos como funcionaría el diagrama de clases

classDiagram
 class Component {
 methodA()
 methodB()
 otherMethods()
 }
 class ConcreteComponent {
 methodA()
 methodB()
 }
 class Decorator {
 WrappedObj Component
 methodA()
 methodB()
 otherMethods()
 }
 class ConcreteDecoratorA {
 WrappedObj Component
 methodA()
 methodB()
 otherMethods()
 }
 class ConcreteDecoratorB {
 WrappedObj Component
 methodA()
 methodB()
 otherMethods()
 }
 Component <|-- ConcreteComponent
 Component <|-- Decorator
 Decorator <|-- ConcreteDecoratorA
 Decorator <|-- ConcreteDecoratorB

Tendremos una clase base (nuestra clase abstracta) que en el diagrama se llama Component. De esta clase creamos dos clases: una es la clase ConcreteComponent, que es la que usaremos para instanciar nuestros objetos, y otra clase llamada Decorator, que es la que usaremos para crear todos los decoradores que podemos usar con nuestro objeto ConcreteComponent.

Decorator es una clase abstracta que será usada para crear nuestros decoradores específicos. Esta clase definirá los métodos y demás lógica que debe ser implementada para que otras clases sean decoradores válidos.

Ejemplo

Aplicando el anterior esquema a un ejemplo, podemos suponer que queremos crear tipos de bebidas que varían su combinación

classDiagram
 class Beverage {
 -description
 +getDescription()
 +cost()
 }
 class Coffee {
 +cost()
 }
 class Decaf {
 +cost()
 }
 class HouseBlend {
 +cost()
 }
 class IngredientDecorator {
 -beverage Beverage
 +getDescription()
 }
 class Milk {
 +cost()
 +getDescription()
 }
 class Mocha {
 +cost()
 +getDescription()
 }
 class Soy {
 +cost()
 +getDescription()
 }
 class Chantilly {
 +cost()
 +getDescription()
 }
 class Chocolate {
 +cost()
 +getDescription()
 }
 Beverage <|-- Coffee
 Beverage <|-- Decaf
 Beverage <|-- HouseBlend
 Beverage <|-- IngredientDecorator
 IngredientDecorator <|-- Milk
 IngredientDecorator <|-- Mocha
 IngredientDecorator <|-- Soy
 IngredientDecorator <|-- Chantilly
 IngredientDecorator <|-- Chocolate

La implementación del anterior diagrama se haría de la siguiente manera (en Python) empezaremos por la implementación de las clases abstractas

from abc import ABC


class Beverage(ABC):
 def cost(self) -> float:
 pass

 def description(self) -> str:
 pass


class IngredientDecorator(ABC):
 def __init__(self, beverage: Beverage):
 self.beverage = beverage

 def cost(self) -> float:
 pass

 def description(self) -> str:
 pass

Ahora haciendo uso de nuestras clases abstractas, podemos crear nuestros objetos y decoradores concretos, nuestros objetos lucirían de la siguiente forma:

from abc_classes import Beverage


class Coffee(Beverage):
 def cost(self) -> float:
 return 1.99

 def description(self) -> str:
 return "Coffee"


class Decaf(Beverage):
 def cost(self) -> float:
 return 1.25

 def description(self) -> str:
 return "Decaf"


class HouseBlend(Beverage):
 def cost(self) -> float:
 return 0.89

 def description(self) -> str:
 return "House Blend"

y nuestros decoradores

from abc_classes import IngredientDecorator


class Milk(IngredientDecorator):
 def cost(self) -> float:
 return self.beverage.cost() + 0.10

 def description(self) -> str:
 return self.beverage.description() + ", Milk"


class Mocha(IngredientDecorator):
 def cost(self) -> float:
 return self.beverage.cost() + 0.20

 def description(self) -> str:
 return self.beverage.description() + ", Mocha"


class Soy(IngredientDecorator):
 def cost(self) -> float:
 return self.beverage.cost() + 0.15

 def description(self) -> str:
 return self.beverage.description() + ", Soy"


class Chantilly(IngredientDecorator):
 def cost(self) -> float:
 return self.beverage.cost() + 0.25

 def description(self) -> str:
 return self.beverage.description() + ", Chantilly"


class Chocolate(IngredientDecorator):
 def cost(self) -> float:
 return self.beverage.cost() + 0.30

 def description(self) -> str:
 return self.beverage.description() + ", Chocolate"

y su uso dentro de nuestro código sería

from concrete_classes import Coffee, Decaf, HouseBlend
from decorators import Milk, Mocha, Soy, Chantilly, Chocolate

if __name__ == "__main__":

 chocolate_blend = Chantilly(Chocolate(HouseBlend()))
 soy_decaf = Soy(Decaf())
 moccachino = Mocha(Chocolate(Milk(Coffee())))

 print(chocolate_blend.cost())
 print(chocolate_blend.description())

 print(soy_decaf.cost())
 print(soy_decaf.description())

 print(moccachino.cost())
 print(moccachino.description())

cuando ejecutemos este código podremos ver que en nuestro resultado obtendremos

1.44
House Blend, Chocolate, Chantilly
1.4
Decaf, Soy
2.59
Coffee, Milk, Chocolate, Mocha

Consideraciones del patrón decorador

la herencia es una forma de extensión, pero no necesariamente la mejor forma de alcanzar la flexibilidad de nuestros diseños
En nuestros diseños debemos de habilitar la extensión de nuevos comportamientos evitando la modificación del código actual
la composición y la delegación pueden ser usados para agregar nuevos comportamientos en tiempo de ejecución
El patrón decorador provee una alternativa al uso de subclases para extender el comportamiento
El patrón decorador involucra el uso de clases decoradores que son usadas para encapsular componentes del mismo tipo en concreto
Las clases decoradoras tienen el mismo tipo de la clase que decoran o encapsulan
Los decoradores agregan nuevos comportamientos antes o después de que el objeto encapsulado realiza su trabajo
Los decoradores normalmente son transparentes al cliente del componente
Los decoradores pueden resultar en muchos objetos pequeños en nuestros diseños y el sobre uso del mismo puede derbar en crear código complejo y difícil de mantener

Patrones de Diseño: Observador

Dacadev — Mon, 08 Jan 2024 01:25:17 +0000

Tabla de Contenido

Note

El patrón observador define una relación uno-a-muchos entre objetos: cuando un objeto cambia de estado, todos sus dependientes son notificados automáticamente.

Teoría

El patrón observador es muy útil cuando se desea actualizar diversos objetos en función de los cambios en otros, siendo ampliamente implementado en frameworks frontend como React o Vue.

Este patrón se basa en dos partes clave: los publishers u observables, que son los objetos emisores de valores, y los suscriptores, conocidos como observadores o subscribers. Estos últimos reciben los valores emitidos por los publishers.

Note

Publishers + Suscribers = Observer Pattern

La esencia de este patrón es permitir que un publisher emita eventos a sus subscribers, teniendo además la capacidad de agregar o eliminar suscriptores de sus listas.

Veamos gráficamente cómo funciona este patrón.

En el caso 1, observamos un Objeto Publisher emitiendo valores constantemente, compartidos con todos los Suscribers registrados en su lista. En este ejemplo, no hay suscriptores.

En el caso 2, dos objetos están suscritos al objeto Publisher, recibiendo el valor emitido en el momento de su emisión.

Note

El patrón Observer permite relacionar objetos de manera comprensible, eficiente y mantenible. Es una relación One-to-Many.

Implementación

Implementaremos el patrón observer en Python definiendo dos clases abstractas: Publisher y Subscriber. Luego, crearemos clases derivadas que emitan valores (Publisher) y que se registren para recibir datos (Subscribers).

Comenzamos con las clases abstractas:

from abc import ABC, abstractmethod

class Suscriber(ABC):
 def __init__(self):
 pass

 @abstractmethod
 def update(self, value) -> None:
 raise NotImplementedError("You must implement this method")

class Publisher(ABC):
 def __init__(self):
 self.subscribers: list[Suscriber] = list()

 def add_suscriber(self, subscriber: Suscriber):
 self.subscribers.append(subscriber)

 def remove_suscriber(self, suscriber: Suscriber):
 self.subscribers.remove(suscriber)

 def notify_suscribers(self, value):
 for suscriber in self.subscribers:

En este código, definimos dos clases:

Subscriber: Representa a los suscriptores o observadores, exigiendo la implementación del método update, que recibe el dato actualizado.
Publisher: Define tres métodos clave: - add_subscriber: Registra un nuevo suscriptor. - remove_subscriber: Elimina un suscriptor específico. - notify_subscribers: Actualiza el valor a todos los suscriptores.

Note

Este código es una guía sobre cómo funciona el patrón y puede mejorarse según las necesidades de cada proyecto.

Ahora, implementemos este patrón en un ejemplo práctico: un sistema de IoT en casa que mide la radiación ultravioleta. Queremos compartir estos datos con dos sistemas: uno que almacena información para la protección infantil contra los rayos UV y otro para un sistema de riego basado en estas mediciones.

Implementaremos tres clases:

UVSolarSystem (Publisher)
UVTracker (Suscriber)
UVPlantTracker (Suscriber)

class UVSolarSystem(Publisher):

 def emit_value(self):
 value = randint(0, 100)
 self.notify_suscribers(value)

class UVTracker(Suscriber):

 def update(self, value) -> None:
 print(f"UVTracker: {value}")
 print("Doing funny stuff with this value :D")

class UVPlantTracker (Suscriber):

 def update(self, value) -> None:
 print(f"UVPlantTracker: {value}")
 print("Doing funny stuff for the plants with this value :D")

En el código, el método emit_value en UVSolarSystem es personalizado y utiliza notify_subscribers. Las clases Subscriber implementan el método update.

Probemos el código:

print("Stage 1".center(50, "="))
# define the publisher
solar_system = UVSolarSystem()

solar_system.emit_value()

print("Stage 2".center(50, "="))
# first suscriber
uv_tracker = UVTracker()

solar_system.add_suscriber(uv_tracker)
solar_system.emit_value()

print("Stage 3".center(50, "="))
# second suscriber
uv_plant_tracker = UVPlantTracker()

solar_system.add_suscriber(uv_plant_tracker)
solar_system.emit_value()

print("Stage 4".center(50, "="))
# remove the first suscriber
solar_system.remove_suscriber(uv_tracker)

La salida sería

>>> $ python main.py
=====================Stage 1======================
=====================Stage 2======================
UVTracker: 2
Doing funny stuff with this value :D
=====================Stage 3======================
UVTracker: 79
Doing funny stuff with this value :D
UVPlantTracker: 79
Doing funny stuff for the plants with this value :D
=====================Stage 4======================
UVPlantTracker: 73

Podemos mejorar el Publisher inicial agregando la posibilidad de retener el último valor emitido. Esto permite a los suscriptores acceder al valor cuando lo necesiten. El cambio en la clase Publisher sería:

class PublisherImprove(ABC):
 def __init__(self) -> None:
 self.subscribers: list[Suscriber] = list()
 self._value = None

 def add_suscriber(self, subscriber: Suscriber):
 self.subscribers.append(subscriber)

 def remove_suscriber(self, suscriber: Suscriber):
 self.subscribers.remove(suscriber)

 def notify_suscribers(self):
 for suscriber in self.subscribers:
 suscriber.update(self._value)

 @property
 def get_value(self):
 return self._value

Agregamos el getter get_value para acceder al valor actual del Publisher, alojado como atributo privado self._value.

Consideraciones del patrón observador

Define una relación one-to-many entre objetos.
Los observables actualizan a los observadores a través de una interfaz común.
Cualquier observador puede participar si cumple con la interfaz común.
Los observadores deben estar desacoplados del observable.
Es posible acceder a los datos del observable cuando sea necesario, en vez de esperar cada evento.

Patrones de Diseño: Estrategia

Dacadev — Thu, 28 Dec 2023 01:25:17 +0000

Tabla de Contenido

Note

El patrón estrategia define una familia de algoritmos intercambiables, encapsulando cada uno de ellos para que puedan ser usados de manera flexible en tiempo de ejecución.

Este patrón consiste en definir/identificar un conjunto de comportamientos comunes de un objeto y encapsular dichos comportamientos como una familia de algoritmos que, por definición, serán comunes entre ellos. De esta manera, si un objeto hace uso de dichos comportamientos, cada uno de ellos sería reemplazable por alguno de la misma familia.

Apliquemos el concepto agnóstico y posteriormente lo aplicaremos en código.

Supongamos que queremos crear un conjunto de clases que estén relacionadas con aves. Cada una de nuestras aves tendrá la capacidad de volar. Para aplicar el patrón estrategia, debemos identificar primero cuáles son esos comportamientos comunes que tienen nuestro conjunto de clases (Aves), para lo cual sería el método de volar, y vamos a encapsular este tipo de comportamiento. Esta idea se ilustra en el siguiente diagrama:

classDiagram
 class Ave {
 +volar()
 }
 class NoVolar {
 ejecutarVuelo()
 }
 class SiVolar {
 ejecutarVuelo()
 }
 ComportamientoVolar <|-- NoVolar
 ComportamientoVolar <|-- SiVolar
 class ComportamientoVolar {
 +ejecutarVuelo()
 }
 Ave <|-- Pato
 Ave <|-- Gallina
 Ave --|> ComportamientoVolar

Para este proceso optaremos por definir las clases abstractas de Aves y del comportamiento de volar, de esta manera podemos crear nuestras diversas clases y estas podrán emplear cualquiera de las clases que implementen la clase base de comportamientoVolar.

Este código implementado en Python se vería de la siguiente manera:

from abc import ABC, abstractclassmethod

# Clases abstractas
class FlightBehavior(ABC):
 def __init__(self):
 pass

 @abstractclassmethod
 def execute_fly(self):
 pass

class Bird(ABC):
 def __init__(self, flys_behavior: FlightBehavior):
 self.flys_behavior = flys_behavior

 def fly(self):
 self.flys_behavior.execute_fly()

# Cómo utilizarlo
# 1. Definir las clases que implementan las clases abstractas

# Estrategias
class NoFly(FlightBehavior):
 def __init__(self):
 super().__init__()

 def execute_fly(self):
 print("I can't fly")

class Fly(FlightBehavior):
 def __init__(self):
 super().__init__()

 def execute_fly(self):
 print("I can fly")

# Clases que implementan la estrategia
class Hen(Bird):
 def __init__(self, flys_behavior: FlightBehavior):
 super().__init__(flys_behavior=flys_behavior)

class Duck(Bird):
 def __init__(self, flys_behavior: FlightBehavior):
 super().__init__(flys_behavior=flys_behavior)

# 2. Crear los objetos
if __name__ == '__main__':
 hen = Hen(NoFly())
 hen.fly()

 duck = Duck(Fly())
 duck.fly()

Este patrón es útil en situaciones en las que tienes una clase que tiene varios comportamientos y quieres que el comportamiento se seleccione en tiempo de ejecución, según las necesidades de tu aplicación. Por ejemplo, puedes tener una clase que realiza operaciones matemáticas y quieres poder cambiar la operación que realiza en tiempo de ejecución, según las necesidades de la aplicación.

Tip

El patrón estrategia es ideal cuando tienes múltiples algoritmos para una tarea y necesitas cambiar entre ellos de forma dinámica. Piensa en sistemas de pago, algoritmos de ordenamiento o validaciones configurables.

A continuación, un ejemplo de Python de este caso de cambio de estrategia en tiempo de ejecución:

from abc import ABC, abstractmethod

class Context:
 def __init__(self, strategy: 'Strategy') -> None:
 self._strategy = strategy

 def execute_strategy(self, x: int, y: int) -> int:
 return self._strategy.execute(x, y)

class Strategy(ABC):
 @abstractmethod
 def execute(self, x: int, y: int) -> int:
 pass

class AddStrategy(Strategy):
 def execute(self, x: int, y: int) -> int:
 return x + y

class SubtractStrategy(Strategy):
 def execute(self, x: int, y: int) -> int:
 return x - y

# Uso de las clases
context = Context(AddStrategy())
print(context.execute_strategy(10, 5)) # Salida: 15

context = Context(SubtractStrategy())
print(context.execute_strategy(10, 5)) # Salida: 5

Despliegue su sitio en GitHub Pages con HUGO y dominio personalizado

Dacadev — Mon, 18 Dec 2023 20:56:15 +0000

Tabla de Contenido

Note

En este tutorial aprenderás a desplegar un sitio web creado con Hugo en GitHub Pages en menos de 10 minutos, automatizar el despliegue con GitHub Actions y configurar un dominio personalizado.

HUGO es un generador de sitios estáticos creado en Go, que cuenta con un rendimiento excelente y varias funcionalidades que permiten crear sitios web de manera amigable tanto para desarrolladores como para creadores de contenido.

Para saber más de la herramienta, puedes remitirte a la documentación en el siguiente link

Para desplegar tu sitio web creado con HUGO, dispones de muchas herramientas, tanto pagas como gratuitas, que te pueden ayudar en este proceso. En este post, vamos a ver cómo podemos desplegar rápidamente nuestro sitio en GitHub Pages en menos de 10 minutos y actualizar el dominio a uno personalizado.

GitHub Pages es un servicio que ofrece GitHub para los repositorios públicos o para aquellos usuarios que cuentan con una suscripción pro, sean usuarios personales o empresariales.

Despliegue paso a paso del sitio en GitHub Pages

Debes tener un proyecto de HUGO funcional y alojarlo en un repositorio público en GitHub.

Si quieres que el repositorio sea privado y aún así desplegar tu sitio, es importante contar con la cuenta Pro.

En la imagen de referencia, estoy usando la página especial de GitHub Pages que coincide con mi nombre de usuario, dacadev-official. Esto significa que cuando despliegue mi sitio, lo harán en la raíz del dominio de mi cuenta, que sería https://dacadev-official.github.io. Si el nombre fuera diferente, la URL sería https://dacadev-official.github.io/<my-repo-name>. Es importante tener esto en cuenta ya que si en HUGO estamos usando Permalinks o relURL sin tener configurado debidamente nuestro baseurl, podría generar problemas en los enlaces.

Dentro de nuestro repositorio, nos dirigiremos a la sección de settings > pages y activaremos la opción de build and deploy con GitHub Actions.
El siguiente paso consiste en activar las GitHub Actions. Para ello, debemos crear un archivo dentro del folder .github/workflows.

Las GitHub Actions son una herramienta de automatización integrada en GitHub, que permite ejecutar flujos de trabajo basados en eventos dentro de un repositorio.

Crearemos el archivo hugo.yaml dentro del folder mencionado. Puede ser cualquier nombre, pero lo importante es que sea un nombre relacionado o descriptivo de lo que hará. Dentro de este archivo, colocaremos el siguiente contenido.

 # Nombre de la acción
name: Deploy Hugo site to Pages

# Se activara cuando se haga un push sobre la rama main
on:
 push:
 branches:
 - main

# Permisos para que pueda leer el contenido del repo y
# pueda escribir sobre la funcionalidad de GitHub Pages
permissions:
 contents: read
 pages: write
 id-token: write

# Estara asociado al grupo relacionados con pages y no cancelará
# otros procesos que esten en ejecución
concurrency:
 group: "pages"
 cancel-in-progress: false

# Define bash como el encargado de ejecutar los trabajos
defaults:
 run:
 shell: bash

# En este apartado define el entorno usado para el workflow
jobs:
	# 1 TRABAJO DE CONSTRUCCIÓN DEL SITIO
 build:
 # Entorno
 runs-on: ubuntu-latest
 env:
			# Esta variable permite cambiar facilmente la version de HUGO usada
 HUGO_VERSION: 0.121.1
 steps:
 - name: Install Hugo CLI
 run: |
 wget -O ${{ runner.temp }}/hugo.deb https://github.com/gohugoio/hugo/releases/download/v${HUGO_VERSION}/hugo_extended_${HUGO_VERSION}_linux-amd64.deb \
 && sudo dpkg -i ${{ runner.temp }}/hugo.deb
 - name: Install Dart Sass
 run: sudo snap install dart-sass
				# Prepara el entorno para desplegar las páginas
 - name: Checkout
 uses: actions/checkout@v4
 with:
 submodules: recursive
 fetch-depth: 0
 - name: Setup Pages
 id: pages
 uses: actions/configure-pages@v4
 - name: Install Node.js dependencies
 run: "yarn install"
				# Configura las variables de entorno de HUGO y procede a
				# ejecutar el comando para construir el sitio.
 - name: Build with Hugo
 env:
 HUGO_ENVIRONMENT: production
 HUGO_ENV: production
 run: |
 hugo \
 --gc \
 --minify \
 --baseURL "${{ steps.pages.outputs.base_url }}/"
	 # Sube el contenido generado por hugo al directorio de GitHub Pages
			- name: Upload artifact
 uses: actions/upload-pages-artifact@v2
 with:
 path: ./public

 # 2 REDESPLIEGA EL SITIO EN GITHUB PAGES CON LOS NUEVOS CAMBIOS
 deploy:
 environment:
 name: github-pages
 url: ${{ steps.deployment.outputs.page_url }}
 runs-on: ubuntu-latest
 needs: build
 steps:
 - name: Deploy to GitHub Pages
 id: deployment
 uses: actions/deploy-pages@v3

El siguiente paso es hacer commit con el nuevo archivo agregado, con un mensaje descriptivo, y finalmente hacer push de los cambios a la rama main o la que hayas definido en el archivo .yaml de configuración.

git commit -m “feat: implement github actions to deploy site into GitHub Pages” git push origin main

Nos dirigiremos a la página de nuestro repositorio y veremos que GitHub ha detectado automáticamente nuestros cambios con las acciones y las ejecutará. Verás algo similar a la siguiente imagen. Una vez que se completen los workflows correctamente, debes dirigirte a la URL del repositorio, que sería https://<username>.github.io/<repository>. Recuerda que si tu repositorio tiene el mismo nombre que tu usuario, puedes omitir el <repository>.

En caso de que se genere un error o algo similar debes de revisar los logs de cada paso que enontrarás en el link de details al lado de cada uno de los pasos

Configura un dominio personalizado en GitHub Pages

Hasta este punto, hemos configurado y desplegado exitosamente nuestro sitio en GitHub Pages. Ahora, lo que nos falta es configurar nuestro nombre de dominio para que tenga un nombre de nuestra marca o necesidad en cuestión.

En este ejemplo, hemos usado un dominio adquirido en Namecheap que tenemos listo para configurar.

Lo primero que haremos es configurar nuestro dominio dentro de nuestro repositorio. Para ello, nos dirigiremos a settings > pages de nuevo y buscaremos la opción de Custom Domain.
Dentro del input, agregamos el dominio que queremos agregar.
El siguiente paso será configurar las direcciones IP a las cuales queremos que apunte nuestro dominio. Para ello, nos dirigiremos al panel de control de Namecheap e iremos a las opciones avanzadas de nuestro dominio. Las URL listadas son las siguientes:
- 185.199.108.153
- 185.199.109.153
- 185.199.110.153
- 185.199.111.153

Lo que estamos configurando es lo siguiente:

Registros A con la dirección @, que representa la raíz del dominio, apuntando a cuatro direcciones IP diferentes. Son necesarios para que tu dominio personalizado apunte a los servidores de GitHub Pages. Esto permite que cuando alguien ingrese tu dominio en su navegador, la solicitud sea dirigida a los servidores de GitHub, donde está alojado tu proyecto.
Registro CNAME con el host www y el valor <username>.github.io., redirige las solicitudes de www.tudominio.com al subdominio <username>.github.io en GitHub. Esto es útil si quieres que tanto www.tudominio.com como tudominio.com muestren tu proyecto en GitHub Pages.

Ya con esto, tu sitio estaría listo para servir a través de tu dominio personalizado.

Tip

Debes esperar un tiempo para que GitHub confirme que el dominio ingresado está configurado correctamente. Normalmente esto puede tomar entre unos minutos hasta 24 horas dependiendo de la propagación DNS.

Patrones de diseño: Qué son?

Dacadev — Sat, 02 Dec 2023 00:29:10 +0000

Tabla de Contenido

Los patrones de diseño, en general, se pueden definir como soluciones estandarizadas a problemas comunes en el diseño de software. No son fragmentos de código específicos, sino más bien guías o plantillas que se pueden aplicar en diversos contextos de programación.

Estos patrones son especialmente útiles porque permiten reutilizar conocimientos y enfoques que han sido probados y perfeccionados a lo largo de los años, y proporcionan un punto de partida para tus proyectos de software.

Note

Los patrones de diseño son guías que pueden ser adaptadas para cada propósito específico según se requiera.

Los patrones de diseño se dividen en tres categorías principales:

Patrones Creacionales: Estos patrones se relacionan con los procesos de creación de objetos. Su objetivo es abstraer los detalles de la instanciación de clases, haciendo los sistemas más independientes de cómo sus objetos son creados y representados. Dentro de esta categoría encontramos los patrones:
- Singleton
- Factory Method
- Abstract Factory
- Builder
- Prototype.
Patrones Estructurales: Estos patrones se enfocan en cómo las clases y objetos se componen para formar estructuras más grandes. Los patrones estructurales facilitan el diseño al identificar formas sencillas de realizar relaciones entre entidades. Dentro de esta categoría encontramos los patrones:
- Adapter
- Bridge
- Composite
- Decorator
- Facade
- Flyweight
- Proxy.
Patrones de Comportamiento: Estos patrones se centran en la comunicación entre objetos. Son útiles para definir patrones de comunicación entre clases y objetos, haciéndolos más flexibles y eficientes. Encontraremos patrones como:
- Observer [más info]
- Mediator
- Iterator
- Strategy [más info]
- Command
- State
- Visitor.

Cada patrón tiene su propio conjunto de reglas y contextos donde es más adecuado. Lo importante es entender que no existe un patrón que sea mejor que los otros en todas las situaciones.

Principios de diseño

Antes de adentrarte en los patrones de diseño, es buena idea tener unas bases y conceptos iniciales que te ayudarán al momento de estudiar cada uno de los patrones. Estos principios son:

Identifica los aspectos de tu aplicación que pueden cambiar y sepáralos de aquellos que probablemente seguirán igual.
Programa para una interfaz, no para una implementación. Programar para interfaces significa programar para supertipos.
Prefiere la composición sobre la herencia en OO. Es decir, si debes escoger entre una u otra, es más flexible y fácil implementar la composición, ya que esta se define a través de interfaces.
Esfuérzate por lograr diseños con acoplamientos débiles entre objetos que interactúan. Es decir, disminuye al máximo la dependencia entre los objetos de tu aplicación.
Las clases deben ser abiertas a código nuevo y cerradas a la modificación del mismo. Es decir, se debe evitar modificar lo existente siempre que sea posible.
Depende de abstracciones, no de clases concretas. Es decir, no utilices una clase como dependencia de otra; en su lugar, usa una clase abstracta o una interfaz

Qué No Hacer al Usar Patrones de Diseño

Al momento de estudiar y trabajar con los patrones de diseño, es importante tener en cuenta los siguientes puntos:

Conocer las bases de Orientación a Objetos (OO) no te hace un buen diseñador de OO.
Un buen diseño de OO es reutilizable, extensible y mantenible a lo largo del tiempo.
Los patrones te muestran cómo construir buenos sistemas usando cualidades de OO.
Los patrones son experiencias probadas orientadas a objetos.
Los patrones no te dan código; ellos te dan una solución general a problemas de diseño. Tu objetivo como programador e ingeniero de Software es aplicarlos y adaptarlos a tus casos específicos.
Los patrones no son inventados, son descubiertos. Tú podrías encontrar otro a lo largo de tu carrera.
La mayoría de los patrones y principios son capaces de manejar el constante cambio en el software, permitiéndote adaptar tu código a nuevos requerimientos sin grandes refactorizaciones.

Tip

No intentes aplicar todos los patrones de una vez. Empieza por entender el problema que resuelve cada uno y úsalos cuando el contexto lo requiera. La sobreingeniería es tan perjudicial como la falta de diseño.

Código Limpio: Escribe nombres significativos

Dacadev — Thu, 14 Sep 2023 02:18:24 +0000

Tabla de Contenido

Al momento de escribir código, una tarea difícil de la que nadie habla es el hecho de nombrar nuestras variables, funciones, clases, etc. Y si no lo sientes así, déjame contarte por qué es algo a lo que deberías prestarle atención 😉.

Te voy a compartir algunos consejos que te ayudarán a la hora de definir dichos nombres y el porqué es buena práctica. Dentro de estos consejos encontramos…

Note

🚀 El contenido de este post está basado en las enseñanzas del libro “Código Limpio” y lo que he aprendido a lo largo de mi carrera como programador.

Nombres significativos

Los nombres deben transmitir claramente cuál es el propósito del código, es decir, que con el hecho de leer la variable o función, se debe entender qué contiene.

// Incorrecto
const a: string[] = [];

// Correcto
const users: string[] = [];

En el ejemplo anterior podemos ver que en la primera parte estamos definiendo nombres aleatorios para nuestro código lo cual no nos dice nada y en dado caso debemos leer más a fondo el código para entender qué es lo que hace, mientras que en la segunda parte podemos ver claramente que la variable será un arreglo de usuarios.

Transmitir el propósito del código

Los nombres deben transmitir claramente cuál es la intención o uso del código. Por ejemplo, en el siguiente ejemplo podemos ver que en la primera parte el nombre no nos dice nada sobre lo que hace la función, mientras que en la segunda parte podemos ver que el nombre nos dice claramente que dicha función escribirá Hello World.

// Incorrecto
function foo(): void {
 console.log("Hello World");
}

// Correcto
function printHelloWorld(): void {
 console.log("Hello World");
}

Note

🚀 Incluso podemos mejorar el nombre de la función printHelloWorld a printHelloWorldToConsole para ser más explícitos.

Sé explícito y puntual

Los nombres que des dentro de tu código deben ser explícitos, esto significa que deben ser claros al transmitir información, esto ya lo mencioné, pero no caigas en hacerlo en exceso. Observa el siguiente ejemplo.

// Incorrecto
const usersStringNameArray: string[] = ["John", "Mary", "Sam"];

// Correcto
const userNames: string[] = ["John", "Mary", "Sam"];

En el ejemplo observamos que estamos repitiendo información que ya nos brinda el tipado, como por ejemplo nombrar que es un arreglo de strings, lo que termina siendo redundante ya que el tipo de dato está implícito en el tipado string[].

Variables similares

Habrá casos en donde tengas variables cuyo comportamiento es similar o que hagan referencia a un mismo valor y puede ser difícil nombrarlas. Usa nombres que realmente distingan la funcionalidad de dicha variable y cuál es su objetivo, como en el siguiente código:

// Incorrecto
function copyChars(a1: string[], a2: string[]): void {
 for (let i = 0; i < a1.length; i++) {
 a2[i] = a1[i];
 }
}

// Correcto
function copyChars(source: string[], destination: string[]): void {
 for (let i = 0; i < source.length; i++) {
 destination[i] = source[i];
 }
}

Para el ejemplo anterior, podemos observar que el uso de source y destination en lugar de a1 y a2 transmite claramente la funcionalidad de cada variable a pesar de ser similares.

Nombres pronunciables

Usa nombres que sean pronunciables y que estén relacionados con el lenguaje que se esté usando al momento de escribir código. De esta manera, al leer el código no tendrás que hacer mapas mentales de los nombres.

Nombres fáciles de buscar

En concordancia con el punto anterior, además de tener nombres pronunciables, también piensa en que sean fáciles de buscar dentro del código o incluso dentro del proyecto.

Intenta evitar el uso de variables sencillas como a, además de que no transmiten nada, encontrarlas es difícil. ¿Cuántas palabras no tienen una ‘a’? 🙃

Note

🚀 Solo en casos en donde la variable se use una vez en códigos pequeños, como ciclos for, podemos optar por usar variables simples como e.

for (let j: number = 0; j < 34; j++) {
 s += (t[j] * 4) / 5;
}

No permitas los mapas mentales

Cuando nos referimos a mapas mentales del código, estamos pensando en los demás (inclusive en tu yo del futuro). Cuando estás leyendo código y empiezas a crear mapas en tu cabeza con las relaciones de cada nombre de variable, función, etc., estás agregando una tarea adicional e innecesaria porque en sí tienes que entender el código y ahora tener ese mapa de nombres en la cabeza. ¿Imagínate si tienes muchas variables o nombres?

Para evitar esto, no uses nombres simples como i, j (muy común en ciclos for) o r para decir url o response. Simplemente coloca el nombre que corresponde.

Nombres en las clases

Además de los consejos ya presentados, en las clases debemos tener en cuenta también otros casos para escribir código entendible y mantenible. Ten en cuenta estas consideraciones:

Las clases deben tener nombres sustantivos y NO verbales o de acciones. Un sustantivo es una palabra que se utiliza para nombrar personas, animales, cosas, lugares o ideas.
Los métodos de las clases deben tener nombres que hagan referencia a verbos o frases verbales, como postPayment, deletePage o save.
Los accesores, mutadores, getters o setters deben ser nombrados según su valor y llevar el prefijo get/set e is.
Define una forma de nombrar las acciones y aférrate a ella. Por ejemplo, si usas get, no uses fetch en otros. De esta manera mantienes la consistencia a través del código y/o proyecto.