📚 Cours SCSS (Sass) 📍 Chapitre 6 / 21

Partials et organisation des fichiers SCSS

Lorsque ton projet grandit, écrire tout ton SCSS dans un seul fichier devient vite ingérable. Ce chapitre t'apprend à découper ton code grâce aux partials et à organiser tes fichiers de manière professionnelle et maintenable. Tu vas découvrir comment structurer ton projet pour qu'il reste clair, même avec des centaines de lignes de code.

Objectifs du chapitre

  • Comprendre ce qu'est un partial SCSS et pourquoi l'utiliser.
  • Savoir découper un projet SCSS en plusieurs fichiers logiques.
  • Mettre en place une arborescence claire et professionnelle.
  • Organiser les imports dans le bon ordre.
  • Préparer le terrain pour les modules @use et @forward.
À retenir

Les partials servent à organiser le code source, pas à générer plusieurs fichiers CSS. Le résultat final reste généralement un seul fichier CSS bien structuré.

Explications théoriques détaillées

Qu'est-ce qu'un partial SCSS ?

Un partial est un fichier SCSS dont le nom commence par un underscore _. Cette convention indique à Sass que ce fichier ne doit pas être compilé seul en CSS.

STRUCTURE
_variables.scss
_buttons.scss
_layout.scss
_forms.scss
_typography.scss

Ces fichiers sont ensuite importés dans un fichier principal (souvent main.scss ou app.scss). Le compilateur Sass fusionne tous ces partials en un seul fichier CSS à la compilation.

Pourquoi organiser son SCSS en plusieurs fichiers ?

Comme mentionné au chapitre 1, un problème fréquent en CSS est d'avoir tout dans style.css, ce qui rend le code difficile à maintenir. Voici les avantages d'une organisation en partials :

  • Meilleure lisibilité : chaque fichier a une responsabilité claire.
  • Code plus facile à maintenir : tu modifies un composant sans toucher au reste.
  • Travail en équipe plus fluide : plusieurs personnes peuvent travailler sur des fichiers différents sans conflits.
  • Réutilisation simplifiée : tu peux récupérer des partials dans d'autres projets.
  • Chargement plus rapide : le navigateur ne télécharge qu'un seul fichier CSS final.
Conseil terrain

Un bon découpage de fichiers évite 80 % des problèmes de CSS "incompréhensible" sur les projets de moyenne et grande taille. C'est l'une des compétences les plus valorisées chez les développeurs front-end seniors.

Comment les partials fonctionnent-ils ?

Le processus est simple :

  1. Tu écris ton code SCSS dans plusieurs fichiers (partials) avec des noms explicites.
  2. Tu importes ces partials dans un fichier principal avec @import (ou @use pour la méthode moderne).
  3. Tu compiles uniquement le fichier principal avec Sass.
  4. Sass fusionne tous les partials en un seul fichier CSS optimisé.

Exemples simples

Exemple 1 : Structure minimale avec partials

Commençons avec une structure simple pour un petit projet :

STRUCTURE
scss/
  _variables.scss    # Variables globales
  _base.scss         # Styles de base (reset, body, etc.)
  main.scss          # Fichier principal (point d'entrée)

Le fichier main.scss sert de point d'entrée et importe tous les partials.

Exemple 2 : Contenu des fichiers avec imports

Voici ce que pourraient contenir ces fichiers :

_variables.scss :

SCSS
// Variables de couleurs
$primary: #3b82f6;
$secondary: #8b5cf6;
$success: #10b981;
$warning: #f59e0b;
$danger: #ef4444;

// Variables typographiques
$font-family: 'Inter', system-ui, sans-serif;
$font-size-base: 16px;
$line-height-base: 1.6;

// Variables d'espacement
$spacing-xs: 4px;
$spacing-sm: 8px;
$spacing-md: 16px;
$spacing-lg: 24px;
$spacing-xl: 32px;

// Variables de bordures
$border-radius: 8px;
$border-width: 1px;

_base.scss :

SCSS
// Reset et styles de base
* {
  box-sizing: border-box;
  margin: 0;
  padding: 0;
}

body {
  font-family: $font-family;
  font-size: $font-size-base;
  line-height: $line-height-base;
  color: #1e293b;
  background-color: #f8fafc;
}

// Liens
a {
  color: $primary;
  text-decoration: none;
  
  &:hover {
    text-decoration: underline;
  }
}

// Images responsives
img {
  max-width: 100%;
  height: auto;
}

main.scss :

