Skip to content

Sass Aide-mémoire

Préprocesseur CSS puissant avec variables, imbrication et mixins.

01

Bases de Sass

Variables et imbrication

Les variables Sass utilisent le préfixe $. L'imbrication reflète la structure HTML. & désigne le sélecteur parent. Utilisez lighten()/darken() pour la manipulation de couleurs.

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 syntaxe indentée

SCSS (.scss) est un sur-ensemble de CSS — tout fichier CSS valide est du SCSS valide. Sass (.sass) supprime accolades et points-virgules, en s'appuyant sur l'indentation. SCSS est plus populaire et plus facile à migrer. Choisissez-en un et restez cohérent dans un projet.

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; }

Commentaires

Les commentaires // sont silencieux (retirés de la sortie). Les commentaires /* */ sont préservés dans le CSS compilé. Les commentaires /*! */ sont gardés même en mode compressé/production — pour les licences ou avis critiques. Utilisez // pour la documentation interne.

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; }

Compilation

Sass compile le .scss/.sass en .css. --watch recompile automatiquement à la sauvegarde. Styles de sortie : expanded (lisible par défaut), nested (indenté), compact (une règle par ligne), compressed (minifié pour la production). Utilisez compressed en production pour réduire la taille du fichier.

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; }

Aperçu de l'héritage de sélecteurs

Sass est un préprocesseur CSS ajoutant variables, imbrication, mixins, héritage, fonctions et flux de contrôle. Cela réduit la répétition (principe DRY) et rend les grandes feuilles de style gérables. Toutes les fonctionnalités Sass compilent vers du CSS standard.

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 et types de données

Déclaration et portée des variables

Les variables déclarées hors de tout bloc sont globales. Les variables déclarées dans un bloc sont locales à ce bloc. Les locales masquent les globales du même nom. Utilisez des locales pour éviter de polluer le namespace 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 affecte une valeur seulement si la variable est null ou undefined. Cela permet aux utilisateurs de surcharger les défauts d'une bibliothèque en réglant les variables AVANT de l'importer. Critique pour bâtir des bibliothèques Sass configurables et design systems.

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 affecte explicitement à la portée globale depuis un bloc (mixin, fonction, directive de contrôle). Depuis Sass 3, l'affectation dans les blocs est locale par défaut. Utilisez !global avec parcimonie — la mutation globale rend le code difficile à raisonner.

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

Types de données

Sass a 7 types de données : nombres (avec unités), chaînes, couleurs, booléens, null, listes et maps. type-of() retourne le type sous forme de chaîne. Comprendre les types est essentiel pour bien utiliser fonctions et directives de contrôle.

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

Interpolation #{}

L'interpolation #{} injecte des variables dans les sélecteurs, noms de propriétés, chaînes et autres endroits où les variables simples ne sont pas permises. Contrairement à $var qui ne marche que dans les valeurs, #{} marche presque partout. Elle convertit toute valeur en sa représentation chaîne.

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

Imbrication (nesting)

Imbrication de base

L'imbrication permet d'écrire des sélecteurs reflétant la hiérarchie HTML, évitant la répétition des sélecteurs parents. Le CSS compilé crée des sélecteurs descendants. Cela améliore la lisibilité mais l'abus crée des sélecteurs trop spécifiques — limitez l'imbrication à 3-4 niveaux au maximum.

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 {...}

Imbrication profonde (anti-pattern)

L'imbrication profonde crée de longs sélecteurs trop spécifiques, durs à surcharger et plus lents à matcher pour les navigateurs. Règle empirique : pas plus de 3-4 niveaux. Aplatissez les structures profondes avec des classes explicites style BEM pour la maintenabilité.

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; }

Propriétés imbriquées

Les propriétés imbriquées utilisent deux-points après le namespace de propriété (font:, border:, margin:) pour grouper les sous-propriétés liées. Évite de répéter le préfixe et n'est que du sucre syntaxique. Compile vers des propriétés CSS standard comme 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

Imbrication des media queries

Imbriquer des @media dans les règles garde les styles responsifs co-localisés avec le composant, améliorant la maintenabilité. Le CSS compilé hisse @media au niveau supérieur. Un gain de lisibilité majeur face à l'éparpillement des media queries dans les fichiers.

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; } }

