Kurs HTML i CSS · Moduł 7: SASS

SASS vs CSS Custom Properties - kiedy używać czego?

6 min czytania ·
W tej lekcji7

Witaj w kolejnej komnacie egipskiej mądrości! Jestem Mohamet i dzisiaj odkryjemy przed Tobą jeden z najważniejszych sekretów współczesnego CSS - różnicę między zmiennymi SASS a natywnym CSS Custom Properties (nazywane też CSS Variables).

Podobnie jak starożytni Egipcjanie mieli różne narzędzia do różnych celów - jedne do budowy piramid, inne do rysowania hieroglifów - tak i my mamy różne narzędzia do zarządzania wartościami w CSS. Poznajmy je!

SASS Variables - kompilacja w czasie budowy

Zmienne SASS są przetwarzane w czasie kompilacji. Oznacza to, że zanim Twój kod trafi do przeglądarki, SASS zamienia wszystkie zmienne na konkretne wartości.

// SASS variables - compile time
$primary-color: #3498db;
$spacing-unit: 8px;
$font-stack: 'Roboto', sans-serif;

.button {
  background: $primary-color;
  padding: $spacing-unit * 2;
  font-family: $font-stack;
}

Po skompilowaniu do CSS:

.button {
  background: #3498db;
  padding: 16px;
  font-family: 'Roboto', sans-serif;
}

Jak widzisz, zmienne SASS znikają w finalnym CSS - zostają tylko konkretne wartości. To jak hieroglify, które po przetłumaczeniu stają się zwykłym tekstem.

CSS Custom Properties - dynamiczne w czasie rzeczywistym

CSS Custom Properties działają w przeglądarce w czasie rzeczywistym. Są prawdziwymi zmiennymi CSS, które można zmieniać dynamicznie!

/* CSS Custom Properties - runtime, dynamic! */
:root {
  --primary-color: #3498db;
  --spacing-unit: 8px;
  --font-stack: 'Roboto', sans-serif;
}

.button {
  background: var(--primary-color);
  padding: calc(var(--spacing-unit) * 2);
  font-family: var(--font-stack);
}

Różnica: Te zmienne pozostają w finalnym CSS i można je zmieniać dynamicznie przez JavaScript!

// Możesz zmieniać CSS Custom Properties w czasie rzeczywistym!
document.documentElement.style.setProperty('--primary-color', '#e74c3c');

// SASS variables NIE MOGĄ być zmieniane w runtime - są już skompilowane!

Kluczowe różnice

1. Zasięg (Scope)

SASS Variables:

$global-color: blue;

.foo {
  $local-color: green;
  color: $local-color; // działa
}

.bar {
  color: $local-color; // BŁĄD! Zmienna niedostępna
}

CSS Custom Properties:

:root {
  --global-color: blue;
}

.foo {
  --local-color: green;
  color: var(--local-color); /* działa */
}

.bar {
  color: var(--local-color); /* fallback do wartości domyślnej lub dziedziczenie */
}

CSS Custom Properties dziedziczą się w dół drzewa DOM - podobnie jak kolor czy czcionka!

2. Obliczenia matematyczne

SASS Variables:

$base-size: 16px;
$large-size: $base-size * 2; // 32px - obliczone podczas kompilacji

.element {
  font-size: $large-size; // wynik: font-size: 32px;
}

CSS Custom Properties:

:root {
  --base-size: 16px;
}

.element {
  /* Musisz użyć calc() */
  font-size: calc(var(--base-size) * 2);
}

3. Dynamiczne zmiany

SASS Variables - brak wsparcia dla dynamicznych zmian:

// To NIE ZADZIAŁA w runtime!
$theme-color: #3498db;

.theme-light {
  $theme-color: #ecf0f1; // To się nie zmieni po załadowaniu strony
}

CSS Custom Properties - pełna dynamika:

:root {
  --theme-color: #3498db;
  --background: #ffffff;
  --text: #000000;
}

/* Ciemny motyw - po prostu nadpisz zmienne! */
[data-theme="dark"] {
  --theme-color: #e74c3c;
  --background: #2c3e50;
  --text: #ecf0f1;
}

