Skip to content

Sass Hoja de referencia

Preprocesador de CSS potente con variables, anidamiento y mixins.

01

Fundamentos de Sass

Variables y anidamiento

Las variables de Sass usan el prefijo $. El anidamiento refleja la estructura del HTML. & se refiere al selector padre. Usa lighten()/darken() para manipular colores.

sass
// SCSS syntax ($var)
$primary-color: #3498db;
$font-stack: -apple-system, sans-serif;

body {
  font-family: $font-stack;
  color: $primary-color;

  a {
    color: lighten($primary-color, 20%);

    &:hover {
      color: darken($primary-color, 10%);
    }
  }
}

SCSS vs sintaxis indentada

SCSS (.scss) es un superconjunto de CSS — cualquier archivo CSS válido es SCSS válido. Sass (.sass) elimina llaves y punto y coma, confiando en la sangría. SCSS es más popular y más fácil de migrar. Elige uno y sé consistente dentro de un proyecto.

sass
// SCSS (.scss) - uses braces and semicolons
.box {
  width: 100px;
  height: 100px;
}

// Sass (.sass) - indentation-based, no braces/semicolons
.box
  width: 100px
  height: 100px

// Both compile to the same CSS
// .box { width: 100px; height: 100px; }

Comentarios

Los comentarios // son silenciosos (eliminados en la salida). Los comentarios /* */ se conservan en el CSS compilado. Los comentarios /*! */ se mantienen incluso en modo comprimido/producción — úsalos para licencias o avisos críticos. Usa // para documentación interna.

sass
// Single-line comment - NOT compiled to CSS
/* Multi-line comment - compiled to CSS */
/*! Important comment - always kept even in compressed mode */

// Silent comment for developers
$base-font: 16px;

/*! Keep this copyright notice */
body { font-size: $base-font; }

Compilación

Sass compila .scss/.sass a .css. --watch recompila automáticamente al guardar. Estilos de salida: expanded (legible por defecto), nested (indentado), compact (una regla por línea), compressed (minificado para producción). Usa compressed en producción para reducir el tamaño del archivo.

sass
// Compile a single file
// $ sass input.scss output.css

// Watch for changes
// $ sass --watch input.scss:output.css

// Watch a directory
// $ sass --watch scss/:css/

// Compressed output
// $ sass --style=compressed input.scss output.css

// Four output styles: expanded, nested, compact, compressed
$width: 100px;
.box { width: $width; }

Visión general de la herencia de selectores

Sass es un preprocesador de CSS que añade variables, anidamiento, mixins, herencia, funciones y flujo de control. Estos reducen la repetición (principio DRY) y hacen manejables las hojas de estilo grandes. Todas las características de Sass compilan a CSS estándar.

sass
// Sass adds programming features to CSS:
// 1. Variables ($var)
// 2. Nesting
// 3. Mixins (@mixin / @include)
// 4. Inheritance (@extend)
// 5. Functions (@function)
// 6. Control directives (@if, @for, @each, @while)
// 7. Partials & Modules (@use, @forward)

// These features help keep stylesheets DRY and maintainable.
$radius: 4px;
.card { border-radius: $radius; }
02

Variables y tipos de datos

Declaración de variables y ámbito

Las variables declaradas fuera de cualquier bloque son globales. Las declaradas dentro de un bloque son locales a ese bloque. Las locales ocultan a las globales con el mismo nombre. Usa locales para no contaminar el espacio de nombres global.

sass
$color: #333;          // global scope
$padding: 10px;         // global

.block {
  $local-color: #fff;   // local to .block
  color: $local-color;
  padding: $padding;    // can read globals
}

// $local-color is NOT available here
// .other { color: $local-color; } // ERROR

Flag !default

!default asigna un valor solo si la variable es null o undefined. Esto deja que los usuarios anulen los valores por defecto de una librería fijando variables ANTES de importarla. Crítico para construir librerías y sistemas de diseño Sass configurables.

sass
// Only assign if the variable is not already defined
$base-color: #333 !default;
$base-color: #fff; // this wins (already? no - assigned above first)

// Useful in libraries/partials for user overrides
// _theme.scss
$primary: blue !default;
.button { background: $primary; }

// User config BEFORE importing
// $primary: red;
// @use 'theme';  -> button is red

Flag !global

!global asigna explícitamente al ámbito global desde dentro de un bloque (mixin, función, directiva de control). Desde Sass 3+, la asignación dentro de bloques es local por defecto. Usa !global con moderación — la mutación global puede hacer el código difícil de razonar.

sass
$count: 0;

@for $i from 1 through 3 {
  $count: $count + $i !global;
}

// $count is now 6 (1+2+3)
.total { content: "#{$count}"; }

// Without !global, the assignment inside @for
// would create a local variable instead

Tipos de datos

Sass tiene 7 tipos de datos: números (con unidades), cadenas, colores, booleanos, null, listas y mapas. type-of() devuelve el tipo como cadena. Entender los tipos es esencial para usar correctamente las funciones y directivas de control.

sass
// Sass has 7 data types:
$number:  16px;              // number (with optional unit)
$string:  "Helvetica";       // string (quoted or unquoted)
$color:   #3498db;           // color
$boolean: true;              // boolean (true/false)
$null:    null;              // null (no value)
$list:    10px 20px 30px;    // list (space or comma separated)
$map:     (key: value);      // map (key-value pairs)

// Type checking
type-of($number)  // number
type-of($list)    // list
type-of($map)     // map

Interpolación #{}

La interpolación #{} inyecta variables en selectores, nombres de propiedad, cadenas y otros lugares donde las variables planas no están permitidas. A diferencia de $var que solo funciona en valores, #{} funciona casi en cualquier lugar. Convierte cualquier valor a su representación como cadena.

sass
$name: "user";
$version: 2;

// Use #{} to insert variables into selectors and strings
.#{$name}-avatar { background: url("/img/#{$name}.png"); }

// In property names and values
.icon-#{$name} {
  content: "v#{$version}";
}

// Interpolation in @media and @include
@media (max-width: #{$version * 100}px) {
  body { font-size: 14px; }
}
03

Anidamiento

Anidamiento básico

El anidamiento te permite escribir selectores que reflejan la jerarquía del HTML, evitando repetir los selectores padre. El CSS compilado crea selectores descendientes. Esto mejora la legibilidad pero el abuso crea selectores demasiado específicos — mantén el anidamiento a 3-4 niveles como máximo.

sass
// SCSS nesting mirrors HTML structure
.nav {
  background: #333;

  ul {
    list-style: none;
    margin: 0;

    li {
      display: inline-block;
    }
  }

  a {
    color: white;
    text-decoration: none;
  }
}

// Compiles to: .nav {...} .nav ul {...} .nav ul li {...} .nav a {...}

Anidamiento profundo (antipatrón)

El anidamiento profundo crea selectores largos y demasiado específicos que son difíciles de sobrescribir y más lentos de emparejar para los navegadores. La regla práctica: no anides más de 3-4 niveles. Aplana las estructuras profundas con clases explícitas estilo BEM por mantenibilidad.

sass
// AVOID: overly deep nesting
.header {
  .nav {
    > ul {
      li {
        a {
          span {  // 5 levels deep!
            color: red;
          }
        }
      }
    }
  }
}

// Compiles to: .header .nav > ul li a span
// Too specific - hard to override, slow to match

// BETTER: flatten with classes
.header-nav-link-text { color: red; }

Propiedades anidadas

Las propiedades anidadas usan dos puntos tras el espacio de nombres de la propiedad (font:, border:, margin:) para agrupar subpropiedades relacionadas. Esto evita repetir el prefijo y es puramente azúcar sintáctico. Compila a propiedades CSS estándar como font-family, border-top, etc.

sass
.icon {
  // Shorthand for font-family, font-size, font-weight...
  font: {
    family: "Arial";
    size: 14px;
    weight: bold;
  }

  // border-top, border-right, etc.
  border: {
    top: 1px solid #ccc;
    bottom: 2px dashed #999;
  }
}

// Compiles to: font-family, font-size, font-weight, border-top, border-bottom

Anidar media queries

Anidar consultas @media dentro de las reglas mantiene los estilos responsivos colocalizados con el componente, mejorando la mantenibilidad. El CSS compilado eleva @media al nivel superior. Es una gran victoria de legibilidad frente a esparcir media queries por los archivos.

sass
.container {
  width: 100%;

  // Media query nested inside the rule
  @media (min-width: 768px) {
    width: 720px;
  }

  @media (min-width: 1024px) {
    width: 960px;
  }
}

// Compiles to:
// .container { width: 100%; }
// @media (min-width: 768px) { .container { width: 720px; } }
// @media (min-width: 1024px) { .container { width: 960px; } }

Listas de selectores en el anidamiento

Al anidar una lista de selectores separados por comas, Sass combina cada ítem con el padre. Es más limpio que escribir cada combinación a mano. El & también puede usarse dentro de listas anidadas para añadir clases/modificadores a varios padres a la vez.

sass
.btn {
  // Comma creates a selector list
  .icon,
  .label {
    color: white;
  }
}

// Compiles to:
// .btn .icon, .btn .label { color: white; }

// Nesting a list with &
.card,
.panel {
  &.active { border-color: blue; }
}

// .card.active, .panel.active { border-color: blue; }
04

Selector padre (&)

Selector padre básico

& se refiere al selector padre, permitiendo anidar pseudo-clases (:hover, :focus), pseudo-elementos (::before) y modificadores. Esto mantiene juntos los estilos relacionados. &:hover compila a .button:hover. Sin &, obtendrías un selector descendiente.