Listes de sélecteurs dans l'imbrication

Quand on imbrique une liste de sélecteurs séparés par virgules, Sass combine chaque élément avec le parent. Plus propre que d'écrire chaque combinaison à la main. Le & peut aussi s'utiliser dans les listes imbriquées pour apposer classes/modificateurs à plusieurs parents d'un coup.

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

Sélecteur parent (&)

Sélecteur parent de base

& désigne le sélecteur parent, permettant d'imbriquer pseudo-classes (:hover, :focus), pseudo-éléments (::before) et modificateurs. Cela garde les styles liés ensemble. &:hover compile en .button:hover. Sans &, on obtiendrait un sélecteur descendant.

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 avec &

& permet le nommage BEM (Block Element Modifier) de façon concise. &__title appose __title au parent, créant .card__title. &--featured crée des classes modificateurs. Cela garde la génération des classes BEM DRY et cohérente dans une définition de bloc.

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;
  }
}

Suffixer le sélecteur parent

Placer & au début d'un sélecteur imbriqué appose le suffixe au parent, générant des sélecteurs composés comme .button-primary. Utile pour nommer des variantes. Attention — abuser du suffixage peut obscurcir les noms de classes générés à la lecture de la source.

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

Imbrication inversée

Placer & à la fin d'un sélecteur imbriqué inverse l'ordre — le parent devient descendant. Parfait pour les styles contextuels/thèmes comme .dark-theme .modal où le composant s'adapte au contexte de son ancêtre, gardant les surcharges contextuelles près du composant.

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

& multiples dans un sélecteur

On peut utiliser & plusieurs fois dans un même sélecteur. & + & génère .button + .button pour le style entre frères. Puissant pour l'espacement entre éléments répétés et les sélecteurs complexes à états. Chaque & est remplacé par le sélecteur parent complet.

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

Partials (fichiers _partial)

Créer des partials

Les partials sont des fichiers Sass nommés avec un underscore initial (ex. _variables.scss). L'underscore dit à Sass de ne pas les compiler en fichier CSS séparé. Les partials sont destinés à être importés dans un fichier principal. Cela modularise le code pour la maintenabilité.

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';

Conventions de nommage des partials

Les partials portent des noms descriptifs avec un underscore initial. L'instruction @use ou @import omet l'underscore et l'extension — Sass résout 'variables' vers _variables.scss automatiquement. Un nommage cohérent aide les équipes à localiser rapidement le code.

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';

Pattern d'architecture 7-1

Le pattern 7-1 est une architecture Sass largement adoptée : 7 dossiers (abstracts, base, components, layout, pages, themes, vendors) plus un point d'entrée main.scss. Passe bien à l'échelle pour les grands projets en séparant les préoccupations. Chaque dossier héberge des partials importés dans 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';

Index de partials (_index.scss)

Un partial _index.scss (ou _all.scss) agit comme l'API publique d'un dossier, transmettant tous ses partials. Cela permet d'importer tout un dossier avec un seul @use. À l'ajout d'un nouveau partial, mettez à jour seulement l'index — le fichier principal reste inchangé. C'est le pattern du système de modules 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

Bonnes pratiques des partials

Bonnes pratiques : une préoccupation par partial, des fichiers petits (50-200 lignes), @use pour une gestion explicite des dépendances, et éviter les imports circulaires. Les partials améliorent maintenabilité et réutilisation. @use rend les dépendances explicites, contrairement au vieux @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 et @use

@import (déprécié)

@import est déprécié car il pollue le namespace global, peut exécuter des fichiers plusieurs fois et n'offre ni confidentialité ni namespacing. Sass recommande de migrer vers @use et @forward. Le code @import existant marche encore mais devrait migrer pour les nouveaux projets.

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 de base (namespacé)

@use charge un module une fois et expose ses membres via un namespace (le nom de fichier par défaut). Accédez aux membres avec namespace.$var ou namespace.nom-mixin(). Cela prévient pollution globale et collisions de noms. Chaque module n'est chargé qu'une fois, peu importe le nombre de @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 avec as

'as v' renomme le namespace en quelque chose de plus court. 'as *' charge les membres dans la portée courante sans préfixe — pratique mais risque des collisions, donc avec parcimonie. Les namespaces nommés sont plus sûrs et clarifient d'où vient chaque membre à la lecture.

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 avec configuration (with)