.page {
  background: var(--background);
  color: var(--text);
}

Możesz przełączać motywy jedną linią JavaScriptu:

document.body.setAttribute('data-theme', 'dark');

Praktyczne przykłady - kiedy używać czego?

Użyj SASS Variables gdy:

1. Potrzebujesz mixinów i funkcji

$primary-color: #3498db;

@mixin button-variant($color) {
  background: $color;
  border-color: darken($color, 10%);

  &:hover {
    background: darken($color, 15%);
  }
}

.btn-primary {
  @include button-variant($primary-color);
}

2. Wykonujesz złożone obliczenia

$grid-columns: 12;
$grid-gutter: 30px;

@for $i from 1 through $grid-columns {
  .col-#{$i} {
    width: percentage($i / $grid-columns);
  }
}

3. Potrzebujesz zagnieżdżania i organizacji kodu

$breakpoint-tablet: 768px;

.header {
  padding: 20px;

  @media (min-width: $breakpoint-tablet) {
    padding: 40px;
  }

  .nav {
    display: flex;

    &__item {
      margin: 0 10px;
    }
  }
}

Użyj CSS Custom Properties gdy:

1. Potrzebujesz dynamicznych zmian

:root {
  --primary-hue: 210;
  --primary-saturation: 70%;
  --primary-lightness: 50%;
}

.button {
  background: hsl(
    var(--primary-hue),
    var(--primary-saturation),
    var(--primary-lightness)
  );
}

/* Zmień odcień dynamicznie w JS */
const slider = document.querySelector('#hue-slider');
slider.addEventListener('input', (e) => {
  document.documentElement.style.setProperty('--primary-hue', e.target.value);
});

2. Tworzysz system motywów

/* Jasny motyw */
:root {
  --bg-primary: #ffffff;
  --bg-secondary: #f8f9fa;
  --text-primary: #212529;
  --text-secondary: #6c757d;
  --border-color: #dee2e6;
}

/* Ciemny motyw */
[data-theme="dark"] {
  --bg-primary: #212529;
  --bg-secondary: #343a40;
  --text-primary: #f8f9fa;
  --text-secondary: #adb5bd;
  --border-color: #495057;
}

/* Komponenty używają tych samych zmiennych */
.card {
  background: var(--bg-primary);
  color: var(--text-primary);
  border: 1px solid var(--border-color);
}

3. Potrzebujesz dziedziczenia wartości w komponentach

.card {
  --card-padding: 1rem;
  --card-bg: white;

  padding: var(--card-padding);
  background: var(--card-bg);
}

.card--large {
  --card-padding: 2rem; /* Nadpisz tylko padding */
}

.card--dark {
  --card-bg: #2c3e50; /* Nadpisz tylko background */
}

Najlepsze rozwiązanie: Używaj obu!

Podobnie jak starożytni Egipcjanie używali różnych narzędzi do budowy swoich cudów architektury, ty również powinieneś łączyć moc SASS i CSS Custom Properties!

Strategia hybrydowa:

// _variables.scss - SASS variables dla konfiguracji projektu
$color-blue-500: #3498db;
$color-red-500: #e74c3c;
$spacing-base: 8px;

// Generuj CSS Custom Properties z SASS variables
:root {
  // Kolory
  --color-primary: #{$color-blue-500};
  --color-danger: #{$color-red-500};

  // Spacing
  --spacing-xs: #{$spacing-base * 0.5};
  --spacing-sm: #{$spacing-base};
  --spacing-md: #{$spacing-base * 2};
  --spacing-lg: #{$spacing-base * 3};
}

// Użyj SASS do generowania wariantów
@mixin generate-spacing-utilities {
  @each $size, $value in (
    'xs': var(--spacing-xs),
    'sm': var(--spacing-sm),
    'md': var(--spacing-md),
    'lg': var(--spacing-lg)
  ) {
    .p-#{$size} {
      padding: #{$value};
    }
    .m-#{$size} {
      margin: #{$value};
    }
  }
}

