Saltar al contenido

Lección 10 de 12 · Lectura y práctica

Variables CSS y arquitectura modular

CONCEPTO CLAVE: Las Variables CSS (Custom Properties) son entidades definidas por el autor que contienen valores específicos que pueden ser reutilizados en todo el documento. Permiten crear sistemas de diseño consistentes y.

Del concepto a la práctica

Taller de esta lección

Las variables CSS permiten centralizar decisiones que se repiten. La arquitectura modular consiste en separar tokens globales de reglas de componentes: si el color principal cambia, modificas una declaración, no cada botón y enlace por separado.

Ejemplo resuelto

Un panel de aviso reutiliza el color y el espacio definidos en :root.

css
:root {
  --color-acento: #24506b;
  --espacio-2: 8px;
}
.notice {
  border-inline-start: 4px solid var(--color-acento);
  padding: var(--espacio-2);
}
  1. Nombra tokens globales por función; un componente también puede declarar variables locales cuando necesita valores propios.

  2. Decláralas en :root si son globales.

  3. Consúmelas con var() dentro del módulo.

  4. Cambia el valor una sola vez y revisa todos sus usos.

Error frecuente: escribir --Color-Acento y consumir --color-acento. Corrígelo respetando mayúsculas y minúsculas exactamente.

Pruébalo

Define variables para color, espacio y radio; úsalas en dos tarjetas distintas.

Comprueba tu resultado

Al cambiar una variable, deben actualizarse las dos tarjetas y ninguna regla debe repetir literalmente el mismo valor tokenizado.

Comparación de una interfaz sin jerarquía y otra con título, información y acción claramente ordenados.
CursaloMapa de práctica
La jerarquía guía la mirada

El tamaño, el espacio y el contraste ayudan a distinguir lo principal de lo secundario. Una jerarquía clara guía la lectura desde el título hasta la información y la acción. Comprueba que el orden visual coincida con la tarea de la persona.

Ver la infografía en tamaño completo ↗
CONCEPTO CLAVE: Las Variables CSS (Custom Properties) son entidades definidas por el autor que contienen valores específicos que pueden ser reutilizados en todo el documento. Permiten crear sistemas de diseño consistentes y facilitan el mantenimiento del código.

¿Qué son las Variables CSS?

Las Variables CSS, también conocidas como Custom Properties, son valores que definimos una vez y usamos en múltiples lugares de nuestra hoja de estilos. Imagina que son como cajas donde guardas colores, tamaños o cualquier valor que necesites repetir.

La sintaxis es simple: un nombre precedido por dos guiones (--) y un valor. Para usarlas, utilizas la función var(--nombre-variable).

:root {
  --color-primario: #3498db;
  --color-secundario: #2ecc71;
  --espaciado-base: 16px;
  --tamano-fuente: 1rem;
}

button {
  background-color: var(--color-primario);
  padding: var(--espaciado-base);
  font-size: var(--tamano-fuente);
}

¿Por qué usar Variables CSS?

📌 El problema: Sin variables, si quieres cambiar el color principal de tu sitio, tendrías que buscar y reemplazar en dozens de lugares. Con sitios grandes, esto es un desastre.

Las Variables CSS te permiten:

  1. Reutilización: Define un valor, úsalo infinite veces.
  2. Mantenimiento: Cambia una vez, actualiza en todas partes.
  3. Consistencia: Asegura que los mismos valores se usen uniformemente.
  4. Temas: Facilita crear temas claros y oscuros cambiando solo los valores.
  5. Legibilidad: Tu código es más fácil de entender y mantener.

Sintaxis y Uso Básico

Para declarar una variable CSS, usa cualquier selector. Sin embargo, la convención es usar :root para variables globales:

:root {
  --mi-color: #ff6b6b;
  --mi-espaciado: 20px;
  --mi-familia: 'Segoe UI', sans-serif;
}

/* También puedes definir variables en selectores específicos */
.card {
  --card-padding: 24px;
  padding: var(--card-padding);
}