sass
.button {
  background: blue;
  color: white;

  // & refers to the parent (.button)
  &:hover {
    background: darkblue;
  }

  &:focus {
    outline: 2px solid blue;
  }

  &::after {
    content: "→";
  }
}

// Compiles to: .button, .button:hover, .button:focus, .button::after

BEM con &

& habilita el nombrado BEM (Bloque Elemento Modificador) de forma concisa. &__título añade __título al padre, creando .card__título. &--destacado crea clases modificadoras. Esto mantiene la generación de clases BEM DRY y consistente dentro de la definición de un bloque.

sass
// BEM methodology with parent selector
.card {
  background: white;

  &__title {       // .card__title
    font-size: 18px;
  }

  &__body {        // .card__body
    padding: 16px;
  }

  &--featured {    // .card--featured
    border-color: gold;
  }

  &--featured &__title {  // .card--featured .card__title
    color: gold;
  }
}

Sufijar el selector padre

Colocar & al inicio de un selector anidado añade el sufijo al padre, generando selectores compuestos como .button-primary. Es útil para nombrar variantes. Ten cuidado — abusar del sufijado puede oscurecer los nombres de clase generados al leer el código.

sass
.button {
  background: blue;

  // Append suffix to parent
  &-primary { background: darkblue; }    // .button-primary
  &-secondary { background: gray; }      // .button-secondary
  &-danger { background: red; }          // .button-danger

  // Combining with state
  &-primary.is-active { font-weight: bold; }
}

// Generates: .button, .button-primary, .button-secondary, .button-danger

Anidamiento invertido

Colocar & al final de un selector anidado invierte el orden — el padre pasa a ser descendiente. Es perfecto para estilos contextuales/de tema como .dark-theme .modal donde el componente se adapta al contexto de su ancestro, manteniendo las anulaciones específicas de contexto cerca del componente.

sass
.modal {
  // & at the end - parent as descendant
  .dark-theme & {
    background: #222;
    color: #eee;
  }

  .sidebar & {
    width: 200px;
  }
}

// Compiles to:
// .dark-theme .modal { background: #222; color: #eee; }
// .sidebar .modal { width: 200px; }

// Useful when parent is styled differently in a context

Varios & en un selector

Puedes usar & varias veces en un mismo selector. & + & genera .button + .button para estilizar hermanos. Es potente para espaciar elementos repetidos y selectores complejos basados en estado. Cada & se reemplaza por el selector padre completo.

sass
.button {
  // Multiple & references in one selector
  & + & {              // .button + .button (adjacent sibling)
    margin-left: 8px;
  }

  & ~ & {              // .button ~ .button (general sibling)
    margin-top: 4px;
  }

  &.active &__icon {   // .button.active .button__icon
    color: white;
  }

  .parent &.is-open &__content {
    display: block;
  }
}
05

Parciales (archivos _partial)

Crear parciales

Los parciales son archivos Sass nombrados con guion bajo inicial (por ejemplo, _variables.scss). El guion bajo le indica a Sass que no los compile a un archivo CSS separado. Los parciales están pensados para importarse en un archivo principal. Esto modulariza el código por mantenibilidad.

sass
// _variables.scss - partial file (underscore prefix)
$primary: #3498db;
$secondary: #2ecc71;
$font-base: 16px;

// _buttons.scss
.button {
  background: $primary;
  padding: $font-base / 2;
}

// Partials are NOT compiled to their own CSS file.
// The underscore tells Sass this is a partial.
// Import them into a main file:
// main.scss:  @use 'variables'; @use 'buttons';

Convenciones de nombrado de parciales

Los parciales usan nombres descriptivos con guion bajo inicial. La sentencia @use o @import omite el guion bajo y la extensión — Sass resuelve 'variables' a _variables.scss automáticamente. Un nombrado consistente ayuda a los equipos a localizar el código rápido.

sass
// Common partial naming patterns:
// _variables.scss   - variables
// _mixins.scss      - mixins
// _functions.scss   - functions
// _reset.scss       - CSS reset
// _base.scss        - base styles
// _typography.scss  - typography
// _buttons.scss     - button component
// _header.scss      - header component
// _footer.scss      - footer component
// _mediaqueries.scss - media queries

// Import without the underscore or extension:
// @use 'variables';
// @use 'mixins';

Patrón de arquitectura 7-1

El patrón 7-1 es una arquitectura de Sass ampliamente adoptada: 7 carpetas (abstracts, base, components, layout, pages, themes, vendors) más un punto de entrada main.scss. Escala bien para proyectos grandes al separar preocupaciones. Cada carpeta guarda parciales importados en main.scss.

sass
// 7-1 architecture: 7 folders, 1 main file
// sass/
//   abstracts/   - variables, functions, mixins
//   base/        - reset, typography, base styles
//   components/  - buttons, cards, nav
//   layout/      - header, footer, grid
//   pages/       - home, about specific styles
//   themes/      - theme definitions
//   vendors/     - third-party
//   main.scss    - imports everything

// main.scss
// @use 'abstracts/variables';
// @use 'base/reset';
// @use 'components/buttons';
// @use 'layout/header';

Parciales índice (_index.scss)

Un parcial _index.scss (o _all.scss) actúa como la API pública de una carpeta, reenviando sus parciales. Esto te permite importar una carpeta entera con una sola sentencia @use. Al añadir un parcial nuevo, actualizas solo el índice — el archivo principal queda sin cambios. Este es el patrón del sistema de módulos de Sass.

sass
// sass/components/_index.scss
// Forward all component partials from one entry point
@forward 'buttons';
@forward 'cards';
@forward 'nav';
@forward 'modal';

// Now in main.scss, one line imports everything:
// @use 'components';
// (resolves to components/_index.scss)

// This keeps the main file clean and lets
// you reorganize partials without touching main.scss

Buenas prácticas de parciales

Buenas prácticas: una preocupación por parcial, archivos pequeños (50-200 líneas), usa @use para gestión explícita de dependencias y evita las importaciones circulares. Los parciales mejoran la mantenibilidad y la reutilización. La sentencia @use hace explícitas las dependencias, a diferencia del antiguo @import.

sass
// 1. One concern per partial
// _buttons.scss  -> only buttons
// _forms.scss    -> only forms

// 2. Keep partials small and focused
// (50-200 lines is a good target)

// 3. Use @use (not @import) for explicit dependencies
// _card.scss
@use '../abstracts/variables' as *;
@use '../abstracts/mixins' as *;

.card {
  background: $white;
  @include card-shadow;
}

// 4. Avoid circular dependencies
06

@import y @use

@import (obsoleto)

@import está obsoleto porque contamina el espacio de nombres global, puede ejecutar archivos varias veces y no ofrece privacidad ni namespacing. Sass recomienda migrar a @use y @forward. El código @import existente sigue funcionando pero debería migrarse para proyectos nuevos.

sass
// @import - the OLD way (deprecated in Sass 1.80+)
@import 'variables';
@import 'mixins';
@import 'buttons';

// Problems with @import:
// 1. Globals leak across files (no namespacing)
// 2. Each @import of the same file runs it again
// 3. No way to make members private
// 4. Extends and mixins can conflict

// Use @use instead (the modern module system)
$primary: blue;

@use básico (con espacio de nombres)

@use carga un módulo una vez y expone sus miembros a través de un espacio de nombres (el nombre del archivo por defecto). Accede a los miembros con espacio.$var o espacio.nombreMixin(). Esto evita la contaminación global y los conflictos de nombres. Cada módulo se carga solo una vez, sin importar cuántas veces aparezca @use.

sass
// _variables.scss
$primary: #3498db;
$radius: 4px;

// main.scss - @use creates a namespace (filename by default)
@use 'variables';

.button {
  // Access via namespace::member
  background: variables.$primary;
  border-radius: variables.$radius;
}

// The namespace prevents naming collisions
// and makes dependencies explicit

@use con as

'as v' renombra el espacio de nombres a algo más corto. 'as *' carga los miembros en el ámbito actual sin prefijo — cómodo pero arriesga colisiones, así que úsalo con moderación. Los espacios de nombres con nombre son más seguros y dejan claro de dónde viene cada miembro al leer el código.

sass
// _variables.scss
$primary: blue;
$secondary: green;

// Rename the namespace with 'as'
@use 'variables' as v;

.btn {
  background: v.$primary;
  color: v.$secondary;
}

// Or remove the namespace entirely (use with caution)
@use 'variables' as *;

.card {
  background: $primary;  // direct access, no prefix
}

// 'as *' can cause collisions - prefer named namespaces

@use con configuración (with)

'with (...)' configura las variables !default de un módulo al cargarlo. Esto reemplaza el patrón de configuración con variables globales de @import. La cláusula with debe ir antes de cualquier otro uso del módulo. Es la forma estándar de configurar temas de librerías y tokens de diseño.

sass
// _theme.scss
$primary: blue !default;
$radius: 4px !default;

.button {
  background: $primary;
  border-radius: $radius;
}

// main.scss - configure variables on import
@use 'theme' with (
  $primary: red,
  $radius: 8px
);

// The 'with' clause sets variables marked !default
// This is how libraries are configured by users

Comparación @use vs @import

Migración de @import a @use: los miembros pasan a tener espacio de nombres, los archivos se cargan una vez, y los miembros que empiezan con - o _ son privados (no expuestos). @use hace explícitas las dependencias y evita la contaminación global accidental. Usa la herramienta sass-migrator para automatizar la migración de bases de código grandes.