@include generate-spacing-utilities;

Praktyczny przykład - responsywny system typografii:

// SASS - konfiguracja i breakpointy
$breakpoint-sm: 576px;
$breakpoint-md: 768px;
$breakpoint-lg: 992px;

:root {
  // Bazowy rozmiar czcionki - może być zmieniany przez user preferences
  --font-size-base: 16px;

  // Skala typograficzna
  --font-size-xs: 0.75rem;
  --font-size-sm: 0.875rem;
  --font-size-md: 1rem;
  --font-size-lg: 1.125rem;
  --font-size-xl: 1.25rem;
  --font-size-2xl: 1.5rem;
  --font-size-3xl: 2rem;
}

// SASS mixin dla responsive typography
@mixin responsive-font-size($min, $max, $min-vw: $breakpoint-sm, $max-vw: $breakpoint-lg) {
  font-size: $min;

  @media (min-width: $min-vw) {
    font-size: calc(#{$min} + (#{$max} - #{$min}) * ((100vw - #{$min-vw}) / (#{$max-vw} - #{$min-vw})));
  }

  @media (min-width: $max-vw) {
    font-size: $max;
  }
}

.heading {
  @include responsive-font-size(var(--font-size-xl), var(--font-size-3xl));
}

Możesz teraz zmienić rozmiar czcionki dla użytkowników z preferencjami dostępności:

// Użytkownik wybiera większe czcionki
document.documentElement.style.setProperty('--font-size-base', '20px');

Podsumowanie - złote zasady

Używaj SASS Variables dla:

  • Konfiguracji projektu (kolory bazowe, breakpointy, wartości stałe)
  • Mixinów i funkcji (reużywalny kod, obliczenia)
  • Organizacji kodu (partials, zagnieżdżanie, @extend)
  • Kompilacji (generowanie klas utility, pętle @for/@each)

Używaj CSS Custom Properties dla:

  • Dynamicznych zmian (motywy, user preferences)
  • Dziedziczenia kontekstowego (komponenty, nested values)
  • JavaScript interakcji (animacje, interaktywne elementy)
  • Runtime calculations (responsive values, fluid typography)

Hybryda (najlepsze podejście):

// Konfiguracja w SASS
$colors: (
  'blue': #3498db,
  'red': #e74c3c,
  'green': #27ae60
);

// Generuj CSS Custom Properties
:root {
  @each $name, $color in $colors {
    --color-#{$name}: #{$color};
    --color-#{$name}-light: #{lighten($color, 10%)};
    --color-#{$name}-dark: #{darken($color, 10%)};
  }
}

// Użyj w komponentach
.button {
  background: var(--color-blue);

  &:hover {
    background: var(--color-blue-dark);
  }
}

// W JavaScript możesz dynamicznie zmieniać
document.documentElement.style.setProperty('--color-blue', '#2ecc71');

Zadanie praktyczne

Stwórz system motywów, który łączy SASS i CSS Custom Properties:

  1. Użyj SASS do zdefiniowania bazowych kolorów i wygenerowania wariantów
  2. Stwórz CSS Custom Properties dla motywu jasnego i ciemnego
  3. Dodaj przycisk przełączający motywy przez JavaScript
  4. Wykorzystaj SASS mixiny do tworzenia komponentów używających CSS variables

Podobnie jak faraonowie łączyli różne materiały do budowy swoich monumentów, tak i Ty połącz moc SASS i CSS Custom Properties, aby stworzyć potężny, elastyczny i łatwy w utrzymaniu system stylów!

Kod do tej lekcji: index.html
<!DOCTYPE html>
<html lang="pl">
<head><title>Projekt formularza</title></head>
<body style="background:#d4a574;font-family:serif;padding:20px;color:#3d2914">
<h1>Projekt Formularza</h1>
<p>Stwórz formularz rejestracji pisarza!</p>
</body>
</html>

Powodzenia, młody budowniczy hieroglifów CSS!

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

  1. Projekt do wysłaniaProjekt: Kompletny system stylów SASS
  2. WideoPodsumowanie modułu

Przydatne artykuły