'with (...)' configure les variables !default d'un module au chargement. Cela remplace le pattern de configuration par variables globales de @import. La clause with doit précéder tout autre usage du module. C'est la façon standard de configurer des thèmes de bibliothèques et design tokens.

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

Comparaison @use vs @import

Migration de @import vers @use : les membres deviennent namespacés, les fichiers se chargent une fois, et les membres commençant par - ou _ sont privés (non exposés). @use rend les dépendances explicites et prévient la pollution globale accidentelle. Utilisez l'outil sass-migrator pour automatiser la migration des grandes bases de code.

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)

Définir et utiliser des mixins

@mixin définit un bloc réutilisable de déclarations (et même de règles). @include insère le contenu du mixin là où il est utilisé. Les mixins sont idéals pour les préfixes vendeurs, clearfix et groupes de déclarations répétés. Contrairement à @extend, les mixins dupliquent les déclarations à chaque inclusion.

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;
}

Arguments de mixin

Les mixins acceptent des arguments comme des fonctions. Par position (l'ordre compte) ou par nom (indépendant de l'ordre, plus clair). Les arguments nommés sont utiles pour les mixins à nombreux paramètres optionnels. Les arguments rendent les mixins flexibles et réutilisables sur différentes valeurs.

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); }

Arguments par défaut

Les valeurs d'arguments par défaut rendent les mixins flexibles — les appelants peuvent omettre des arguments pour utiliser les défauts. Utilisez les arguments nommés pour surcharger des paramètres précis en gardant les autres à leur défaut. Les valeurs par défaut s'évaluent à chaque inclusion du mixin, pas une fois à la définition.

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 avec @content

@content injecte un bloc de styles transmis à @include. Extrêmement puissant pour les mixins de media queries, keyframes et contextes d'enveloppe. Le bloc inclus s'évalue dans la portée appelante, donc peut utiliser les variables de l'appelant. Voir la section @content pour le passage d'arguments.

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; } }

Arguments variables (...)

L'opérateur ... a deux usages : dans une définition de mixin, il collecte les arguments excédentaires en une liste (variadique) ; au site d'appel, il expand une liste en arguments individuels. Essentiel pour les mixins enveloppant des propriétés CSS acceptant un nombre variable de valeurs, comme box-shadow et 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 et héritage

@extend de base

@extend fait hériter à un sélecteur tous les styles d'un autre, partageant la règle plutôt que de la dupliquer. Le CSS compilé groupe les sélecteurs. @extend est plus DRY qu'un mixin pour des styles de base partagés, mais peut créer des chaînes de sélecteurs surprenantes — avec prudence.

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; ... }

Étendre des sélecteurs complexes

@extend marche avec tout sélecteur — classes, sélecteurs d'éléments, pseudo-classes, sélecteurs composés. Étendre .icon.large hérite des règles matchant à la fois .icon et .icon.large. Soyez prudent en étendant des sélecteurs complexes ; le CSS généré peut cascadé de façon inattendue et gonfler la sortie.

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

Enchaîner des @extend

Les @extend s'enchaînent : si B étend A et C étend B, C hérite des deux. Le CSS compilé groupe les sélecteurs en conséquence. De longues chaînes peuvent produire de grandes listes de sélecteurs et de la spécificité surprenante. Pour la plupart des scénarios de réutilisation, un mixin est plus prévisible que des @extend chaînés.

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

Ajouter !optional à @extend saute silencieusement l'extension si le sélecteur cible n'existe pas, au lieu de lever une erreur. Utile quand on étend des sélecteurs optionnels ou chargés conditionnellement. Sans !optional, @extend fait échouer la compilation si la cible manque.

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 groupe les sélecteurs (CSS plus petit quand fortement réutilisé) mais crée un couplage caché. Les mixins @include dupliquent les déclarations (CSS plus grand) mais sont autonomes et configurables. Préférez les mixins pour du nouveau code — plus prévisibles. Réservez @extend aux relations sémantiques au sein d'un fichier.

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

Sélecteurs placeholder (%placeholder)

Bases des %placeholder