sass
// @import (old) - global, no namespace
@import 'variables';
.button { background: $primary; }  // global $primary

// @use (new) - namespaced, loaded once
@use 'variables';
.button { background: variables.$primary; }

// Key differences:
// @import: global scope, runs multiple times, no privacy
// @use:    namespaced, runs once, supports private (-prefix)

// _mixins.scss with a private member
@mixin -internal { /* private - not exposed */ }
@mixin public { @include -internal; }

// @use only exposes non-private (no dash prefix) members
07

Mixins (@mixin / @include)

Definir y usar mixins

@mixin define un bloque reutilizable de declaraciones (e incluso reglas). @include inserta el contenido del mixin donde se usa. Los mixins son ideales para prefijos de fabricantes, clearfixes y grupos de declaraciones repetidos. A diferencia de @extend, los mixins duplican las declaraciones cada vez que se incluyen.

sass
// Define a mixin with @mixin
@mixin center {
  display: flex;
  justify-content: center;
  align-items: center;
}

@mixin card-shadow {
  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
}

// Use with @include
.hero {
  @include center;
  height: 200px;
}

.modal {
  @include center;
  @include card-shadow;
}

Argumentos de mixin

Los mixins aceptan argumentos como las funciones. Pásalos por posición (el orden importa) o por nombre (independiente del orden, más claro). Los argumentos con nombre son útiles para mixins con muchos parámetros opcionales. Los argumentos hacen los mixins flexibles y reutilizables con distintos valores.

sass
@mixin button($bg, $color) {
  background: $bg;
  color: $color;
  padding: 8px 16px;
  border: none;
  border-radius: 4px;
}

// Pass arguments by position
.btn-primary { @include button(blue, white); }
.btn-danger { @include button(red, white); }

// Pass arguments by name (clearer, order-independent)
.btn-info { @include button($color: white, $bg: teal); }

Argumentos por defecto

Los valores de argumento por defecto hacen los mixins flexibles — quien llama puede omitir argumentos para usar los por defecto. Usa argumentos con nombre para sobrescribir parámetros concretos manteniendo los demás en sus valores por defecto. Los valores por defecto se evalúan cada vez que se incluye el mixin, no una vez al definirlo.

sass
@mixin border($width: 1px, $style: solid, $color: #ccc) {
  border: $width $style $color;
}

// Use all defaults
.box { @include border; }
// border: 1px solid #ccc;

// Override one - use named args to skip earlier ones
.card { @include border($color: blue); }
// border: 1px solid blue;

// Override by position
.banner { @include border(2px, dashed); }
// border: 2px dashed #ccc;

Mixin con @content

@content inyecta un bloque de estilos pasado a @include. Es extremadamente potente para mixins de media queries, keyframes y contextos envolventes. El bloque incluido se evalúa en el ámbito de quien llama, así que puede usar las variables de este. Mira la sección @content para el paso de argumentos.

sass
// @content lets you pass a block of styles to a mixin
@mixin respond-to($breakpoint) {
  @media (min-width: $breakpoint) {
    @content;  // injected styles go here
  }
}

.sidebar {
  width: 100%;

  @include respond-to(768px) {
    width: 250px;  // this block replaces @content
    float: left;
  }
}

// Compiles to:
// .sidebar { width: 100%; }
// @media (min-width: 768px) { .sidebar { width: 250px; float: left; } }

Argumentos variables (...)

El operador ... sirve para dos cosas: en la definición de un mixin, recoge los argumentos extra en una lista (variádico); en el sitio de llamada, expande una lista en argumentos individuales. Es esencial para mixins que envuelven propiedades CSS que aceptan un número variable de valores, como box-shadow y transition.

sass
// ... captures multiple args into a list (or expands a list)
@mixin box-shadow($shadows...) {
  box-shadow: $shadows;
}

.card { @include box-shadow(0 1px 2px black, 0 4px 8px gray); }
// box-shadow: 0 1px 2px black, 0 4px 8px gray;

// Expanding a list into arguments
$shadows: 0 1px 2px black, 0 4px 8px gray;
.modal { @include box-shadow($shadows...); }

// Also works for @include with maps as keyword args
@mixin theme($colors) { /* ... */ }
@include theme(("bg": red, "fg": white)...);
08

@extend y herencia

@extend básico

@extend hace que un selector herede la totalidad de los estilos de otro, compartiendo la regla en lugar de duplicarla. El CSS compilado agrupa los selectores juntos. @extend es más DRY que un mixin para estilos base compartidos, pero puede crear cadenas de selectores sorprendentes — úsalo con cuidado.

sass
.message {
  padding: 10px;
  border: 1px solid #ccc;
  border-radius: 4px;
}

// .success inherits all .message styles
.success {
  @extend .message;
  background: #d4edda;
  border-color: #c3e6cb;
}

.error {
  @extend .message;
  background: #f8d7da;
  border-color: #f5c6cb;
}

// Compiles to: .message, .success, .error { padding: 10px; ... }

Extender selectores complejos

@extend funciona con cualquier selector — clases, selectores de elemento, pseudo-clases, selectores compuestos. Extender .icon.large hereda las reglas que coinciden tanto con .icon como con .icon.large. Ten precaución al extender selectores complejos; el CSS generado puede cascadear de formas inesperadas e inflar la salida.

sass
// You can extend any selector, not just classes
a:hover {
  text-decoration: underline;
}

.link-card:hover {
  @extend a:hover;  // inherits :hover rule
  color: blue;
}

// Extending with compound selectors
.icon {
  display: inline-block;
}

.icon.large {
  font-size: 24px;
}

.icon-x { @extend .icon.large; }  // extends BOTH rules

Encadenar @extend

Cadenas de @extend: si B extiende a A y C extiende a B, C hereda de ambos. El CSS compilado agrupa los selectores en consecuencia. Las cadenas profundas pueden producir listas de selectores grandes y especificidad sorprendente. Para la mayoría de escenarios de reutilización, un mixin es más predecible que @extend encadenados.

sass
.base {
  display: block;
  padding: 8px;
}

.intermediate {
  @extend .base;
  background: #eee;
}

.final {
  @extend .intermediate;
  color: red;
}

// .final inherits from .intermediate which inherits from .base
// Compiles to: .base, .intermediate, .final { display: block; padding: 8px; }
//              .intermediate, .final { background: #eee; }
//              .final { color: red; }

@extend !optional

Añadir !optional a @extend se salta en silencio la extensión si el selector objetivo no existe, en lugar de lanzar un error. Es útil al extender selectores opcionales o cargados condicionalmente. Sin !optional, @extend falla la compilación si el objetivo falta.

sass
// !optional prevents errors if the selector doesn't exist
.fluent {
  @extend .nonexistent !optional;  // no error, just skipped
  color: blue;
}

// Without !optional, extending a missing selector throws:
// ".nonexistent failed to @extend"
// Use !optional when the extension target may or may not exist
// (e.g., optional theme classes from a third-party library)

@extend vs @include de mixin

@extend agrupa selectores (CSS menor cuando se reutiliza mucho) pero crea acoplamiento oculto. Los @include de mixins duplican declaraciones (CSS mayor) pero son autosuficientes y configurables. Prefiere mixins para código nuevo — son predecibles. Usa @extend principalmente para relaciones semánticas dentro de un archivo.

sass
// @extend - shares one rule, groups selectors
.btn { padding: 8px; }
.primary { @extend .btn; background: blue; }
// -> .btn, .primary { padding: 8px; }

// @mixin - duplicates declarations each use
@mixin btn { padding: 8px; }
.primary { @include btn; background: blue; }
// -> .primary { padding: 8px; background: blue; }

// When to use which:
// @extend: share base styles semantically (DRY selectors)
// @mixin: configurable repeated declarations (with args)
// Avoid @extend across module boundaries (can cause side effects)
09

Selectores marcador (%placeholder)

Fundamentos de %placeholder

Los selectores %placeholder (por ejemplo, %base-message) son reglas que solo existen para ser extendidas — nunca se generan en el CSS por sí solos. Esto evita el problema de la clase base sin usar que puede causar @extend sobre clases reales. Los placeholders son la forma más limpia de compartir estilos destinados únicamente a la herencia.

sass
// %placeholder selectors are NOT output in CSS
// They only appear when @extended
%base-message {
  padding: 10px;
  border-radius: 4px;
}

.success { @extend %base-message; background: green; }
.error { @extend %base-message; background: red; }

// Compiles to (notice %base-message is gone):
// .success, .error { padding: 10px; border-radius: 4px; }
// .success { background: green; }
// .error { background: red; }

Placeholder vs clase

Cuando haces @extend de una clase real, esa clase aparece en la salida incluso si nunca se usa en el HTML. Los placeholders lo resuelven: %base solo se emite donde se extiende. Usa clases reales cuando la base también se use directamente en el HTML; usa placeholders cuando la base sea puramente para heredar.

sass
// Class as extend target - the class IS output
.message { padding: 10px; }  // appears in CSS even if unused
.success { @extend .message; }

// Placeholder as extend target - NOT output
%message { padding: 10px; }  // never appears in CSS
.success { @extend %message; }

// Result is identical for .success, but the placeholder
// version doesn't pollute the CSS with an unused .message rule.
// Use placeholders for internal/inheritance-only base styles.

Placeholder con @extend

Un selector puede hacer @extend de varios placeholders, combinando conjuntos de estilos compartidos. Esto compone bloques de construcción reutilizables sin generar clases base sin usar. Los placeholders brillan para las primitivas de sistemas de diseño (tarjetas, botones, inputs) compartidas entre muchos componentes concretos.