SCSS
// Import des partials (ordre important !)
@import 'variables';
@import 'base';

// Styles spécifiques au projet
.container {
  max-width: 1200px;
  margin: 0 auto;
  padding: 0 $spacing-md;
}

.header {
  background: white;
  box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
  padding: $spacing-lg 0;
}
Note importante

Ici, nous utilisons encore @import pour la compréhension, car c'est la méthode la plus intuitive pour débuter. Les alternatives modernes @use et @forward seront expliquées en détail au chapitre suivant.

Exemple 3 : CSS généré final

Après compilation, voici ce que donnerait le fichier CSS final (extrait) :

CSS
/* Contenu de _variables.scss compilé */
/* Contenu de _base.scss compilé */

* {
  box-sizing: border-box;
  margin: 0;
  padding: 0;
}

body {
  font-family: 'Inter', system-ui, sans-serif;
  font-size: 16px;
  line-height: 1.6;
  color: #1e293b;
  background-color: #f8fafc;
}

a {
  color: #3b82f6;
  text-decoration: none;
}

a:hover {
  text-decoration: underline;
}

img {
  max-width: 100%;
  height: auto;
}

.container {
  max-width: 1200px;
  margin: 0 auto;
  padding: 0 16px;
}

.header {
  background: white;
  box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
  padding: 24px 0;
}

Comme tu peux le voir, tous les partials sont fusionnés en un seul fichier CSS propre et optimisé.

Exemples concrets et professionnels

Organisation par responsabilité (approche standard)

Pour des projets de taille moyenne, une organisation par "rôle" est très efficace :

STRUCTURE
scss/
  abstracts/          # Abstracts (outils, helpers)
    _variables.scss   # Variables globales
    _functions.scss   # Fonctions personnalisées
    _mixins.scss      # Mixins réutilisables
    _placeholders.scss # Placeholders pour @extend
  
  base/               # Styles de base
    _reset.scss       # Reset/Normalize
    _typography.scss  # Typographie
    _base.scss        # Styles globaux de base
  
  components/         # Composants réutilisables
    _buttons.scss     # Boutons
    _cards.scss       # Cartes
    _forms.scss       # Formulaires
    _modals.scss      # Modales
    _navigation.scss  # Navigation
  
  layout/             # Mise en page
    _header.scss      # En-tête
    _footer.scss      # Pied de page
    _sidebar.scss     # Sidebar
    _grid.scss        # Grille
    _sections.scss    # Sections spécifiques
  
  pages/              # Styles spécifiques aux pages
    _home.scss        # Page d'accueil
    _about.scss       # Page "À propos"
    _contact.scss     # Page contact
  
  themes/             # Thèmes (optionnel)
    _dark.scss        # Thème sombre
    _light.scss       # Thème clair
  
  vendors/            # Bibliothèques externes
    _bootstrap.scss   # Surcouche Bootstrap
    _fontawesome.scss # Styles Font Awesome
  
  main.scss           # Fichier principal

Cette structure est inspirée de l'architecture 7-1 pattern, une méthode éprouvée pour les projets SCSS de grande envergure.