Les sélecteurs %placeholder (ex. %base-message) sont des règles existant seulement pour être étendues — ils ne sortent jamais seuls dans le CSS. Cela évite le problème de classe de base inutilisée que peut causer @extend sur de vraies classes. Ils sont la façon la plus propre de partager des styles destinés uniquement à l'héritage.

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 classe

Quand on @extend une vraie classe, elle apparaît dans la sortie même jamais utilisée en HTML. Les placeholders résolvent cela : %base n'est émis que là où il est étendu. Utilisez de vraies classes quand la base sert aussi directement en HTML ; les placeholders quand la base est purement pour l'héritage.

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 avec @extend

Un sélecteur peut @extend plusieurs placeholders, combinant des ensembles de styles partagés. Cela compose des blocs réutilisables sans émettre de classes de base inutilisées. Les placeholders brillent pour les primitives de design system (cartes, boutons, inputs) partagées entre nombreux composants concrets.

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;
}

Partage de plusieurs sélecteurs réservés

Quand plusieurs sélecteurs @extend le même placeholder, Sass les groupe ensemble dans la sortie, produisant un CSS compact. C'est la forme la plus efficace de partage de styles en Sass : une forme d'héritage/composition sans gonflement de classes CSS au 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

Cas d'usage des sélecteurs réservés

Les sélecteurs réservés sont idéaux pour les motifs utilitaires réutilisables : centrage, clearfix, accessibilité (visually-hidden) et primitives de design system. Ils gardent ces motifs au même endroit et ne les émettent que si utilisés. Une façon propre de partager des styles utilitaires non 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

Fonctions (@function)

Définir des fonctions

@function définit un calcul réutilisable qui @return une valeur. Les fonctions s'appellent dans les valeurs de propriétés (contrairement aux mixins qui sortent des déclarations). Utilisez les fonctions pour les calculs comme conversions d'unités, maths de couleurs et mise à l'échelle responsive. La valeur de retour peut être n'importe quel type de données 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

Arguments et défauts de fonctions

Les fonctions supportent arguments par défaut, arguments nommés et arguments variadiques (...), comme les mixins. Les défauts rendent les fonctions pratiques à appeler. Les arguments nommés améliorent la lisibilité des fonctions à nombreux paramètres optionnels. Les arguments variadiques laissent les fonctions accepter un nombre quelconque de valeurs.

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
}

Aperçu des fonctions intégrées

Sass livre des fonctions intégrées riches pour couleurs, maths, chaînes, listes et maps. Le Sass moderne les organise en modules (sass:math, sass:color, sass:string, sass:list, sass:map, sass:meta) chargés via @use. Les noms de fonctions globales marchent encore mais sont dépréciés au profit des fonctions de modules namespacées.

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)

Exemples de fonctions pratiques

Les fonctions excellent à encapsuler des calculs réutilisables : conversions d'unités (px/em/rem), gestion de z-index via une map, et lookups de design tokens. Centraliser cela dans des fonctions garantit la cohérence et fait que les changements (comme mettre à jour la taille de police de base) se propagent partout automatiquement.

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

Fonctions récursives

Les fonctions Sass supportent la récursion via des conditionnels @if et des appels de soi. Cela permet factorielle, Fibonacci et autres séquences calculées. Mais la récursion Sass n'a pas d'optimisation d'appel terminal et est lente — évitez la récursion profonde dans de vraies feuilles de style. Préférez les boucles (@for) pour le calcul itératif.

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

Directives de contrôle

@if / @else if / @else

@if/@else if/@else sortent des styles conditionnellement selon des comparaisons. Sass utilise == et != pour l'égalité (pas ===). Les opérateurs booléens sont 'and', 'or', 'not' (pas &&, ||, !). Utile pour le changement de thème, feature flags et logique responsive dans les mixins et fonctions.

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

Boucle @for

@for itère une variable d'une valeur de début à une valeur de fin. 'through' est inclusif (inclut la fin) ; 'to' exclusif (exclut la fin). Courant pour générer des colonnes de grille, animations décalées et classes utilitaires numérotées. Utilisez l'interpolation #{} pour insérer le compteur dans les sélecteurs.

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

Boucle @each (listes)

@each itère sur une liste, liant chaque élément à une variable. Idéal pour générer des variantes de thème, classes d'icônes et classes utilitaires depuis une liste de config. Les listes de listes peuvent se déballer en plusieurs variables par itération pour des données appariées comme des tuples (nom, couleur).

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 avec maps