sass
%card-base {
  background: white;
  border: 1px solid #eee;
  border-radius: 8px;
  padding: 16px;
}

%card-shadow {
  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
}

// Combine multiple placeholders
.featured-card {
  @extend %card-base;
  @extend %card-shadow;
  border-color: gold;
}

Compartir varios Placeholders

Cuando varios selectores hacen @extend del mismo placeholder, Sass los agrupa juntos en la salida, produciendo CSS compacto. Es la forma más eficiente de compartir estilos en Sass. Los placeholders habilitan una forma de herencia/composición sin hinchado de clases CSS en runtime.

sass
%button { padding: 8px 16px; border: none; cursor: pointer; }
%rounded { border-radius: 4px; }
%shadow { box-shadow: 0 1px 3px rgba(0,0,0,0.2); }

// Many components share the same placeholders
.btn-primary { @extend %button; @extend %rounded; @extend %shadow; background: blue; }
.btn-secondary { @extend %button; @extend %rounded; background: gray; }
.btn-ghost { @extend %button; background: transparent; }

// Sass deduplicates: %button's rule is shared across all three

Casos de uso de Placeholders

Los Placeholders son ideales para patrones de utilidad reutilizables: centrado, clearfixes, accesibilidad (visually-hidden) y primitivas de sistemas de diseño. Mantienen estos patrones en un solo lugar y evitan generarlos salvo que se usen. Es una forma limpia de compartir estilos de utilidad no configurables.

sass
// 1. Design system primitives
%abs-center {
  position: absolute;
  top: 50%; left: 50%;
  transform: translate(-50%, -50%);
}

// 2. Clearfix
%clearfix::after {
  content: "";
  display: table;
  clear: both;
}

// 3. Visually hidden (accessibility)
%visually-hidden {
  position: absolute;
  width: 1px; height: 1px;
  overflow: hidden;
  clip: rect(0 0 0 0);
}

.modal { @extend %abs-center; }
.container { @extend %clearfix; }
.sr-only { @extend %visually-hidden; }
10

Funciones (@function)

Definir funciones

@function define una computación reutilizable que @return un valor. Las funciones se llaman en valores de propiedad (a diferencia de los mixins que generan declaraciones). Usa funciones para cálculos como conversiones de unidades, matemática de colores y escalado responsivo. El valor de retorno puede ser cualquier tipo de dato de Sass.

sass
// @function defines a function that returns a value
@function rem($px) {
  $base: 16px;
  @return ($px / $base) * 1rem;
}

// Use it like a CSS function
body { font-size: rem(16); }      // 1rem
h1 { font-size: rem(32); }        // 2rem
.small { font-size: rem(12); }    // 0.75rem

// Functions return values; mixins output CSS rules

Argumentos y valores por defecto de funciones

Las funciones soportan argumentos por defecto, argumentos con nombre y argumentos variádicos (...), igual que los mixins. Los valores por defecto hacen cómodo llamar a las funciones. Los argumentos con nombre mejoran la legibilidad en funciones con muchos parámetros opcionales. Los argumentos variádicos dejan que las funciones acepten cualquier número de valores.

sass
@function spacing($factor: 1, $base: 8px) {
  @return $base * $factor;
}

// Use defaults
.card { padding: spacing(); }       // 8px
.card-lg { padding: spacing(2); }   // 16px

// Override by name
.section { padding: spacing($base: 10px); }  // 10px
.hero { padding: spacing(3, 10px); }         // 30px

// Variable arguments work too
@function max-of($nums...) {
  @return ...; // implement with reduce
}

Visión general de funciones integradas

Sass trae ricas funciones integradas para colores, matemática, cadenas, listas y mapas. El Sass moderno organiza estas en módulos (sass:math, sass:color, sass:string, sass:list, sass:map, sass:meta) cargados vía @use. Los nombres globales de funciones siguen funcionando pero están obsoletos en favor de las funciones de módulo con espacio de nombres.

sass
// Color functions
lighten(#000, 50%)       // gray
rgba(#fff, 0.5)          // semi-transparent white
mix(red, blue)           // purple

// Math functions
percentage(0.5)          // 50%
round(3.6)               // 4
min(10px, 20px)          // 10px

// String functions
to-upper-case("abc")     // "ABC"
str-length("hello")      // 5

// List/Map functions
length(1 2 3)            // 3
map-get(("a": 1), "a")   // 1

// Modern Sass uses modules: @use 'sass:math'; math.div(10, 2)

Ejemplos prácticos de funciones

Las funciones sobresalen encapsulando cálculos reutilizables: conversiones de unidades (px/em/rem), gestión de z-index vía un mapa y búsquedas de tokens de diseño. Centralizarlas en funciones garantiza consistencia y hace que los cambios (como actualizar el tamaño de fuente base) se propaguen automáticamente por todas partes.

sass
// Convert px to em relative to a context
@function em($px, $context: 16px) {
  @return ($px / $context) * 1em;
}

// Generate a z-index from a scale map
$z-indexes: (
  "base": 0,
  "dropdown": 100,
  "modal": 200,
  "toast": 300,
);
@function z($name) {
  @return map-get($z-indexes, $name);
}

// Usage
body { font-size: em(18px); }              // 1.125em
.modal { z-index: z("modal"); }            // 200
.toast { z-index: z("toast"); }            // 300

Funciones recursivas

Las funciones de Sass soportan recursión vía condicionales @if y llamadas a sí mismas. Esto habilita factorial, Fibonacci y otras secuencias computadas. Sin embargo, la recursión de Sass no tiene optimización de llamada final y es lenta — evita la recursión profunda en hojas de estilo reales. Prefiere los bucles (@for) para la computación iterativa.

sass
// Functions can call themselves (recursion)
@function factorial($n) {
  @if $n <= 1 {
    @return 1;
  } @else {
    @return $n * factorial($n - 1);
  }
}

.power { width: factorial(5) * 1px; }  // 120px

// Fibonacci
@function fib($n) {
  @if $n < 2 { @return $n; }
  @return fib($n - 1) + fib($n - 2);
}

// Note: deep recursion is slow in Sass - use sparingly
11

Directivas de control

@if / @else if / @else

@if/@else if/@else generan estilos condicionalmente según comparaciones. Sass usa == y != para la igualdad (no ===). Los operadores booleanos son 'and', 'or', 'not' (no &&, ||, !). Útil para cambiar de tema, feature flags y lógica responsiva dentro de mixins y funciones.

sass
@mixin theme($mode) {
  @if $mode == dark {
    background: #222;
    color: #eee;
  } @else if $mode == light {
    background: #fff;
    color: #333;
  } @else {
    background: gray;
    color: black;
  }
}

.dark { @include theme(dark); }
.light { @include theme(light); }
.auto { @include theme(auto); }

// Comparison operators: ==, !=, <, >, <=, >=, and, or, not

Bucle @for

@for itera una variable desde un valor inicial a uno final. 'through' es inclusivo (incluye el final); 'to' es exclusivo (excluye el final). Común para generar columnas de cuadrícula, animaciones escalonadas y clases de utilidad numeradas. Usa la interpolación #{} para insertar el contador en los selectores.

sass
// @for $var from <start> through <end>  (inclusive)
@for $i from 1 through 3 {
  .col-#{$i} { width: 100% / $i; }
}
// .col-1 { width: 100%; }  .col-2 { width: 50%; }  .col-3 { width: 33.333%; }

// 'to' is EXCLUSIVE (excludes the end)
@for $i from 1 to 3 {
  .item-#{$i} { order: $i; }
}
// .item-1, .item-2  (no .item-3)

// Use 'through' for inclusive, 'to' for exclusive ranges

Bucle @each (listas)

@each itera sobre una lista, vinculando cada ítem a una variable. Es ideal para generar variantes de tema, clases de iconos y clases de utilidad desde una lista de configuración. Las listas de listas pueden desempaquetarse en varias variables por iteración para datos emparejados como tuplas (nombre, color).

sass
// Iterate over a list
$icons: user, home, settings, search;

@each $name in $icons {
  .icon-#{$name} {
    background-image: url("/icons/#{$name}.svg");
  }
}
// .icon-user, .icon-home, .icon-settings, .icon-search

// Multiple values (unpacking)
@each $name, $color in (success green), (error red) {
  .alert-#{$name} { color: $color; }
}

@each con mapas

@each sobre un mapa vincula tanto la clave como el valor en cada iteración. Es la forma estándar de generar utilidades responsivas, variantes de tema y clases conscientes de breakpoints desde un mapa de configuración. El orden de iteración de los mapas sigue el orden de inserción en el Sass moderno.

sass
$breakpoints: (
  "sm": 576px,
  "md": 768px,
  "lg": 1024px,
  "xl": 1280px,
);

// Iterate key-value pairs of a map
@each $name, $size in $breakpoints {
  .container-#{$name} {
    max-width: $size;
    margin: 0 auto;
  }
}
// .container-sm, .container-md, .container-lg, .container-xl

// Also destructuring lists of maps for richer config
$buttons: (("primary", blue), ("danger", red));

Bucle @while

@while itera hasta que su condición se vuelve falsa; debes actualizar el contador manualmente. Úsalo para progresiones no lineales (por ejemplo, doblar en cada paso) donde @for no encaja. Asegúrate siempre de que el bucle termine — olvidar incrementar causa un bucle infinito que cuelga la compilación.