/* Fallback cuando la variable no existe */
.elemento {
  color: var(--mi-color, #000000);
}
💡 Tip: El segundo parámetro de var() es un valor de respaldo (fallback) que se usa si la variable no está definida. Es buena práctica incluirlo siempre.

Arquitectura Modular con Variables CSS

La arquitectura modular es un enfoque de desarrollo donde separas tu código en bloques independientes y reutilizables. Las variables CSS son fundamentales para crear esta arquitectura.

El Enfoque ITCSS

ITCSS (Inverted Triangle CSS) es una metodología que organiza tu CSS en capas desde lo más genérico hasta lo más específico:

  1. Settings: Variables, configuraciones globales.
  2. Tools: Mixins, funciones (si usas preprocesadores).
  3. Generic: Reset, normalización.
  4. Base: Estilos de elementos HTML.
  5. Objects: Patrones reutilizables sin estilos visuales.
  6. Components: Componentes específicos con estilos.
  7. Utilities: Clases de utilidad.
/* ===== SETTINGS ===== */
:root {
  /* Colores */
  --color-brand: #6366f1;
  --color-brand-dark: #4f46e5;
  --color-text: #1f2937;
  --color-background: #ffffff;
  
  /* Espaciado */
  --space-xs: 4px;
  --space-sm: 8px;
  --space-md: 16px;
  --space-lg: 24px;
  --space-xl: 32px;
  
  /* Tipografía */
  --font-sans: 'Inter', system-ui, sans-serif;
  --font-size-sm: 0.875rem;
  --font-size-base: 1rem;
  --font-size-lg: 1.125rem;
  --line-height: 1.5;
  
  /* Bordes */
  --radius-sm: 4px;
  --radius-md: 8px;
  --radius-lg: 12px;
}

/* ===== COMPONENTE BUTTON ===== */
.btn {
  display: inline-flex;
  align-items: center;
  justify-content: center;
  padding: var(--space-sm) var(--space-md);
  font-family: var(--font-sans);
  font-size: var(--font-size-base);
  font-weight: 500;
  line-height: var(--line-height);
  border: none;
  border-radius: var(--radius-md);
  cursor: pointer;
  transition: all 0.2s ease;
}

.btn--primary {
  background-color: var(--color-brand);
  color: white;
}

.btn--primary:hover {
  background-color: var(--color-brand-dark);
  transform: translateY(-1px);
}
⚠️ Advertencia: No uses variables CSS para todo. Si un valor solo se usa una vez y no tiene significado semántico, no necesita ser una variable. Por ejemplo, width: 73.5% puede quedar como está.

Temas con Variables CSS

Una de las ventajas más poderosas de las variables CSS es la capacidad de implementar temas fácilmente:

:root {
  --bg-color: #ffffff;
  --text-color: #1a1a1a;
  --surface-color: #f5f5f5;
}

[data-theme="dark"] {
  --bg-color: #1a1a1a;
  --text-color: #f5f5f5;
  --surface-color: #2d2d2d;
}

body {
  background-color: var(--bg-color);
  color: var(--text-color);
}

.card {
  background-color: var(--surface-color);
}
<!-- En tu HTML -->
<button onclick="toggleTheme()">Cambiar Tema</button>

<script>
function toggleTheme() {
  const current = document.documentElement.getAttribute('data-theme');
  document.documentElement.setAttribute(
    'data-theme',
    current === 'dark' ? 'light' : 'dark'
  );
}
</script>

Variables CSS con Componentes

Las variables de componentes permiten personalizar componentes desde el HTML sin crear nuevas clases:

.card {
  /* Variables con valores por defecto */
  --card-padding: 24px;
  --card-bg: #ffffff;
  --card-radius: 12px;
  
  padding: var(--card-padding);
  background: var(--card-bg);
  border-radius: var(--card-radius);
}

/* Personalización desde HTML */
.card--featured {
  --card-padding: 40px;
  --card-bg: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
  --card-radius: 20px;
}
<div class="card">
  <h3>Tarjeta Normal</h3>
  <p>Usa los valores por defecto</p>
</div>

<div class="card card--featured">
  <h3>Tarjeta Destacada</h3>
  <p>Personalizada con variables</p>
</div>
📌 Buena práctica: Usa la convención de nombres con guiones bajos o guiones para separar palabras: --color-primary, --spacing-large, --font_family_main.

Ejemplo Práctico: Sistema de Diseño Completo

/* ============================
   SISTEMA DE DISEÑO BÁSICO
   ============================ */

:root {
  /* Tokens de color */
  --indigo-50: #eef2ff;
  --indigo-100: #e0e7ff;
  --indigo-500: #6366f1;
  --indigo-600: #4f46e5;
  --indigo-900: #312e81;
  
  /* Tokens semánticos */
  --color-primary: var(--indigo-600);
  --color-primary-hover: var(--indigo-500);
  --color-text: var(--indigo-900);
  --color-bg: var(--indigo-50);
  
  /* Tokens de espaciado */
  --space-1: 0.25rem;
  --space-2: 0.5rem;
  --space-3: 0.75rem;
  --space-4: 1rem;
  --space-6: 1.5rem;
  --space-8: 2rem;
  --space-12: 3rem;
  
  /* Tokens de tipografía */
  --text-xs: 0.75rem;
  --text-sm: 0.875rem;
  --text-base: 1rem;
  --text-lg: 1.125rem;
  --text-xl: 1.25rem;
  --text-2xl: 1.5rem;
  --text-3xl: 1.875rem;
  
  /* Tokens de sombra */
  --shadow-sm: 0 1px 2px 0 rgba(0, 0, 0, 0.05);
  --shadow-md: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
  --shadow-lg: 0 10px 15px -3px rgba(0, 0, 0, 0.1);
  
  /* Tokens de animación */
  --transition-fast: 150ms;
  --transition-base: 300ms;
  --transition-slow: 500ms;
}

/* Aplicando tokens */
body {
  font-family: system-ui, -apple-system, sans-serif;
  font-size: var(--text-base);
  line-height: 1.6;
  color: var(--color-text);
  background-color: var(--color-bg);
}

.button {
  display: inline-flex;
  align-items: center;
  justify-content: center;
  padding: var(--space-3) var(--space-6);
  font-size: var(--text-base);
  font-weight: 600;
  color: white;
  background-color: var(--color-primary);
  border-radius: var(--space-2);
  box-shadow: var(--shadow-md);
  transition: all var(--transition-fast);
}

.button:hover {
  background-color: var(--color-primary-hover);
  box-shadow: var(--shadow-lg);
  transform: translateY(-2px);
}
Ver más: Ventajas sobre preprocesadores

A diferencia de los preprocesadores como Sass o Less, las Variables CSS:

  • Nativas: No requieren compilación ni herramientas adicionales.
  • Runtime: Se pueden modificar con JavaScript en tiempo real.
  • Herencia: Respetan el cascade y la herencia de CSS.
  • DOM: Pueden leerse y modificarse directamente desde el DOM.
// Cambiar variable CSS con JavaScript
document.documentElement.style.setProperty('--color-primary', '#ff0000');

// Leer variable CSS
const color = getComputedStyle(document.documentElement)
  .getPropertyValue('--color-primary');
console.log(color); // #ff0000

Organización de Archivos

Para proyectos más grandes, organiza tus archivos de esta manera:

Archivo Contenido
tokens.css Todas las variables CSS (:root)
reset.css Normalize/reset de estilos
base.css Estilos base de elementos HTML
components.css Componentes reutilizables
layout.css Estructura de página (header, footer, grid)
utilities.css Clases de utilidad
main.css Archivo principal que importa todos
/* main.css */
@import 'tokens.css';
@import 'reset.css';
@import 'base.css';
@import 'components.css';
@import 'layout.css';
@import 'utilities.css';
💡 Tip profesional: Para proyectos simples, puedes tener todo en un archivo. Para proyectos complejos, separar facilita el mantenimiento y la colaboración en equipo.
Las Variables CSS transforman tu CSS de una colección de valores repetidos a un sistema de diseño coherente y mantenible.

Resumen y Próximos Pasos

Has aprendido conceptos fundamentales sobre Variables CSS y arquitectura modular:

  1. Las Variables CSS se declaran con --nombre: valor y se usan con var(--nombre).
  2. Usa :root para variables globales que aplicarán en todo el documento.
  3. Crea tokens semánticos que representen decisiones de diseño.
  4. Implementa temas cambiando los valores de las variables.
  5. Usa variables en componentes para facilitar su personalización.
  6. Organiza tu CSS siguiendo metodologías como ITCSS para mejor mantenibilidad.
🧠 Quiz

¿Cuál es la sintaxis correcta para declarar y usar una variable CSS llamada '--color-primary' con el valor '#ff6b6b'?

  • A) $color-primary: #ff6b6b; y luego $color-primary;
  • B) --color-primary: #ff6b6b; y luego var(--color-primary)
  • C) var-color-primary: #ff6b6b; y luego --color-primary
  • D) color-primary: #ff6b6b; y luego $color-primary
✅ Respuesta correcta: B. Las variables CSS se declaran con prefijo -- y se usan con la función var().
⚠️ Recuerda: Las variables CSS son sensibles a mayúsculas y minúsculas. --Color y --color son variables diferentes. Mantén un naming convention consistente en todo tu proyecto.

Sigue con HTML y CSS Moderno desde Cero

Esta lección forma parte de un curso de Cursalo. Revisa su programa y elige entre la compra individual o el acceso a toda la escuela.

Si ya tenías acceso a este curso, entra con tu cuenta: tus derechos y tu progreso se conservan. No necesitas comprarlo de nuevo.

01 / ELEGIR UNA RUTA

El próximo paso

Aprende IA mientras construyes algo que sí necesitas.

Empieza por el curso inicial o explora el catálogo para encontrar una práctica alineada con tu trabajo.