@each sur une map lie à la fois clé et valeur à chaque itération. C'est la façon standard de générer des utilitaires responsifs, variantes de thème et classes conscientes des breakpoints depuis une map de configuration. L'ordre d'itération des maps suit l'ordre d'insertion dans le Sass moderne.

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));

Boucle @while

@while boucle jusqu'à ce que sa condition devienne fausse ; il faut mettre à jour le compteur manuellement. À utiliser pour des progressions non linéaires (ex. doubler à chaque pas) où @for ne convient pas. Assurez-vous toujours que la boucle se termine — oublier d'incrémenter cause une boucle infinie qui suspend la compilation.

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

Listes et maps

Listes

Les listes sont le type tableau de Sass, séparées par espaces ou virgules. Les index commencent à 1 (contrairement à la plupart des langages) — nth($list, 1) retourne le premier élément. Les index négatifs comptent depuis la fin. Une valeur unique est traitée comme liste à un élément. Les listes peuvent s'imbriquer.

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

Fonctions de listes

Fonctions de listes : length(), nth(), index() pour l'accès ; append(), join(), insert-nth() retournent de nouvelles listes (les listes sont immuables). zip() apparie les éléments de plusieurs listes. separator() retourne le séparateur de la liste. Utilisez @each pour itérer. L'API moderne vit dans le module 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

Maps

Les maps sont des collections clé-valeur (tableaux associatifs). Les clés doivent être uniques ; les valeurs peuvent être tout type Sass y compris des maps imbriquées. Utilisez map-get() pour lire les valeurs, map-has-key() pour vérifier l'existence. Les maps sont la façon standard de modéliser design tokens, breakpoints et palettes de thème.

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),
);

Fonctions de maps

Fonctions de maps : map-get() lit une valeur, map-keys()/map-values() retournent des listes, map-merge() combine des maps (génial pour étendre des thèmes), map-remove() supprime des clés. Les maps sont immuables — les fonctions retournent de nouvelles maps. L'API moderne est namespacée sous le module 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)

Itérer et déstructurer

@each déstructure les maps (clé, valeur) et les listes de listes, liant plusieurs variables par itération. Cela transforme des données de configuration en CSS généré — un motif puissant pour les design systems. Combiné aux maps, on peut piloter tout un framework de classes utilitaires depuis une seule map de config.

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

Fonctions de couleurs

lighten / darken

lighten() et darken() décalent la luminosité d'une couleur en pourcentage. Dépréciées au profit de color.adjust() de sass:color, explicite sur le canal modifié. Un lighten/darken pur peut produire des résultats surprenants sur des couleurs déjà extrêmes — préférez les ajustements basés 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 / transparence

rgba($color, $alpha) ajoute de la transparence à toute couleur — la fonction de couleur la plus courante. rgba() accepte aussi 4 arguments numériques. Le module sass:color moderne offre color.adjust($alpha: ...) pour un contrôle explicite de l'alpha. La syntaxe espace CSS Color 4 (rgb(r g b / a%)) est aussi valide dans le Sass moderne.

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 / mélange de couleurs

mix($color1, $color2, $weight) mélange deux couleurs — $weight est le pourcentage de $color1 (défaut 50%). Utilisez mix($color, white) pour les teintes et mix($color, black) pour les ombres, souvent plus naturelles que lighten()/darken(). color.mix est l'équivalent namespacé moderne.

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

Trois outils de couleur précis : color.adjust() ajoute des deltas aux canaux, color.scale() met à l'échelle les canaux vers leur min/max en pourcentage (plus sûr — ne dépasse jamais), color.change() fixe les canaux à des valeurs absolues. Les globaux adjust-color/scale-color/change-color sont des alias dépréciés.

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 lisent les canaux HSL — utiles pour la logique conditionnelle. color.complement() retourne la couleur de teinte opposée (génial pour les accents), color.grayscale() désature, color.invert() inverse en RGB. color.hsl() construit des couleurs depuis des valeurs HSL. Cela permet une génération de palettes programmatique.

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

Opérations mathématiques

Arithmétique de base