sass
// @while repeats while a condition is true
$i: 1;
@while $i <= 5 {
  .mt-#{$i} { margin-top: $i * 4px; }
  $i: $i + 1;
}
// .mt-1 { margin-top: 4px; } ... .mt-5 { margin-top: 20px; }

// Unlike @for, you control the increment
// WARNING: always increment/decrement to avoid infinite loops!
$i: 6;
@while $i > 0 {
  .delay-#{$i} { transition-delay: $i * 100ms; }
  $i: $i - 1;
}
12

Listas y mapas

Listas

Las listas son el tipo array de Sass, separadas por espacios o comas. Los índices empiezan en 1 (a diferencia de la mayoría de lenguajes) — nth($lista, 1) devuelve el primer ítem. Los índices negativos cuentan desde el final. Un valor único se trata como lista de un elemento. Las listas pueden anidarse.

sass
// Lists are ordered collections (like arrays)
// Separated by spaces or commas
$sizes: 10px 20px 30px;          // space-separated
$colors: red, green, blue;       // comma-separated
$mixed: (1px 2px) (3px 4px);     // nested lists

// Single value is also a list of length 1
$one: 5px;

// Indexes are 1-based!
$list: a b c;
nth($list, 1);   // a  (NOT 0-indexed)
nth($list, -1);  // c  (negative = from end)
length($list);   // 3

Funciones de lista

Funciones de lista: length(), nth(), index() para acceso; append(), join(), insert-nth() devuelven listas nuevas (las listas son inmutables). zip() empareja elementos de varias listas. separator() devuelve el separador de la lista. Usa @each para iterar. La API moderna vive en el módulo sass:list.

sass
$list: a b c;

// Access
length($list);          // 3
nth($list, 2);          // b
index($list, b);        // 2 (position of b, or null)

// Modify (return NEW list - lists are immutable)
append($list, d);       // a b c d
join(a b, c d);         // a b c d
join((a b), (c d), comma); // a, b, c, d

// Insert
insert-nth($list, 2, x);   // a x b c

// Misc
zip(1 2, a b);          // (1 a) (2 b) - pairs elements

Mapas

Los mapas son colecciones clave-valor (arrays asociativos). Las claves deben ser únicas; los valores pueden ser cualquier tipo de Sass incluidos mapas anidados. Usa map-get() para leer valores y map-has-key() para comprobar la existencia. Los mapas son la forma estándar de modelar tokens de diseño, breakpoints y paletas de tema.

sass
// Maps are key-value pairs (like objects/dictionaries)
$colors: (
  "primary": #3498db,
  "secondary": #2ecc71,
  "danger": #e74c3c,
  "warning": #f39c12,
);

// Access values
map-get($colors, "primary");      // #3498db

// Check existence
map-has-key($colors, "success");  // false

// Keys must be unique; values can be any type (even nested maps)
$breakpoints: (
  "mobile": (max: 767px),
  "desktop": (min: 768px),
);

Funciones de mapa

Funciones de mapa: map-get() lee un valor, map-keys()/map-values() devuelven listas, map-merge() combina mapas (genial para extender temas), map-remove() elimina claves. Los mapas son inmutables — las funciones devuelven mapas nuevos. La API moderna tiene espacio de nombres bajo el módulo sass:map.

sass
$colors: ("a": 1, "b": 2);

// Access
map-get($colors, "a");          // 1
map-has-key($colors, "c");      // false

// Keys & values as lists
map-keys($colors);              // ("a", "b")
map-values($colors);            // (1, 2)

// Merge (combines two maps; second wins on conflicts)
$base: ("x": 1, "y": 2);
$override: ("y": 99, "z": 3);
map-merge($base, $override);    // ("x": 1, "y": 99, "z": 3)

// Remove keys
map-remove($colors, "a");       // ("b": 2)

Iterar y desestructurar

@each desestructura mapas (clave, valor) y listas de listas, vinculando varias variables por iteración. Esto convierte datos de configuración en CSS generado — un patrón potente para sistemas de diseño. Combinado con mapas, puedes impulsar frameworks enteros de clases de utilidad desde un único mapa de configuración.

sass
$grid: (
  "sm": 576px,
  "md": 768px,
  "lg": 1024px,
);

// @each destructures map into key+value
@each $name, $size in $grid {
  @media (min-width: $size) {
    .container-#{$name} { max-width: $size; }
  }
}

// Nested destructuring with lists of lists
$config: (("primary", blue, white), ("danger", red, white));
@each $name, $bg, $fg in $config {
  .btn-#{$name} { background: $bg; color: $fg; }
}
13

Funciones de color

lighten / darken

lighten() y darken() desplazan la luminosidad de un color un porcentaje. Están obsoletos en favor de color.adjust() de sass:color, que es explícito sobre qué canal cambia. El lighten/darken puro puede producir resultados sorprendentes en colores ya extremos — prefiere los ajustes basados en HSL.

sass
$base: #3498db;

.light { background: lighten($base, 20%); }   // lighter blue
.dark  { background: darken($base, 20%); }    // darker blue

// Note: lighten/darken are deprecated in modern Sass
// Prefer sass:color adjust() for clarity:
@use 'sass:color';
.adjusted {
  // same effect, explicit
  background: color.adjust($base, $lightness: 20%);
  border-color: color.adjust($base, $lightness: -20%);
}

rgba / rgb / transparencia

rgba($color, $alpha) añade transparencia a cualquier color — la función de color más común. rgba() también acepta 4 argumentos numéricos. El módulo moderno sass:color ofrece color.adjust($alpha: ...) para control explícito del alfa. La sintaxis de espacio de CSS Color 4 (rgb(r g b / a%)) también es válida en el Sass moderno.

sass
$brand: #3498db;

// Add alpha to any color
.semi { background: rgba($brand, 0.5); }    // #3498db at 50%
.fade { background: rgba($brand, 0.1); }    // very transparent

// rgba() also accepts 4 numeric args
.box { background: rgba(52, 152, 219, 0.8); }

// Modern alternative: color.adjust for alpha
@use 'sass:color';
.glass { background: color.adjust($brand, $alpha: -0.5); }

// rgb() and rgba() with space syntax (CSS Color 4)
.modern { background: rgb(52 152 219 / 80%); }

mix / mezclar colores

mix($color1, $color2, $weight) mezcla dos colores — $weight es el porcentaje de $color1 (50% por defecto). Usa mix($color, white) para tintes y mix($color, black) para sombras, que suelen verse más naturales que lighten()/darken(). color.mix es el equivalente moderno con espacio de nombres.

sass
// mix() blends two colors by a weight (default 50%)
$mix: mix(red, blue);          // purple (50/50)
$mix30: mix(red, blue, 30%);   // 30% red, 70% blue (bluer)

// Useful for generating tints and shades
$base: #3498db;
.tint  { background: mix($base, white, 20%); }  // 20% blue, 80% white
.shade { background: mix($base, black, 20%); }  // 20% blue, 80% black

// sass:color module
@use 'sass:color';
.blended { background: color.mix(red, blue, 50%); }

adjust-color / scale-color / change-color

Tres herramientas de color precisas: color.adjust() añade deltas a los canales, color.scale() escala los canales hacia su mín/máx por un porcentaje (más seguro — nunca se pasa), color.change() fija los canales a valores absolutos. Los globales adjust-color/scale-color/change-color son alias obsoletos.

sass
@use 'sass:color';
$base: #3498db;

// adjust: ADDS to channels (absolute change)
.a { background: color.adjust($base, $red: 30, $alpha: -0.3); }

// scale: SCALES channels by % (relative change, stays in range)
.s { background: color.scale($base, $lightness: 50%); }

// change: SETS channels to exact values (replaces)
.c { background: color.change($base, $lightness: 50%, $hue: 0); }

// adjust moves by a delta, scale shrinks/grows toward min/max,
// change overwrites with a fixed value.

hue / saturation / complement

color.hue/saturation/lightness leen los canales HSL — útil para lógica condicional. color.complement() devuelve el color de tono opuesto (genial para acentos), color.grayscale() desatura, color.invert() invierte el RGB. color.hsl() construye colores a partir de valores HSL. Estos habilitan la generación programática de paletas.

sass
@use 'sass:color';
$c: #3498db;

// Read HSL channels
color.hue($c);           // 204deg
color.saturation($c);    // 70%
color.lightness($c);     // 53%

// Derive new colors
.complement { background: color.complement($c); }     // opposite hue
.grayscale  { background: color.grayscale($c); }       // desaturated
.invert     { background: color.invert($c); }          // RGB inverse

// Build from HSL
.from-hsl { background: color.hsl(204, 70%, 53%); }
14

Operaciones matemáticas

Aritmética básica

Sass soporta +, -, *, /, % sobre números y maneja unidades. Como CSS usa / para separar (font: 16px/1.5), la / plana como división está obsoleta — usa math.div() de sass:math o paréntesis. Las unidades deben ser compatibles para + y -. Multiplicar dos valores con unidades suele ser un error.

sass
$base: 16px;

// Sass does math on numbers (with unit handling)
width: 100% - 20px;   // ERROR - incompatible units
width: 100px + 20px;  // 120px
width: 100px * 2;     // 200px
width: 100px / 2;     // 50px (use math.div in modern Sass)
width: (100px / 2);   // 50px (parenthesized = math, not CSS)

// Modern division (the / operator is deprecated for division)
@use 'sass:math';
width: math.div(100px, 2);   // 50px
width: math.div(100, 3);     // 33.333...

Conversión de unidades