Fichier principal organisé (point d'entrée)

Le fichier main.scss importe tous les partials dans un ordre logique :

SCSS
// Abstracts (outils) - doivent venir en premier
@import 'abstracts/variables';
@import 'abstracts/functions';
@import 'abstracts/mixins';
@import 'abstracts/placeholders';

// Base (fondations)
@import 'base/reset';
@import 'base/typography';
@import 'base/base';

// Composants réutilisables
@import 'components/buttons';
@import 'components/cards';
@import 'components/forms';
@import 'components/modals';
@import 'components/navigation';

// Layout (mise en page)
@import 'layout/header';
@import 'layout/footer';
@import 'layout/sidebar';
@import 'layout/grid';
@import 'layout/sections';

// Pages spécifiques
@import 'pages/home';
@import 'pages/about';
@import 'pages/contact';

// Thèmes
@import 'themes/dark';
@import 'themes/light';

// Vendors (bibliothèques externes)
@import 'vendors/bootstrap';
@import 'vendors/fontawesome';
Conseil terrain

L'ordre des imports est crucial ! Les abstracts (variables, mixins) doivent être importés en premier, car ils sont utilisés dans tous les autres fichiers. Ensuite viennent les bases, puis les composants, puis le layout, et enfin les styles spécifiques.

Structure simplifiée pour petits projets

Pour un site simple ou une application légère, une structure allégée suffit :

STRUCTURE
styles/
  _config.scss     # Variables et configuration
  _base.scss       # Styles de base
  _components.scss # Tous les composants
  _layout.scss     # Mise en page générale
  main.scss        # Point d'entrée

L'important est de trouver un équilibre : assez de fichiers pour être organisé, mais pas trop pour ne pas se perdre.

Bonnes pratiques

Règles d'or pour l'organisation SCSS

  • Un fichier = une responsabilité claire : chaque partial doit avoir un rôle précis et limité.
  • Utiliser des noms explicites : _buttons.scss plutôt que _btns.scss.
  • Éviter les fichiers trop longs : si un partial dépasse 200 lignes, envisage de le diviser.
  • Centraliser les variables globales : toutes les variables partagées dans un fichier dédié.
  • Documenter l'architecture : ajoute un README ou des commentaires pour expliquer ta structure.
  • Rester cohérent : une fois une structure choisie, applique-la systématiquement.
  • Ne pas hésiter à refactoriser : si ta structure devient inadaptée, réorganise avant que ce ne soit ingérable.
À retenir

Un bon découpage permet à n'importe quel développeur de comprendre un projet SCSS en quelques minutes, même sans l'avoir écrit. C'est un investissement en temps qui paie énormément à moyen et long terme.

Conventions de nommage

Adopte des conventions cohérentes pour tes noms de fichiers :

EXEMPLES
// Bonnes pratiques
_variables.scss      // Variables globales
_buttons.scss        // Composant au pluriel
_typography.scss     // Domaine fonctionnel
_header.scss         // Élément de layout

// À éviter
_styles.scss         // Trop vague
_btn.scss           // Abréviation
_typo.scss          // Abréviation
_head.scss          // Abréviation

Erreurs courantes

Erreur 1 : tout mettre dans un seul fichier

C'est acceptable pour un exercice ou un prototype, mais catastrophique pour un projet réel qui va évoluer. Un fichier unique de plusieurs milliers de lignes est extrêmement difficile à maintenir, déboguer et faire évoluer.

Attention

Même si ça semble plus simple au début, un gros fichier unique devient rapidement un "cauchemar de maintenance". Préfère toujours une organisation modulaire dès que le projet dépasse quelques centaines de lignes.

Erreur 2 : multiplier les partials inutiles

L'excès inverse est aussi problématique. Créer un fichier séparé pour seulement 10 lignes de code n'a pas de sens. Trop de fichiers tue la lisibilité et rend la navigation difficile.

Bon équilibre : un partial par composant majeur, par section de layout, ou par domaine fonctionnel (typographie, formulaires, etc.).

Erreur 3 : mauvais ordre d'import

Importer un composant avant ses variables ou mixins provoque des erreurs de compilation difficiles à comprendre. Sass lit les fichiers de haut en bas : ce qui est utilisé doit être défini avant.

SCSS (À ÉVITER)
// MAUVAIS ORDRE - ERREUR !
@import 'components/buttons';  // Utilise $primary-color
@import 'abstracts/variables'; // Définit $primary-color ici (trop tard !)

// BON ORDRE
@import 'abstracts/variables'; // Définition d'abord
@import 'components/buttons';  // Utilisation ensuite

Erreur 4 : oublier l'underscore dans les imports

Une erreur fréquente chez les débutants : inclure l'underscore dans l'instruction @import.

SCSS
// MAUVAIS
@import '_variables';

// BON
@import 'variables';

Sass comprend automatiquement que tu veux importer le fichier _variables.scss quand tu écris @import 'variables'.

Résumé du chapitre

Ce que vous avez appris
Les partials sont des fichiers SCSS préfixés par _ qui ne sont pas compilés seuls.
Ils permettent de découper un projet SCSS en fichiers logiques et maintenables.
L'organisation en partials améliore la lisibilité, la maintenabilité et le travail en équipe.
Le fichier principal (point d'entrée) importe tous les partials dans un ordre logique.
À la compilation, tous les partials sont fusionnés en un seul fichier CSS optimisé.

Prochain chapitre : Gestion des modules avec @use et @forward

Bien que @import soit encore largement utilisé, Sass a introduit des directives plus modernes et performantes. Dans le prochain chapitre, nous découvrirons @use et @forward, les nouvelles façons recommandées de gérer les imports en SCSS.

  • Comprendre les limites de @import et l'intérêt des nouvelles directives
  • Maîtriser @use pour importer des modules avec espace de noms
  • Utiliser @forward pour réexporter des partials
  • Configurer les imports avec des options avancées
  • Migrer progressivement de @import vers @use