Sass supporte +, -, *, /, % sur les nombres et gère les unités. Comme le CSS utilise / pour la séparation (font: 16px/1.5), le / simple comme division est déprécié — utilisez math.div() de sass:math, ou des parenthèses. Les unités doivent être compatibles pour + et -. Multiplier deux valeurs avec unités est généralement une erreur.

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...

Conversion d'unités

Sass convertit automatiquement entre unités physiques (px, in, cm, mm, pt, pc) mais PAS entre px/em/rem/%. Il faut écrire des fonctions de conversion soi-même. Le pattern courant est une fonction rem($px) divisant par la taille de police de base. Centralisez la conversion d'unités pour garder une échelle d'espacement cohérente dans le projet.

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)

Fonctions mathématiques

sass:math fournit round(), ceil(), floor(), abs(), min(), max(), percentage(), et (plus récent) trigonométrie et racines plus des constantes comme math.$pi. min()/max() ici sont des fonctions Sass (différentes des min()/max() CSS — utilisez les CSS non quotées pour un vrai min/max CSS). Importez toujours math explicitement.

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

Modulo et division

math.div() est la fonction de division moderne — l'opérateur / est réservé aux séparateurs de listes CSS (comme font: 16px/1.5). math.mod() retourne le reste. math.compatible() vérifie si deux nombres peuvent s'additionner. Utilisez toujours @use 'sass:math' pour l'arithmétique ; le / global pour la division est déprécié et sera retiré.

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%; }
}

Opérateurs de comparaison et logique

Sass utilise == et != pour l'égalité. Les opérateurs booléens sont les mots-clés 'and', 'or', 'not' — pas les &&/||/! à la C. Utilisez des parenthèses pour clarifier la précédence. Ces opérateurs pilotent les conditionnels @if dans mixins, fonctions et directives de contrôle. Valeurs truthy : tout sauf false et 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

Fonctions de chaînes

quote / unquote

quote() enveloppe une chaîne de guillemets ; unquote() les retire. Sass distingue les chaînes quotées (pour content, noms de polices) des non quotées (pour identifiants, noms de classes). Beaucoup de fonctions acceptent les deux mais la distinction compte pour le formatage de sortie et la génération de sélecteurs.

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

Fonctions de casse

to-upper-case() et to-lower-case() convertissent la casse des chaînes — utiles pour générer des noms de classes cohérents, valeurs de content ou normaliser l'entrée. Combinées à l'interpolation #{}, elles permettent de bâtir sélecteurs et contenus dynamiques depuis des variables. Les versions namespacées modernes vivent dans 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

Fonctions de sass:string : string.length() retourne le compte de caractères, string.slice($str, $start, $end) une sous-chaîne (à partir de 1, négatifs depuis la fin), string.index() la position d'une sous-chaîne (à partir de 1, null si absente). Sass n'a pas de split intégré — implémentez-le avec une boucle utilisant index() et 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($string, $insert, $position) insère une sous-chaîne à une position à partir de 1 (utilisez un grand nombre pour ajouter à la fin). string.replace($string, $à-remplacer, $remplacement, $limit ?) échange des sous-chaînes (toutes par défaut, ou compte limité). Essentielles pour la génération programmatique de noms de classes et contenus.

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"

Motifs d'interpolation de chaînes

L'interpolation #{} convertit toute valeur Sass (nombres, listes, couleurs, booléens) en sa représentation chaîne et l'embarque. Utilisez-la pour bâtir sélecteurs dynamiques, noms de propriétés, valeurs de content et URLs. L'interpolation est le pont entre valeurs Sass et texte CSS en sortie, où les variables simples ne sont pas permises.

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 de base

@at-root sort du contexte d'imbrication courant, émettant la règle imbriquée au niveau supérieur de la feuille de style. Sans @at-root, .child dans .parent compile en .parent .child (descendant). @at-root le réduit à .child seul. Cela garde les règles liées groupées dans la source tout en sortant des sélecteurs plats.

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 avec sélecteurs

Combinez @at-root avec & pour ne garder que des parties du sélecteur parent. @at-root .wrapper & émet .wrapper .component (préfixant un contexte) au lieu de .component .wrapper. C'est la façon propre d'écrire des surcharges de thème/contexte tout en les gardant co-localisées avec le code du composant.

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 pour BEM