Sass convierte automáticamente entre unidades físicas (px, in, cm, mm, pt, pc) pero NO entre px/em/rem/%. Debes escribir tú las funciones de conversión. El patrón común es una función rem($px) que divide entre el tamaño de fuente base. Centraliza la conversión de unidades para mantener la escala de espaciado de un proyecto consistente.

sass
$base-font: 16px;

// Convert px to rem
@function rem($px) {
  @return math.div($px, $base-font) * 1rem;
}
h1 { font-size: rem(32px); }   // 2rem

// Convert px to em (relative to context)
@function em($px, $context: 16px) {
  @return math.div($px, $context) * 1em;
}

// Sass does NOT auto-convert between px/em/rem/%
// You must compute the ratio yourself.
// 1in = 96px, 1cm = 37.8px, 1pt = 1.33px (these DO auto-convert)

Funciones matemáticas

sass:math proporciona round(), ceil(), floor(), abs(), min(), max(), percentage() y (más nuevo) funciones trigonométricas y de raíz más constantes como math.$pi. min()/max() aquí son funciones de Sass (distintas de las min()/max() de CSS — usa las de CSS sin comillas para un min/max real de CSS). Importa math siempre explícitamente.

sass
@use 'sass:math';

// Rounding
math.round(3.6);     // 4
math.ceil(3.1);      // 4
math.floor(3.9);     // 3

// Absolute & bounds
math.abs(-5);        // 5
math.min(10px, 20px);  // 10px
math.max(10px, 20px);  // 20px

// Percentage conversion
math.percentage(0.5);  // 50%  (math.percentage, or global percentage)

// Trig & constants (Sass 1.65+)
math.sin(math.$pi);    // ~0
math.cos(0);           // 1
math.sqrt(16);         // 4

Módulo y división

math.div() es la función de división moderna — el operador / está reservado para separadores de lista de CSS (como font: 16px/1.5). math.mod() devuelve el resto. math.compatible() comprueba si dos números pueden sumarse. Usa siempre @use 'sass:math' para la aritmética; la / global para dividir está obsoleta y se eliminará.

sass
@use 'sass:math';

// Modulo (remainder)
math.unit(10px);     // px
math.compatible(10px, 5px);  // true (can add)
math.is-unitless(5);          // true

// Division MUST use math.div (the / operator is for lists/CSS)
$result: math.div(100, 3);    // 33.333...

// Modulo
$rem: math.mod(10, 3);        // 1

// Generating a grid with modulo
@for $i from 1 through 12 {
  .col-#{$i} { width: math.div($i, 12) * 100%; }
}

Operadores de comparación y lógica

Sass usa == y != para la igualdad. Los operadores booleanos son las palabras clave 'and', 'or', 'not' — no al estilo C &&/||/!. Usa paréntesis para aclarar la precedencia. Estos operadores impulsan los condicionales @if dentro de mixins, funciones y directivas de control. Valores verdaderos: cualquier valor salvo false y null.

sass
// Comparison: ==, !=, <, >, <=, >=
@if $width > 100px { /* ... */ }
@if $count == 3 { /* ... */ }
@if $mode != "dark" { /* ... */ }

// Boolean logic: and, or, not (NOT &&, ||, !)
$enabled: true;
$mobile: false;

@if $enabled and not $mobile {
  .desktop-only { display: block; }
}

@if $mode == "dark" or $mode == "night" {
  background: black;
}

// Use parentheses to group
@if ($a > 1 and $b < 10) or $c == 5 { /* ... */ }
15

Funciones de cadena

quote / unquote

quote() envuelve una cadena entre comillas; unquote() las quita. Sass distingue cadenas entre comillas (para content, nombres de fuentes) de cadenas sin comillas (para identificadores, nombres de clase). Muchas funciones aceptan ambas pero la distinción importa para el formato de salida y la generación de selectores.

sass
// quote() forces quotes around a string
$unquoted: Helvetica;
$quoted: quote($unquoted);   // "Helvetica"

// unquote() removes quotes
$quoted: "Arial";
$plain: unquote($quoted);    // Arial

// Useful when a string needs to be quoted for output
.url { background: url(quote("/img/x.png")); }
// url("/img/x.png")

// Quoted vs unquoted matters for some CSS values
// Class names and property names are usually unquoted

Funciones de mayúsculas

to-upper-case() y to-lower-case() convierten las mayúsculas de las cadenas — útil para generar nombres de clase, valores de content o normalizar la entrada consistentemente. Combinadas con la interpolación #{}, te dejan construir selectores y content dinámicos desde variables. Las versiones modernas con espacio de nombres viven en sass:string.

sass
// Change string case
$upper: to-upper-case("hello");   // "HELLO"
$lower: to-lower-case("WORLD");   // "world"

// Practical: generate uppercase class names
$states: success, warning, error;
@each $s in $states {
  .badge-#{to-upper-case($s)} {
    content: "#{to-upper-case($s)}";
  }
}

// .badge-SUCCESS { content: "SUCCESS"; } etc.

str-length / str-slice / str-index

Funciones de sass:string: string.length() devuelve el conteo de caracteres, string.slice($str, $inicio, $fin) devuelve una subcadena (base 1, negativos desde el final), string.index() halla la posición de una subcadena (base 1, null si falta). Sass no tiene split integrado — impleméntalo con un bucle usando index() y slice().

sass
@use 'sass:string';

$str: "Hello, World";

// Length (character count)
string.length($str);    // 12

// Slice (substring) - 1-based, supports negatives
string.slice($str, 1, 5);   // "Hello"
string.slice($str, 8);      // "World"
string.slice($str, -5);     // "World" (from end)

// Index of substring (1-based, or null if not found)
string.index($str, "World");  // 8
string.index($str, "xyz");    // null

// Split is not built-in - use a custom function with index+slice

str-insert / str-replace

string.insert($cadena, $inserción, $posición) inserta una subcadena en una posición base 1 (usa un número grande para añadir al final). string.replace($cadena, $a_reemplazar, $reemplazo, $limite?) intercambia subcadenas (todas por defecto, o conteo limitado). Son esenciales para la generación programática de nombres de clase y contenido.

sass
@use 'sass:string';

// str-insert: insert at position (1-based)
string.insert("Hello", "!", 6);    // "Hello!"
string.insert("World", "Hello ", 1);  // "Hello World"

// Modern Sass (1.55+) has string.replace
string.replace("a-b-c", "-", "_");        // "a_b_c" (replace all)
string.replace("a-b-c", "-", "_", 1);     // "a_b-c" (limit 1)

// Build dynamic strings
$prefix: "icon";
$name: string.insert($prefix, "-user", 100);  // "icon-user"

Patrones de interpolación de cadenas

La interpolación #{} convierte cualquier valor de Sass (números, listas, colores, booleanos) a su representación como cadena y lo incrusta. Úsala para construir selectores dinámicos, nombres de propiedad, valores de content y URLs. La interpolación es el puente entre los valores de Sass y la salida de texto CSS donde las variables planas no están permitidas.

sass
$prefix: "btn";
$modifier: "primary";

// #{} converts any value to a string and embeds it
.#{$prefix}-#{$modifier} { /* ... */ }   // .btn-primary

// Interpolating numbers, lists, booleans
$count: 3;
.item-#{$count} { order: $count; }       // .item-3 { order: 3; }

// Interpolating in @include and @media
@mixin respond-to($bp) {
  @media (max-width: $bp) { @content; }
}

// Interpolating function calls
.content::after {
  content: "#{to-upper-case('hello')}";
}
16

@at-root

@at-root básico

@at-root sale del contexto de anidamiento actual, generando la regla anidada en el nivel superior de la hoja de estilo. Sin @at-root, .child dentro de .parent compila a .parent .child (descendiente). @at-root lo deja en solo .child. Esto mantiene las reglas relacionadas agrupadas en el código mientras genera selectores planos.

sass
.parent {
  color: blue;

  // @at-root jumps out of the nesting
  @at-root .child {
    color: red;
  }
}

// Compiles to (note: .child is NOT nested under .parent):
// .parent { color: blue; }
// .child { color: red; }   <- top-level, not .parent .child

// Useful for defining sibling/related rules inside a block
// without creating a descendant selector.

@at-root con selectores

Combina @at-root con & para conservar selectivamente partes del selector padre. @at-root .wrapper & genera .wrapper .componente (antepone un contexto) en lugar de .componente .wrapper. Es la forma limpia de escribir anulaciones de tema/contexto manteniéndolas colocalizadas con el código del componente.

sass
.component {
  width: 100px;

  // Combine @at-root with & to keep part of the parent
  @at-root .wrapper & {
    background: yellow;
  }
  // -> .wrapper .component { background: yellow; }

  // Useful for context overrides without deep nesting
  @at-root .dark-theme & {
    color: white;
  }
  // -> .dark-theme .component { color: white; }
}

@at-root para BEM

@at-root ayuda a generar clases modificadoras BEM (.block--active) como hermanas en lugar de descendientes. Sin @at-root, anidar .block--active dentro de .block crearía .block .block--active (mal — significa un bloque activo dentro de un bloque). @at-root emite el modificador en el nivel superior, que es la salida BEM correcta.

sass
.block {
  // State classes as siblings, not descendants
  @at-root {
    .block--active { border-color: blue; }
    .block--disabled { opacity: 0.5; }
  }

  // Or inline form
  @at-root .block--hidden { display: none; }
}

// Compiles to top-level siblings:
// .block { ... }
// .block--active { border-color: blue; }
// .block--disabled { opacity: 0.5; }
// .block--hidden { display: none; }

// Avoids accidentally generating .block .block--active

@at-root con media queries