@at-root aide à générer les classes modificateurs BEM (.block--active) comme frères plutôt que descendants. Sans @at-root, imbriquer .block--active dans .block créerait .block .block--active (faux — cela signifie un bloc actif dans un bloc). @at-root émet le modificateur au niveau supérieur, ce qui est la sortie BEM correcte.

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 avec media queries

@at-root (with: media) hisse les règles hors de l'imbrication de sélecteurs mais les garde dans un bloc @media. @at-root (without: media) fait l'inverse. Les clauses with/without contrôlent quels contextes (rule, media, supports) sont préservés. Avancé mais essentiel pour bâtir des bibliothèques de mixins responsives robustes.

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)

Les clauses (without: ...) et (with: ...) contrôlent de quels contextes d'imbrication @at-root s'échappe. Contextes courants : 'rule' (sélecteurs), 'media' (@media), 'supports' (@supports) et 'all'. (without: rule) garde @media mais sort des sélecteurs. Ce contrôle précis de portée permet des patterns avancés de mixins et bibliothèques.

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

Bases de @content

@content dans un @mixin est un emplacement pour un bloc de styles transmis via @include { ... }. Le bloc inclus remplace @content au site d'appel. Cela permet aux mixins d'envelopper des styles custom — essentiel pour media queries, keyframes et tout pattern « d'enveloppe » où le contenu interne varie par usage.

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 avec arguments

@content ($args) transmet des valeurs du mixin au bloc inclus, qui les reçoit avec 'using ($vars)'. Cela permet aux mixins de fournir du contexte (comme le nom du breakpoint courant) au bloc de l'appelant. Puissant pour bâtir des mixins d'itération/enveloppe exposant l'état de boucle au consommateur.

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 pour media queries

Le cas d'usage @content le plus courant : un mixin respond-to qui enveloppe les styles dans la bonne @media. Les appelants passent un bloc de styles responsifs ; le mixin le place dans la bonne media query. Cela rend le code responsive lisible et centralise les définitions de breakpoints au même endroit.

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;
  }
}

Patterns de @content

@content alimente beaucoup de motifs réutilisables : enveloppes @supports, générateurs de keyframes, générateurs de classes modificateurs pour BEM. Chacun laisse l'appelant fournir le corps pendant que le mixin gère la plomberie (sélecteur, at-rule, namespace). C'est ainsi que les bibliothèques Sass bien structurées offrent des APIs flexibles et composables.

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; }
}

Cas d'usage de @content

@content permet des enveloppes contextuelles (media/supports/keyframes), des hooks d'extension (styles de base + ajouts custom) et de la sortie conditionnelle. C'est l'équivalent Sass des fonctions d'ordre supérieur : le mixin est le framework, @content le callback. Maîtrisez @content pour bâtir des utilitaires de styles flexibles et réutilisables.

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

Système de modules (@use / @forward)

@use vs @import

@use remplace @import par un vrai système de modules : le namespacing prévient les collisions, les modules se chargent une fois (mis en cache), les membres préfixés de - ou _ sont privés (non exposés), et 'with' configure explicitement les défauts. Cela corrige tous les problèmes structurels de @import. Utilisez @use pour tout nouveau code Sass.

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 re-exporte les membres d'un autre module sans se les approprier — parfait pour les fichiers barrel/index agrégeant le contenu d'un dossier. @forward supporte 'hide' pour exclure des membres et 'as prefix-*' pour renommer à la re-exportation. Cela permet de composer une API publique propre pour une bibliothèque ou un dossier.

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-'

Membres privés (préfixe -)

Les membres dont le nom commence par - ou _ sont privés — utilisables dans leur propre fichier mais NON exposés via @use ou @forward. Cela permet aux modules de masquer les détails d'implémentation et d'exposer seulement leur API publique. Utilisez le préfixe - pour les helpers internes, gardant l'interface du module propre et stable.

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

Configurer les modules (with)

'with ($var: valeur, ...)' configure les variables !default d'un module au chargement. C'est le remplaçant moderne et délimité du pattern de surcharge par variables globales de @import. La configuration ne s'applique qu'au premier @use d'un module — les @use suivants réutilisent le module configuré. C'est ainsi qu'on thème les bibliothèques.

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.

Bonnes pratiques des modules