@at-root (with: media) eleva las reglas fuera del anidamiento de selectores pero las mantiene dentro de un bloque @media. @at-root (without: media) hace lo contrario. Las cláusulas with/without controlan qué contextos (rule, media, supports) se conservan. Es avanzado pero esencial para construir librerías robustas de mixins responsivos.

sass
.component {
  width: 100%;

  // @at-root lifts media queries to the top level
  @at-root (with: media) {
    @media (min-width: 768px) {
      & { width: 50%; }
    }
  }
  // -> @media (min-width: 768px) { .component { width: 50%; } }
}

// Default @at-root (without: rule) lifts OUT of everything
// @at-root (with: media) keeps the @media context but exits rules
// Useful in complex nested mixins to control scope precisely

@at-root without (with)

Las cláusulas (without: ...) y (with: ...) controlan de qué contextos de anidamiento escapa @at-root. Contextos comunes: 'rule' (selectores), 'media' (@media), 'supports' (@supports) y 'all'. (without: rule) conserva @media pero sale de los selectores. Este control preciso del alcance habilita patrones avanzados de mixins y librerías.

sass
.parent {
  @media (min-width: 768px) {
    .child {
      width: 50%;

      // Exit only the rule, keep the @media
      @at-root (without: rule) {
        .sibling { width: 25%; }
      }
      // -> @media (min-width: 768px) { .sibling { width: 25%; } }

      // Exit everything (default)
      @at-root .top { color: red; }
      // -> .top { color: red; }  (no @media, no parent)
    }
  }
}
17

@content

Fundamentos de @content

@content dentro de un @mixin es un marcador para un bloque de estilos pasado vía @include { ... }. El bloque incluido reemplaza a @content en el sitio de llamada. Esto deja que los mixins envuelvan estilos personalizados — esencial para media queries, keyframes y cualquier patrón 'envolvente' donde el contenido interior varía por uso.

sass
// @content marks where the included block is injected
@mixin highlighted {
  background: yellow;
  font-weight: bold;

  @content;  // the block passed to @include goes here
}

.title {
  @include highlighted {
    color: red;       // injected where @content was
    font-size: 20px;
  }
}

// Compiles to:
// .title { background: yellow; font-weight: bold; color: red; font-size: 20px; }

@content con argumentos

@content ($args) pasa valores del mixin al bloque incluido, que los recibe con 'using ($vars)'. Esto permite que los mixins aporten contexto (como el nombre del breakpoint actual) al bloque de quien llama. Potente para construir mixins de iteración/envoltorio que necesiten exponer el estado del bucle al consumidor.

sass
// Pass values back to the included block (Sass 3.3+)
@mixin each-breakpoint {
  $breakpoints: (sm: 576px, md: 768px, lg: 1024px);

  @each $name, $size in $breakpoints {
    @media (min-width: $size) {
      @content ($name, $size);
    }
  }
}

// Receive via #{...} - actually use the block like a function
@include each-breakpoint using ($name, $size) {
  .container-#{$name} { max-width: $size; }
}

@content para media queries

El caso de uso más común de @content: un mixin respond-to que envuelve los estilos en la @media query correcta. Quienes llaman pasan un bloque de estilos responsivos; el mixin lo coloca dentro de la media query correcta. Esto hace el código responsivo legible y centraliza las definiciones de breakpoints en un solo lugar.

sass
// Classic responsive mixin pattern
@mixin respond-to($breakpoint) {
  @if $breakpoint == phone {
    @media (max-width: 600px) { @content; }
  } @else if $breakpoint == tablet {
    @media (min-width: 601px) and (max-width: 900px) { @content; }
  } @else if $breakpoint == desktop {
    @media (min-width: 901px) { @content; }
  }
}

.sidebar {
  width: 300px;

  @include respond-to(phone) {
    width: 100%;
    float: none;
  }

  @include respond-to(desktop) {
    width: 350px;
  }
}

Patrones de @content

@content impulsa muchos patrones reutilizables: envoltorios @supports, generadores de keyframes y generadores de clases modificadoras para BEM. Cada uno deja que quien llame suministre el cuerpo mientras el mixin maneja el boilerplate (selector, at-rule, espacio de nombres). Así es como las librerías de Sass bien estructuradas aportan APIs flexibles y componibles.

sass
// Wrapper for @supports (feature queries)
@mixin supports-flex { @supports (display: flex) { @content; } }

// Keyframes generator
@mixin keyframes($name) {
  @keyframes #{$name} { @content; }
}

@include keyframes(fade-in) {
  from { opacity: 0; }
  to   { opacity: 1; }
}

// Modifier generator
@mixin modifier($name) {
  &--#{$name} { @content; }
}
.button {
  @include modifier(primary) { background: blue; }
  @include modifier(danger) { background: red; }
}

Casos de uso de @content

@content habilita envoltorios de contexto (media/supports/keyframes), ganchos de extensión (estilos base + adiciones personalizadas) y salida condicional. Es el equivalente en Sass de las funciones de orden superior: el mixin es el framework y @content es el callback. Domina @content para construir utilidades de estilo flexibles y reutilizables.

sass
// 1. Context wrappers (@media, @supports, @keyframes)
@mixin mobile { @media (max-width: 767px) { @content; } }

// 2. Reset/normalize hooks
@mixin base-styles {
  box-sizing: border-box;
  margin: 0;
  @content;  // allow components to add more
}

// 3. Debugging/profiling wrappers
@mixin timed {
  $start: systime();
  @content;
  // log elapsed...
}

// 4. Conditional output
@mixin if-dark($is-dark) {
  @if $is-dark { @content; }
}
18

Sistema de módulos (@use / @forward)

@use vs @import

@use reemplaza a @import con un sistema de módulos propio: el namespacing evita colisiones, los módulos se cargan una vez (cacheados), los miembros con prefijo - o _ son privados (no expuestos) y 'with' configura los valores por defecto explícitamente. Esto arregla la totalidad de los problemas estructurales de @import. Usa @use para cualquier código Sass nuevo.

sass
// @use is the modern module system (replaces @import)
// Key improvements:
// 1. Members are namespaced (no global pollution)
// 2. Modules load ONCE (cached, no duplicate execution)
// 3. Privacy: members starting with - or _ are private
// 4. Explicit configuration with 'with'

// _shapes.scss
$radius: 4px;
@mixin rounded { border-radius: $radius; }
@mixin -internal { /* private */ }   // not exposed

// app.scss
@use 'shapes';          // namespace: shapes
@use 'shapes' as s;     // namespace: s
@use 'shapes' as *;     // no namespace (global)

.card { @include shapes.rounded; }   // via namespace

@forward

@forward reexporta miembros de otro módulo sin hacerlos tuyos — perfecto para archivos barrel/índice que agregan el contenido de una carpeta. @forward soporta 'hide' para excluir miembros y 'as prefijo-*' para renombrar al reexportar. Esto te permite fabricar una API pública limpia para una librería o carpeta.

sass
// @forward re-exports members from another module
// Useful for building index/barrel files

// sass/abstracts/_index.scss
@forward 'variables';    // exposes _variables.scss members
@forward 'functions';
@forward 'mixins';

// Now consumers can import the whole folder at once:
// app.scss
@use 'abstracts' as *;   // gets variables + functions + mixins

// @forward can rename or hide members
@forward 'buttons' hide button-styles;
@forward 'forms' as form-*;  // prefix all members with 'form-'

Miembros privados (prefijo -)

Los miembros cuyos nombres empiezan con - o _ son privados — utilizables dentro de su propio archivo pero NO expuestos vía @use o @forward. Esto deja que los módulos oculten detalles de implementación y expongan solo su API pública. Usa el prefijo - para helpers internos, manteniendo la interfaz de tu módulo limpia y estable.

sass
// _math-helpers.scss
@function -internal-double($n) {
  @return $n * 2;
}

@function public-times-two($n) {
  @return -internal-double($n);  // OK - same file
}

// Public function usable via @use
@function scale($n, $factor: 2) {
  @return -internal-double($n) * $factor;
}

// app.scss
@use 'math-helpers';
.val { width: math-helpers.scale(10); }      // OK
// .val { width: math-helpers.-internal-double(10); }  // ERROR - private

Configurar módulos (with)

'with ($var: valor, ...)' configura las variables !default de un módulo al cargarlo. Es el reemplazo moderno y acotado del patrón de sobrescritura con variables globales de @import. La configuración aplica solo al primer @use de un módulo — las sentencias @use siguientes reutilizan el módulo configurado. Así se tematizan las librerías.

sass
// _theme.scss
$primary: blue !default;
$radius: 4px !default;

@mixin button {
  background: $primary;
  border-radius: $radius;
}

// app.scss - configure on @use
@use 'theme' with (
  $primary: #ff6600,
  $radius: 8px,
);

.btn { @include theme.button; }
// background: #ff6600; border-radius: 8px;

// 'with' only works for variables marked !default in the module.
// Configuration must happen at the FIRST @use of that module.

Buenas prácticas de módulos

Buenas prácticas de módulos: usa @use (no @import), prefiere espacios de nombres cortos y explícitos, agrega carpetas con @forward en _index.scss, marca los helpers internos como privados con -, configura las librerías vía 'with' sobre variables !default y usa los módulos integrados sass:* para las funciones estándar. Esto mantiene el código modular y mantenible.

sass
// 1. Always use @use, never @import (deprecated)
// 2. Use explicit namespaces for clarity
@use 'sass:math';      // built-in module namespace: math
@use 'variables' as v; // short custom namespace

// 3. Use @forward in _index.scss barrel files
// components/_index.scss
@forward 'buttons';
@forward 'cards';

// 4. Keep members private with - prefix
@function -helper() { @return ...; }

// 5. Configure libraries with 'with', set !default on library vars
$brand: blue !default;

// 6. Use built-in modules: sass:math, sass:color, sass:string,
//    sass:list, sass:map, sass:meta, sass:selector, sass:css
19

Depuración (@debug / @warn / @error)

@debug

@debug imprime un valor en la terminal durante la compilación, con el archivo fuente y el número de línea. No detiene la build. Usa @debug para inspeccionar variables, trazar el flujo de ejecución y verificar computaciones durante el desarrollo. Quita o comenta las sentencias @debug antes de publicar. La salida va a stderr, no al CSS.

sass
// @debug prints a message to the console during compilation
$base: 16px;
$size: 24px;

@debug "Calculating size...";
@debug "base is #{$base}, size is #{$size}";
@debug "ratio: " #{math.div($size, $base)};

// Console output during compile:
// _file.scss:5 DEBUG: Calculating size...
// _file.scss:6 DEBUG: base is 16px, size is 24px

// @debug does NOT stop compilation - just logs
// Use it to trace values while developing

@warn

@warn imprime una advertencia no fatal en la consola durante la compilación — la build continúa. Úsalo para avisos de deprecación, comportamiento de respaldo y alertas de mal uso potencial en librerías. @warn incluye un stack trace por defecto para que los usuarios localicen la fuente de la advertencia. Como @debug, no aparece en la salida CSS.

sass
// @warn prints a warning to the console (does NOT stop compilation)
@mixin deprecated-mixin {
  @warn "deprecated-mixin is deprecated; use new-mixin instead.";
  /* ... styles ... */
}

// Useful for deprecation notices, potential issues
@warn "Variable $primary is not set, falling back to default.";

// With stack trace for locating the call site
@warn "Invalid value: #{$value}" {
  // optional stack trace via meta.module-functions
}

// @warn is non-fatal - compilation continues.

@error

@error lanza un error fatal, deteniendo la compilación de inmediato. Úsalo para validar las entradas de funciones y mixins — atrapar el mal uso temprano con un mensaje claro es mejor que generar CSS roto. @error incluye un stack trace. Reserva @error para estados genuinamente inválidos; usa @warn para problemas recuperables y @debug para inspección.

sass
// @error stops compilation with an error message
@function divide($a, $b) {
  @if $b == 0 {
    @error "Cannot divide by zero: divide(#{$a}, #{$b})";
  }
  @return math.div($a, $b);
}

// In a mixin validating arguments
@mixin set-font-size($size) {
  @if not $size {
    @error "set-font-size requires a non-null $size, got #{$size}";
  }
  font-size: $size;
}

// @error halts the build - use for invalid inputs
// that would produce broken CSS.

Funciones del módulo meta

sass:meta aporta introspección: type-of() devuelve el tipo de un valor, inspect() produce una cadena legible de cualquier valor (genial para depurar), y las funciones *-exists comprueban variables/mixins/funciones por nombre. meta.get-function() devuelve una referencia llamable, habilitando patrones de orden superior. Úsalos para código de librería defensivo.

sass
@use 'sass:meta';

// Inspect values
meta.type-of(10px);          // number
meta.type-of("hi");          // string
meta.type-of((a: 1));        // map
meta.inspect((a: 1, b: 2));  // (a: 1, b: 2) - readable representation

// Variable existence (within current scope)
meta.variable-exists("base");    // true if $base exists
meta.global-variable-exists("primary");

// Mixin/function existence
meta.mixin-exists("my-mixin");
meta.function-exists("my-func");

// Feature queries
meta.feature-exists("at-error");  // true

// Get a function reference (for higher-order use)
$fn: meta.get-function("lighten");

Funciones de inspección

type-of() (global o meta.type-of) identifica el tipo de dato de un valor — esencial para lógica defensiva de funciones/mixins. inspect() renderiza cualquier valor de Sass (incluidos mapas y listas anidadas) como cadena legible, perfecto para el logging de @debug. math.unit()/is-unitless() inspeccionan números. Juntas, estas herramientas hacen observables los internos de Sass durante el desarrollo.

sass
@use 'sass:meta';
@use 'sass:math';

// type-of: get the type of any value
$value: 16px;
type-of($value);          // number
type-of("hello");         // string
type-of(#fff);            // color
type-of(true);            // bool
type-of(null);            // null
type-of(1 2 3);           // list
type-of((a: 1));          // map

// inspect: readable debug output of complex values
$map: (primary: blue, secondary: green);
debug: inspect($map);  // (primary: blue, secondary: green)

// unit / unitless for numbers
math.unit(16px);         // px
math.is-unitless(16);    // true

// Combine with @debug for tracing
@debug "got: #{inspect($map)}";
20

Sintaxis Sass vs SCSS

Sintaxis SCSS (.scss)

SCSS (.scss) es la sintaxis de Sass más popular. Es un superconjunto estricto de CSS — cualquier archivo CSS válido es SCSS válido, así que puedes renombrar .css a .scss y empezar a añadir características de Sass incrementalmente. SCSS usa llaves y punto y coma como CSS. Elige SCSS para proyectos nuevos y adopción de equipos.

sass
// SCSS - Sassy CSS
// Uses braces {} and semicolons ;
// Superset of CSS - all CSS is valid SCSS

$primary: #3498db;

.button {
  background: $primary;

  &:hover {
    background: darken($primary, 10%);
  }

  .icon {
    width: 16px;
    height: 16px;
  }
}

// Pros: familiar to CSS devs, easy migration, widely adopted

Sintaxis indentada Sass (.sass)

La sintaxis indentada de Sass (.sass) prescinde de llaves y punto y coma, confiando únicamente en la sangría (como Python o Stylus). Es más tersa pero no puedes pegar CSS crudo en un archivo .sass sin cambios, y los errores de sangría causan bugs. Menos común que SCSS pero preferida por algunos por su aspecto limpio. Ambas compilan al CSS idéntico.

sass
// Sass - indented syntax
// NO braces, NO semicolons - uses indentation only
// Removes CSS punctuation for a cleaner look

$primary: #3498db

.button
  background: $primary

  &:hover
    background: darken($primary, 10%)

  .icon
    width: 16px
    height: 16px

// Pros: less typing, cleaner visually
// Cons: can't paste CSS directly, less popular, error-prone indentation

Convertir entre sintaxis

sass-convert (incluido con Sass) convierte entre .scss y .sass. En la sintaxis de Sass, @mixin se convierte en = y @include en + por brevedad. Más allá de la sintaxis, ambos son idénticos — mismas características, mismo CSS de salida. La mayoría de equipos se estandarizan en SCSS por su compatibilidad con CSS y su soporte de herramientas más amplio.

sass
// Convert SCSS to Sass (and vice versa) with the sass CLI:
// $ sass-convert style.scss style.sass
// $ sass-convert style.sass style.scss

// Bulk convert a folder:
// $ sass-convert --recursive --from scss --to sass scss/ sass/
// $ sass-convert --recursive --from sass --to scss sass/ scss/

// Key syntax differences:
// 1. SCSS uses { } and ;  |  Sass uses indentation
// 2. SCSS: @include mixin()  |  Sass: +mixin()
// 3. SCSS: @mixin name {}    |  Sass: =name
// 4. SCSS: @import "x"       |  Sass: same
// 5. Multi-line: SCSS needs ; | Sass just newlines

Cuándo usar cada uno

SCSS es el valor por defecto más seguro — es el estándar de la industria, cualquier archivo CSS es SCSS válido y la mayoría de documentación/ejemplos lo usan. La sintaxis indentada .sass atrae a desarrolladores que odian la puntuación pero está menos soportada por las herramientas y dificulta incorporar a nuevos miembros del equipo. Elige uno por proyecto y sé consistente.

sass
// Use SCSS (.scss) when:
// - Starting a new project (most common choice)
// - Migrating an existing CSS codebase (CSS is valid SCSS)
// - Working on a team (most developers know SCSS)
// - Using CSS frameworks/libraries (they're usually SCSS)

// Use Sass (.sass) when:
// - You prefer minimal punctuation / Python-like syntax
// - Writing from scratch with no CSS to migrate
// - Personal preference for cleaner-looking source

// Both produce identical CSS. The choice is stylistic.
// IMPORTANT: don't mix .scss and .sass in the same project.

Trampas comunes

El Sass moderno desaconseja varias características heredadas: usa math.div() en lugar de / para dividir, @use/@forward en lugar de @import, y las funciones de módulo sass:color/sass:math en lugar de las globales lighten()/darken()/mix() etc. La herramienta sass-migrator automatiza estas migraciones. Vigila las advertencias de deprecación durante la compilación para mantener el código a prueba de futuro.

sass
// 1. Division: / is deprecated for math, use math.div()
@use 'sass:math';
width: math.div(100px, 2);   // CORRECT
// width: 100px / 2;          // DEPRECATED (may be CSS list separator)

// 2. @import is deprecated - use @use/@forward
@use 'variables';             // CORRECT
// @import 'variables';        // DEPRECATED

// 3. lighten()/darken() deprecated - use color.adjust
@use 'sass:color';
color.adjust($c, $lightness: 10%);   // CORRECT
// lighten($c, 10%);                  // DEPRECATED

// 4. Global color functions deprecated - use sass:color module
color.mix(red, blue);          // CORRECT (via @use 'sass:color')
// mix(red, blue);              // DEPRECATED global function

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.