Bonnes pratiques de modules : utilisez @use (pas @import), préférez des namespaces courts et explicites, agrégez les dossiers avec @forward dans _index.scss, marquez les helpers internes privés avec -, configurez les bibliothèques via 'with' sur des variables !default, et utilisez les modules sass:* intégrés pour les fonctions standard. Cela garde le code modulaire et maintenable.

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

Débogage (@debug / @warn / @error)

@debug

@debug imprime une valeur au terminal pendant la compilation, avec le fichier source et le numéro de ligne. Il n'arrête pas la build. Utilisez @debug pour inspecter les variables, tracer le flux d'exécution et vérifier les calculs pendant le développement. Retirez ou commentez les @debug avant livraison. La sortie va sur stderr, pas dans le 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 un avertissement non fatal à la console pendant la compilation — la build continue. À utiliser pour les notices de dépréciation, comportements de repli et alertes de mauvais usage dans les bibliothèques. @warn inclut une pile d'appels par défaut pour que les utilisateurs localisent la source. Comme @debug, il n'apparaît pas dans la sortie 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 lève une erreur fatale, arrêtant immédiatement la compilation. Utilisez-le pour valider les entrées des fonctions et mixins — attraper tôt un mauvais usage avec un message clair vaut mieux qu'émettre du CSS cassé. @error inclut une pile d'appels. Réservez @error aux états vraiment invalides ; @warn pour les problèmes récupérables et @debug pour l'inspection.

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.

Fonctions du module meta

sass:meta fournit l'introspection : type-of() retourne le type d'une valeur, inspect() produit une chaîne lisible de toute valeur (génial pour déboguer), et les fonctions *-exists vérifient variables/mixins/fonctions par nom. meta.get-function() retourne une référence appelable, permettant des patterns d'ordre supérieur. À utiliser pour du code de bibliothèque défensif.

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");

Fonctions d'inspection

type-of() (global ou meta.type-of) identifie le type de données d'une valeur — essentiel pour la logique défensive des fonctions/mixins. inspect() rend toute valeur Sass (maps et listes imbriquées incluses) en chaîne lisible, parfait pour du logging @debug. math.unit()/is-unitless() inspectent les nombres. Ensemble, ces outils rendent les internals Sass observables pendant le développement.

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

Syntaxe Sass vs SCSS

Syntaxe SCSS (.scss)

SCSS (.scss) est la syntaxe Sass la plus populaire. Strict sur-ensemble de CSS — tout fichier CSS valide est du SCSS valide, donc on peut renommer .css en .scss et ajouter les fonctionnalités Sass incrémentalement. SCSS utilise accolades et points-virgules comme le CSS. Choisissez SCSS pour les nouveaux projets et l'adoption en équipe.

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

Syntaxe indentée Sass (.sass)

La syntaxe indentée Sass (.sass) abandonne accolades et points-virgules, s'appuyant uniquement sur l'indentation (comme Python ou Stylus). Plus terser mais on ne peut pas coller du CSS brut dans un fichier .sass sans changement, et les erreurs d'indentation causent des bugs. Moins courant que SCSS mais préféré par certains pour son look propre. Les deux compilent vers un CSS identique.

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 syntaxes

sass-convert (fourni avec Sass) convertit entre .scss et .sass. En syntaxe Sass, @mixin devient = et @include devient + par brièveté. Au-delà de la syntaxe, tout est identique — mêmes fonctionnalités, même CSS en sortie. La plupart des équipes standardisent sur SCSS pour sa compatibilité CSS et son meilleur support d'outillage.

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

Quand utiliser lequel

SCSS est le défaut le plus sûr — standard de l'industrie, tout fichier CSS est du SCSS valide, et la plupart des docs/exemples l'utilisent. La syntaxe indentée .sass séduit les développeurs qui n'aiment pas la ponctuation mais est moins largement supportée par l'outillage et plus dure à intégrer pour de nouveaux membres. Choisissez-en un par projet et restez cohérent.

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.

Pièges courants

Le Sass moderne déprécie plusieurs fonctionnalités legacy : utilisez math.div() au lieu de / pour la division, @use/@forward au lieu de @import, et les fonctions de modules sass:color/sass:math au lieu des lighten()/darken()/mix() globales. L'outil sass-migrator automatise ces migrations. Surveillez les avertissements de dépréciation pendant la compilation pour garder le code prêt pour le futur.

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.