larlet-fr-david-cache/cache/e2600a64d31f9684cf8711384bc7ac98/index.md

title: Bonnes pratiques en CSS : BEM et OOCSS
url: http://www.alsacreations.com/article/lire/1641-bonnes-pratiques-en-css-bem-et-oocss.html
hash_url: e2600a64d31f9684cf8711384bc7ac98

<p>
	Des années durant, j'ai intégré des sites Web et développé des applications JavaScript sans ressentir le besoin d'une méthodologie pour nommer les classes CSS. Puis, les projets grossissant, le code CSS est devenu douloureux…</p>
<p>
	L'épineux sujet du nommage en CSS est loin d'être fermé. Depuis le début de la décennie, plusieurs auteurs majeurs ont partagé leurs recherches. Ils ont apporté un regard nouveau et sont allés à contrecourant, en rupture avec ce qui faisait jusqu'alors consensus. Je raconte dans cet article mon propre cheminement dans leurs travaux en espérant qu'il sera utile à l'intégrateur Web autant qu'au développeur JavaScript. J'ai cherché en effet une approche adaptée à la fois aux pages et aux applications Web.</p>
<h3>
	Sommaire</h3>
<ol class="tdm">
	<li>
		<a href="#oocss">OOCSS</a></li>
	<li>
		<a href="#bem">BEM</a></li>
	<li>
		<a href="#pertinence-de-bem">Pertinence de BEM</a></li>
	<li>
		<a href="#une-syntaxe-bem-jolie">Une syntaxe BEM… jolie !</a></li>
	<li>
		<a href="#ingerences-transversales-et-oocss">Ingérences transversales et… OOCSS</a></li>
	<li>
		<a href="#cas-d-utilisation-partie-1-html">Cas d'utilisation, partie 1 : HTML</a></li>
	<li>
		<a href="#cas-d-utilisation-partie-2-css-avec-sass">Cas d'utilisation, partie 2 : CSS avec SASS</a></li>
	<li>
		<a href="#conclusion">Conclusion</a></li>
</ol>
<h3 id="oocss">
	OOCSS</h3>
<p>
	Je me suis d'abord tourné vers OOCSS (<em>Object Oriented CSS</em>), un ensemble de bonnes pratiques initiées par Nicole Sullivan (<a href="http://www.stubbornella.org/">Stubbornella</a>).</p>
<p>
	Le concept de OOCSS est de repérer des « objets CSS », c'est-à-dire des « patterns visuels » qui se répètent, et de définir ainsi des classes réutilisables. La méthode consiste à prendre le design comme point de départ : on repère des répétitions visuelles <em>puis</em> on les nomme. La sémantique du document n'est donc plus une base de travail, et des classes CSS nommées selon l'apparence sont autorisées à partir du moment où elles sont génériques. En cela, OOCSS est en décalage avec les bonnes pratiques des années 2000. L'ancien nommage par la sémantique préconisait des classes comme <code>.last-articles-box</code> ou <code>.comment-title</code>, alors qu'en OOCSS des classes <code>.links-box</code> ou <code>.tiny-title</code> seront préférées. Cela implique que le pilotage de l'apparence se fait depuis le code HTML. Ainsi, lorsqu'une feuille de styles écrite à la manière OOCSS est bien faite, il devient possible d'ajouter des morceaux entiers dans le design sans toucher à la feuille CSS, juste en réutilisant des objets CSS déjà existants.</p>
<p>
	OOCSS met en avant deux principes :</p>
<ol>
	<li>
		Le principe de séparation de la structure et de l'apparence ;</li>
	<li>
		Le principe de séparation du conteneur et du contenu.</li>
</ol>
<p>
	Le premier principe nous fera préférer, dans les sélecteurs CSS, les classes plutôt que des identifiants ou des noms d'éléments HTML. Il incite également à factoriser les propriétés visuelles répétées. Pour l'exemple, partons du code HTML suivant :</p>
<pre class="code">
<code class="html">&lt;button class="<b>small-btn</b>"&gt;&lt;/button&gt;
&lt;button class="<b>large-btn</b>"&gt;&lt;/button&gt;
</code></pre>
<p>
	Mieux vaut factoriser dans une classe <code>btn</code> les règles CSS communes aux deux boutons, ce qui donne :</p>
<pre class="code">
<code class="html">&lt;button class="<b>btn small-btn</b>"&gt;&lt;/button&gt;
&lt;button class="<b>btn large-btn</b>"&gt;&lt;/button&gt;
</code></pre>
<p>
	Le second principe consiste à éviter des cascades CSS comme <code>.links-box .title</code>, car l'apparence du contenu <code>.title</code> serait alors couplée au conteneur <code>.links-box</code>. Une classe <code>.box-title</code> sera plus réutilisable.</p>
<p>
	Je recommande au lecteur l'exposé de Nicole Sullivan : <a href="http://www.slideshare.net/stubbornella/our-best-practices-are-killing-us"><em>Our best practices are killing us</em></a>, publié en 2011. Cet exposé est formidable. Il a été, pour de nombreux intégrateurs, le point de départ d'une aventure OOCSS. Le lecteur désirant aller plus loin lira ensuite cette <a href="http://nicoespeon.com/fr/2013/05/plongee-au-coeur-de-oocss/">introduction à OOCSS</a> (en français) ainsi que le <a href="https://github.com/stubbornella/oocss/wiki">wiki du framework OOCSS</a>.</p>
<p>
	Mais OOCSS correspondait imparfaitement à mon besoin. Les designers avec lesquels je travaille conçoivent trop de variations entre chaque bloc. OOCSS ne donne pas des règles de construction nettes et fermes, et le temps passé à factoriser l'apparence peut dépasser le gain de la réutilisation. L'approche OOCSS aide certainement à afficher des milliers d'objets dans une plateforme tentaculaire comme Facebook, car le designer lui-même raisonne alors par objets. Elle reste globalement inappropriée pour intégrer un joli design monolithique fait sur mesure pour un site plus modeste. En outre, dans le cadre de la conception d'une application JavaScript, le découpage de l'interface ne devrait pas être fait par l'apparence, les ressemblances entre composants différents étant toujours superficielles et amenées à diverger.</p>
<p>
	Quoi qu'il en soit, les nouvelles bonnes pratiques de OOCSS font prendre conscience que l'ancien nommage par la seule sémantique est obsolète dans la mesure où il nous fait produire du code CSS non-réutilisable. Mettons OOCSS de côté pour le moment, nous y reviendrons plus tard.</p>
<figure class="center">
	<img alt="Design des Halles de Paris, 1863, par Victor Baltard [Source: Wikipedia]" src="/xmedia/doc/full/Design_des_Halles_de_Paris,_1863,_par_Victor_Baltard_[Source:_Wikipedia].jpg"/> <figcaption>La méthode consiste à prendre le design comme point de départ… [Design des Halles de Paris, 1863, par Victor Baltard, Wikipédia]</figcaption></figure>
<h3 id="bem">
	BEM</h3>
<p>
	La méthodologie BEM est une solution élaborée par Yandex et publiée en 2010. BEM a deux faces : il s'agit d'abord d'une méthode déclarative de l'interface utilisateur servant à décrire un « arbre BEM », les outils <em>open source</em> de Yandex travaillent ensuite sur cet arbre. BEM apporte également une convention de nommage des classes CSS qui a gagné une certaine popularité. C'est de cette méthodologie du nommage, véritablement puissante, que nous allons parler ici.</p>
<p>
	BEM est l'acronyme de <em>Block, Element, Modifier</em>, et toute la méthodologie du nommage à la manière BEM tient dans ces trois mots. La force du concept ? Ce qui compose un page ou une application Web peut toujours être rangé dans une arborescence de blocs, d'éléments et de modificateurs.</p>
<p>
	Un <strong>bloc</strong> est une entité indépendante, une « brique » de l'application ou de la page Web. Un bloc forme son propre contexte autonome. Ci-dessous des exemples de blocs dans une illustration tirée du site officiel :</p>
<figure class="center">
	<img alt="Logo, Onglets, Formulaires, etc." src="/xmedia/doc/full/bem-blocks-540.jpg"/> <figcaption>Des blocs BEM [source : <a href="http://bem.info/method/definitions/#Unified-Data-Domain">bem.info</a>]</figcaption></figure>
<p>
	Un <strong>élément</strong> est une partie d'un bloc. Le contexte d'un élément est celui du bloc. Ci-dessous deux exemples empruntés toujours au site officiel :</p>
<figure class="center">
	<img alt="Champ Input, Button" src="/xmedia/doc/full/bem-elements-540.jpg"/> <figcaption>Des éléments BEM [source : <a href="http://bem.info/method/definitions/#Element">bem.info</a>]</figcaption></figure>
<p>
	En tant que « brique de construction », un bloc est réutilisable dans d'autres blocs ou dans des éléments. Il ne connait toutefois que son propre contexte et non celui du parent. Un bloc n'est donc pas livré avec les règles CSS de son propre positionnement au sein du conteneur parent. Nous éclaircirons ultérieurement, sur un cas d'utilisation, ce point important.</p>
<p>
	Un <strong>modificateur</strong> est une propriété qui sert à créer des variantes, pour faire des modifications minimes comme changer des couleurs. Il existe des modificateurs de blocs et des modificateurs d'éléments.</p>
<p>
	La méthodologie BEM établit ensuite trois règles essentielles :</p>
<ol>
	<li>
		Les blocs et les éléments doivent chacun avoir un nom unique, lequel sera utilisé comme classe CSS ;</li>
	<li>
		Les sélecteurs CSS ne doivent pas utiliser les noms des éléments HTML (pas de <code>.menu td</code>) ;</li>
	<li>
		Les cascades dans les sélecteurs CSS devraient être évitées.</li>
</ol>
<p>
	À propos de la première règle, précisons que les identifiants HTML (les attributs <code>id</code>) ne doivent pas être utilisés en CSS, chaque bloc pouvant par principe être instancié plusieurs fois. Les identifiants HTML ne servent que d'ancres. La deuxième règle est nécessaire dans la mesure où les blocs peuvent être imbriqués. Un sélecteur <code>.menu td</code> briserait la séparation des contextes en interagissant avec les balises <code>&lt;td&gt;</code> des sous-blocs, cela doit être évité.</p>
<p>
	Ces règles impliquent de préfixer les noms des éléments par leur contexte. Venons-en à la convention de nommage des classes CSS. Le site officiel prend soin de préciser que seuls comptent les concepts, la syntaxe restant libre. L'équipe de BEM utilise pour sa part une syntaxe à base de <em>underscores</em> :</p>
<ul>
	<li>
		<code>block-name</code></li>
	<li>
		<code>block-name_modifier_name</code></li>
	<li>
		<code>block-name__element-name</code></li>
	<li>
		<code>block-name__element-name_modifier_name</code></li>
</ul>
<p>
	Pouah ! Hideux ! La raison d'une telle laideur est un manque de caractères utilisables dans les identifiants en CSS.</p>
<p>
	Le code CSS, en méthodologie BEM, est presque plat. Voici un exemple de code CSS pour un bloc <code>search-box</code> doté d'un modificateur <code>light</code>, contenant un élément <code>btn</code> avec un modificateur <code>max_visible</code> :</p>
<pre class="code">
<code class="css">.<b>search-box</b> {
  height: 300px;
  width: 300px;
}
.search-box_<b>light</b> {
  background-color: #DEF;
  color: #777;
}
.search-box__<b>btn</b> {
  padding: 4px;
}
.search-box__btn_<b>max_visible</b> {
  font-weight: bold;
}
</code></pre>
<p>
	Le code HTML :</p>
<pre class="code">
<code class="html">&lt;div class="<b>search-box</b> search-box_<b>light</b>"&gt;
  &lt;!-- (input field here) --&gt;
  &lt;button class="search-box__<b>btn</b> search-box__btn_<b>max_visible</b>"&gt;Search&lt;/button&gt;
&lt;/div&gt;
</code></pre>
<p>
	Une cascade est utilisée lorsqu'un modificateur de bloc a un effet sur un élément :</p>
<pre class="code">
<code class="css">.search-box_<b>light</b> .search-box__<b>btn</b> {
  background-color: #9AB;
}
</code></pre>
<p>
	Signalons entre parenthèses que cette cascade est à éviter sur les blocs pouvant s'imbriquer récursivement, car le modificateur du bloc parent affecterait alors les blocs enfants. Fort heureusement le cas est rare.</p>
<p>
	Nous n'en avons pas terminé avec BEM. Dans la suite de l'article cependant nous nous écarterons de la syntaxe et même de la terminologie originale. Je suggère au lecteur intéressé par l'orthodoxie : la <a href="http://bem.info/method/definitions/">présentation officielle de la méthodologie BEM</a> dont sont tirées les deux illustrations, et un article sur <a href="http://www.smashingmagazine.com/2014/07/17/bem-methodology-for-small-projects/">l'utilisation de BEM dans de petits projets</a> (incluant la partie déclarative de l'arbre BEM).</p>
<h3 id="pertinence-de-bem">
	Pertinence de BEM</h3>
<p>
	BEM, c'est un peu le chic type au visage ingrat. Il a des qualités mais qu'est-ce qu'il est… LAID ! Je ne sais pas pour vous ? En ce qui me concerne, travailler sur un code qui me dégoute, ça, jamais !</p>
<p>
	Tout de même, juger sur l'apparence n'est pas bien. Donnons-lui une chance et regardons au moins ses avantages.</p>
<h4 id="la-proprete">
	La propreté</h4>
<p>
	En BEM, aucun risque d'aboutir à ce code-là :</p>
<pre class="code">
<code class="css">.my-aside-title {
  font-size: 1.5em; /* Je style mon titre, OK c'est propre */
}
.my-aside h2.my-aside-title {
  position: inherit; /* Ah merde, annulation d'une règle sur h2 prévue pour autre chose */
}
</code></pre>
<h4 id="la-performance">
	<img alt="Performance [source: all-free-photos.com]" class="left" src="/xmedia/doc/full/Performance_[source:_all-free-photos.com].jpg"/>La performance</h4>
<p>
	La performance concerne plus particulièrement les applications Web. Les navigateurs rangent les classes CSS dans une table de hachage globale au document, mais il serait trop couteux de créer des sous-tables pour les descendants au niveau de chaque élément HTML. Aussi, en CSS, seul le premier niveau de sélection est performant. Les cascades CSS, lorsqu'elles sont nombreuses, engendrent des problèmes de fluidité surtout sur les pages animées des applications Web.</p>
<p>
	BEM, en limitant drastiquement l'usage des cascades CSS, incite à élaborer des feuilles de styles performantes.</p>
<h4 id="la-scalability-et-une-architecture-par-composants">
	La <em>scalability</em> et une architecture par composants</h4>
<p>
	<img alt="Scalability [source: Wikipedia]" class="right" src="/xmedia/doc/full/Scalability_[source:_Wikipedia].jpg"/>Un bloc peut être placé n'importe où dans la page, ou encore apparaitre (être instancié) plusieurs fois. Cela est possible parce que ses règles CSS sont radicalement séparées de celles des autres blocs. Il est alors possible de construire des applications géantes tout en travaillant toujours à une échelle réduite : le contexte d'un bloc.</p>
<p>
	Un parallèle est à faire avec les « composants Web », lesquels seront les briques des futures applications JavaScript. Chaque composant Web embarquera ses propres règles CSS et son propre code JavaScript. La norme prévoit un <em>shadow DOM</em>, c'est-à-dire une <em>sandbox</em> qui encapsule une portion de DOM dans le but d'empêcher les sélecteurs CSS et les identifiants HTML d'interagir par erreur avec le reste du DOM. Aujourd'hui, tout le challenge des <i>frameworks</i> JavaScript est de s'adapter à cette manière de travailler.</p>
<p>
	Les blocs BEM correspondent bien à la philosophie du développement par composants. BEM donne pour les technologies d'aujourd'hui un format de nommage utilisable et une manière de travailler compatible avec celle de demain.</p>
<h3 id="une-syntaxe-bem-jolie">
	Une syntaxe BEM… jolie !</h3>
<p>
	D'un côté BEM en vaut la peine, de l'autre il n'est pas séduisant. Nous risquons le mariage de raison… Les lignes suivantes relatent une démarche qui m'a pris plusieurs mois.</p>
<p>
	HTML 5 est venu avec une bonne et une mauvaise nouvelle. La bonne nouvelle, c'est qu'il est désormais possible d'utiliser <a href="http://www.whatwg.org/specs/web-apps/current-work/multipage/dom.html#classes">n'importe quel caractère</a> dans les identifieurs des attributs <code>class</code> et <code>id</code>. Et la mauvaise nouvelle, c'est que… pas en CSS. Un auteur Belge a dressé <a href="http://mathiasbynens.be/notes/css-escapes#css">la liste des caractères</a> qui ont un sens spécial en CSS et qu'il faut donc échapper : <code>!</code>, <code>"</code>, <code>#</code>, <code>$</code>, <code>%</code>, <code>&amp;</code>, <code>'</code>, <code>(</code>, <code>)</code>, <code>*</code>, <code>+</code>, <code>,</code>, <code>-</code>, <code>.</code>, <code>/</code>, <code>:</code>, <code>;</code>, <code>&lt;</code>, <code>=</code>, <code>&gt;</code>, <code>?</code>, <code>@</code>, <code>[</code>, <code>\</code>, <code>]</code>, <code>^</code>, <code>`</code>, <code>{</code>, <code>|</code>, <code>}</code> et <code>~</code>. Échapper n'est pas une option, on ne va pas remplacer une laideur par une autre.</p>
<p>
	Il reste alors deux caractères de séparation : le trait d'union (<code>-</code>) qu'une règle spéciale permet d'utiliser dans un identifieur sauf en première position, et le <i>underscore</i> (<code>_</code>).</p>
<p>
	Aïe.</p>
<p>
	Bloqué.</p>
<p>
	Prenons le problème autrement. La norme en CSS dit ceci :</p>
<blockquote>
	All CSS syntax is case-insensitive within the ASCII range […], except for parts that are not under the control of CSS. For example, the case-sensitivity of values of the HTML attributes "id" and "class" […] (<a href="http://www.w3.org/TR/CSS21/syndata.html#characters">Source : W3C</a>).</blockquote>
<p>
	La casse est donc utilisable. À titre personnel je rechignais un peu. J'ai toujours nommé mes classes CSS en minuscules avec des traits d'union, tous les gens bien font comme cela. Mais ici il faut sacrifier quelque chose. Accepter un séparateur illisible et moche ? Plutôt mourir ! S'assoir sur la norme ? Bon j'avoue avoir envisagé un temps une utilisation irrégulière du tilde (<code>~</code>)… Mais quoi ! La casse est valide, on l'utilise ailleurs en programmation, zut alors ! À cœur vaillant rien d'impossible, tant pis pour la tradition.</p>
<p>
	Une syntaxe BEM basée sur la casse est décrite par Nicolas Gallagher dans son mémorable article : <a href="http://nicolasgallagher.com/about-html-semantics-front-end-architecture/"><em>About HTML semantics and front-end architecture</em></a>, 2012. L'auteur en fait usage dans son framework <em>SUIT CSS</em>. La voici :</p>
<ul>
	<li>
		<code>ComponentName</code></li>
	<li>
		<code>ComponentName--modifierName</code></li>
	<li>
		<code>ComponentName-descendantName</code></li>
	<li>
		<code>ComponentName.is-stateOfComponent</code></li>
</ul>
<p>
	On l'aura compris, les composants sont les blocs et les descendants sont les éléments. La terminologie de BEM est ambigüe car « bloc » en CSS est aussi un type de flux d'affichage (l'opposé de « en ligne ») et « élément » désigne une balise HTML et son contenu. Aussi, adoptons définitivement les termes « composant » et « descendant ». Un <strong>composant CSS</strong> évoque en effet avec justesse l'idée d'encapsulation du composant Web, et un <strong>descendant</strong> en est effectivement un dans l'arbre DOM. Un composant Web pouvant embarquer plusieurs composants CSS, je préfère accoler ainsi « CSS » afin de les distinguer.</p>
<p>
	La syntaxe de l'état est intéressante : un simple point de séparation. C'est la syntaxe du sélecteur pour deux classes affectées à un même élément HTML. Ce sélecteur est devenu utilisable depuis que Windows XP et donc Internet Explorer 6 ont été abandonnés. Ci-dessous un exemple de bloc <code>MenuBtn</code> marqué avec l'état <code>current</code> en syntaxe SUIT CSS :</p>
<pre class="code">
<code class="html">&lt;button class="<b>MenuBtn</b> <b>is-current</b>"&gt;Open&lt;/button&gt;
</code></pre>
<p>
	En revanche, la syntaxe des modificateurs oblige encore, à l'instar de celle originale de BEM, à de lourdes répétitions. Car la classe CSS d'un modificateur est déclarée <em>en plus</em> de celle du composant CSS. Voici comment s'écrira un bouton doté des modificateurs <code>big</code> et <code>darkBlue</code> :</p>
<pre class="code">
<code class="html">&lt;button class="<b>MenuBtn</b> MenuBtn--<b>big</b> MenuBtn--<b>darkBlue</b>"&gt;Open&lt;/button&gt;
</code></pre>
<p>
	Pourquoi le principe de la double classe n'a-t-il pas été retenu pour les modificateurs ? L'auteur m'a répondu : « It helps keep specificity low » (« Ça aide à garder basse la spécificité »). Et c'est une réalité. La <a href="http://www.w3.org/TR/CSS21/cascade.html#specificity">spécificité CSS</a> est une mesure de la priorité d'un sélecteur CSS. Par exemple, le code suivant affichera en bleu les éléments ayant les deux classes <code>c1</code> et <code>c2</code>, car la spécificité de <code>.c1.c2</code> est plus élevée que celle de <code>.c1</code> :</p>
<pre class="code">
<code class="css">.c1.c2 {
  color: blue;
}
.c1 {
  color: red;
}
</code></pre>
<p>
	Toutefois, si <code>c1</code> était le nom du composant CSS et <code>c2</code> celui d'un modificateur, alors une spécificité plus haute pour le modificateur aurait du sens. Le but d'un modificateur n'est-il pas précisément de surcharger les règles d'affichage de base du composant ?</p>
<p>
	En outre, sur le plan de la performance, sélectionner simultanément deux classes CSS revient à faire l'intersection des résultats de deux sélections simples. La complexité, au sens algorithmique du terme, reste dans le même ordre de grandeur. Par conséquent la sélection simultanée de deux classes CSS est performante.</p>
<p>
	Voici alors la convention de nommage que je propose à mon tour, dérivée de celle de SUIT CSS, dérivée de BEM :</p>
<ul>
	<li>
		<code>ComponentName</code></li>
	<li>
		<code>ComponentName.modifierName</code></li>
	<li>
		<code>ComponentName-descendantName</code></li>
	<li>
		<code>ComponentName-descendantName.modifierName</code></li>
	<li>
		<code>ComponentName.isStateOfComponent</code></li>
</ul>
<p>
	J'ai gardé l'idée d'une convention pour un état booléen. Mais, visuellement, un état n'est rien d'autre qu'un modificateur spécial et je l'ai donc intégré dans la syntaxe des modificateurs. Voici un exemple de code HTML contenant de surcroit un descendant <code>keyword</code> :</p>
<pre class="code">
<code class="html">&lt;button class="<b>MenuBtn</b> <b>big</b> <b>darkBlue</b> <b>isCurrent</b>"&gt;
  Open the &lt;b class="MenuBtn-<b>keyword</b>"&gt;archives&lt;/b&gt;
&lt;/button&gt;</code></pre>
<p>
	Il arrive qu'une classe ne s'applique que sur certains types d'écrans. Un simple suffixe en majuscules fera ressortir cette caractéristique. Par exemple le modificateur <code>stickyMT</code> s'appliquera sur les écrans des mobiles et des tablettes seulement. Je compose pour ma part les suffixes avec <code>D</code> (<em>desktop</em>), <code>T</code> (<em>tablet</em>) et <code>M</code> (<em>mobile</em>). En cas d'écrans multiples, ordonner alphabétiquement.</p>
<h3 id="ingerences-transversales-et-oocss">
	Ingérences transversales et… OOCSS</h3>
<p>
	La méthodologie BEM apporte une solide séparation entre les contextes CSS des différents composants CSS. Pourtant, tous ces contextes reposent en définitive sur du sable mouvant. Les composants supposent en effet toujours un certain contexte CSS global, comme l'existence d'un <em>reset CSS</em> pour annuler les marges ou encore le fait qu'une balise <code>&lt;strong&gt;</code> affiche par défaut son contenu en gras.</p>
<p>
	Et il est à mon avis justifié de jouer volontairement sur la corde transversale en marquant des éléments du DOM avec des classes ne respectant pas l'arborescence des composants CSS. Ainsi, un site réutilisant des patterns visuels globaux à la façon OOCSS fera dépendre de classes CSS transversales des propriétés décoratives. Dans une application JavaScript, un service du support multilingue peut travailler de manière transversale sur des libellés disposant de traductions.</p>
<p>
	Pour ces marqueurs transversaux, je propose d'utiliser un préfixe commençant par une lettre minuscule et se terminant par le premier trait d'union : <code>myPrefix-…</code>. Par exemple un <em>objet CSS</em> aux propriétés décoratives : <code>ob-prettyBox</code> ; un libellé dont le contenu est modifiable par un service multilingue transversal : <code>lang-localizableLabel</code>. Pas de convention pour ce qui suit le préfixe : <code>lang-LocalizableLabel</code> ou encore <code>lang-localizable-label</code> au bon vouloir du concepteur.</p>
<p>
	Nota. — Les ingérences transversales sortent de l'orthodoxie BEM.</p>
<h4 id="a-propos-d-objets-css">
	À propos d'objets CSS</h4>
<p>
	Parmi les objets CSS valides en OOCSS, distinguons ceux purement décoratifs de ceux qui organisent l'interface utilisateur.</p>
<p>
	Les objets CSS décoratifs qui se limitent aux propriétés sans effet sur le flux d'affichage, comme les couleurs, les ombres, les coins arrondis, sont à consommer sans modération. Cependant, la mise en commun de propriétés décoratives peut aller plus loin. S'il apparait que la moitié des composants CSS partagent un <code>padding</code> de dix pixels et une bordure de deux pixels, pourquoi ne pas définir une classe transversale <code>ob-commonBox</code> ? Grâce aux objets CSS, nous ne sommes plus limités à un seul contexte CSS global, nous pouvons créer de multiples contextes CSS globaux. Ils seront ensuite affectés aux composants ou descendants, et joueront le rôle d'habillage par défaut.</p>
<p>
	Quant aux objets CSS qui structurent l'interface utilisateur, à l'instar du <em><a href="http://www.stubbornella.org/content/2010/06/25/the-media-object-saves-hundreds-of-lines-of-code/">media object</a></em>, leur usage coïncide avec celui des composants CSS. Une syntaxe BEM devrait alors être préférée. Ensuite, lorsqu'il s'agit de délimiter nos composants CSS à partir d'un design, l'approche OOCSS consistant à repérer des répétitions de patterns visuels est excellente.</p>
<h3 id="cas-d-utilisation-partie-1-html">
	Cas d'utilisation, partie 1 : HTML</h3>
<p>
	Un peu de pratique pour fixer les idées. Nous allons élaborer un modèle de page innovant pour un blog. Admirez la beauté :</p>
<figure class="center">
	<p>
		<img alt="Template de blog" src="/xmedia/doc/full/blog-template-540.jpg"/></p>
</figure>
<p>
	Quatre grands composants CSS se distinguent aisément : <code>SiteHeader</code> pour l'en-tête, <code>MainContent</code> l'article principal en blanc, <code>Sidebar</code> la barre latérale et <code>SiteFooter</code> le pied de page.</p>
<p>
	Nous avons également besoin d'un composant <code>PageWrapper</code> pour centrer la page et lui fixer une largeur, et <code>BodyLayout</code> le conteneur de l'article principal et de la barre latérale. Intéressons-nous au code HTML de ce dernier :</p>
<pre class="code">
<code class="html">  &lt;div class="BodyLayout"&gt;
    &lt;main class="BodyLayout-<b>mainContent</b>"&gt;
      &lt;article class="<b>MainContent</b>"&gt;&lt;!-- Content here… --&gt;&lt;/article&gt;
    &lt;/main&gt;
    &lt;div class="BodyLayout-<b>sidebar</b> <b>Sidebar</b>"&gt;&lt;!-- Widgets here… --&gt;&lt;/div&gt;
  &lt;/div&gt;
</code></pre>
<p>
	En tant que composants CSS, <code>MainContent</code> et <code>Sidebar</code> ne doivent pas contenir leur propre positionnement. Aussi seront-ils positionnés par des conteneurs <code>mainContent</code> et <code>sidebar</code> (notez bien les premières lettres minuscules qui distinguent les descendants des composants). Et dans le cas de la barre latérale, le descendant <code>sidebar</code> et le composant <code>Sidebar</code> sont associés au même élément HTML. Cela est autorisé par BEM : on dit alors du nœud du DOM qu'il est un <em>mix</em> des deux.</p>
<p>
	Les <em>mix</em> sont pratiques dans le cas d'un modèle de page Web car ils économisent des balises HTML. Ils impliquent toutefois une plus grande rigueur dans les CSS, comme nous le verrons dans la section suivante.</p>
<p>
	Voici le code HTML complet :</p>
<pre class="code">
<code class="html">&lt;!DOCTYPE html&gt;
&lt;html&gt;
&lt;head&gt;
  &lt;link rel="stylesheet" href="hello-bem.css"&gt;
&lt;/head&gt;
&lt;body&gt;
&lt;div class="<b>PageWrapper</b>"&gt;
  &lt;header class="<b>SiteHeader</b>"&gt;
    &lt;a class="SiteHeader-<b>titles</b>" href="/"&gt;
      &lt;p class="SiteHeader-<b>h1</b>"&gt;Hello, World!&lt;/p&gt;
      &lt;p class="SiteHeader-<b>h2</b>"&gt;BEM is sooo handy&lt;/p&gt;
    &lt;/a&gt;
  &lt;/header&gt;
  &lt;div class="<b>BodyLayout</b>"&gt;
    &lt;main class="BodyLayout-<b>mainContent</b>"&gt;
      &lt;article class="<b>MainContent</b> <b>ob-formattedText</b>"&gt;&lt;p&gt;Main content here&lt;/p&gt;&lt;/article&gt;
    &lt;/main&gt;
    &lt;div class="BodyLayout-<b>sidebar</b> <b>Sidebar</b>"&gt;
      &lt;ul&gt;
        &lt;li class="Sidebar-<b>li</b>"&gt;&lt;aside class="<b>SmallBox</b> <b>sticky</b>"&gt;Widget 1&lt;/aside&gt;&lt;/li&gt;
        &lt;li class="Sidebar-<b>li</b>"&gt;&lt;aside class="<b>SmallBox</b>"&gt;Widget 2&lt;/aside&gt;&lt;/li&gt;
      &lt;/ul&gt;
    &lt;/div&gt;
  &lt;/div&gt;
  &lt;footer class="<b>SiteFooter</b>"&gt;Something about copies here&lt;/footer&gt;
&lt;/div&gt;
</code></pre>
<p>
	Du texte formaté pourrait apparaitre dans plusieurs composants CSS différents, il fait donc l'objet d'une classe transversale <code>ob-formattedText</code>. Notons également la présence du modificateur <code>sticky</code> sur la première des deux instances du composant <code>SmallBox</code>.</p>
<h4 id="discussion-html">
	Discussion HTML</h4>
<p>
	Deux sujets méritent une attention particulière. Premièrement, constatons que les arbres BEM et DOM ne coïncident pas en tout point. Nous avons des descendants frères : <code>SiteHeader-titles</code>, <code>SiteHeader-h1</code> et <code>SiteHeader-h2</code>, tous trois sont des enfants du composant <code>SiteHeader</code> alors que dans l'arbre DOM les deux derniers sont des enfants du premier. Autre exemple : le descendant <code>BodyLayout-sidebar</code> est le parent du composant <code>Sidebar</code> dans l'arbre BEM alors que dans le DOM il s'agit du même élément.</p>
<p>
	Ensuite, certains morceaux de HTML peuvent être au choix des descendants ou des composants. Pour déterminer quel est le meilleur choix, la question n'est pas : « Cette chose-là a-t-elle du sens indépendamment du reste ? » L'en-tête d'un article, contenant le titre et la date de publication, perdrait son sens s'il était séparé du corps de l'article. Il mérite pourtant souvent d'être un composant car la question à se poser est plutôt : « A-t-on besoin de créer un contexte (d'apparence) à ce niveau ? » Et en effet, la zone de titre d'un article, surtout si elle est complexe, mérite d'être un composant. Cela permettra, par exemple, de la déplacer sous le corps de l'article le jour où ce dernier deviendra une vidéo.</p>
<p>
	En cas d'indécision, la règle que je suggère est de faire au plus simple. Dans le code HTML au-dessus, le descendant <code>SiteHeader-titles</code> pourrait être un composant <code>SiteTitles</code>. Dans la mesure où le composant englobant <code>SiteHeader</code> est presque vide, j'ai préféré utiliser son contexte. Mais le jour où nous lui ajouterons d'autres enfants, il deviendra plus pratique de créer un contexte composant à part pour les titres du site.</p>
<h3 id="cas-d-utilisation-partie-2-css-avec-sass">
	Cas d'utilisation, partie 2 : CSS avec SASS</h3>
<p>
	Dans cette partie, je vais utiliser le préprocesseur SASS avec sa variante syntaxique SCSS. SASS autorise les imbrications et depuis la version 3.3 sortie cette année elles fonctionnent même sur des noms composés.</p>
<p>
	En SASS, le <code>&amp;</code> représente le sélecteur du bloc de déclarations parent. Un exemple de code SCSS :</p>
<pre class="code">
<code class="css"><b>.Sidebar</b> {
  background-color: #998;
  min-height: 160px;
  padding: 20px 0;
  &amp;<b>-li</b> {
    margin-bottom: 10px;
    padding: 0 20px;
  }
}
</code></pre>
<p>
	… Après compilation par SASS, le code CSS généré est le suivant :</p>
<pre class="code">
<code class="css"><b>.Sidebar</b> {
  background-color: #998;
  min-height: 160px;
  padding: 20px 0
}
<b>.Sidebar-li</b> {
  margin-bottom: 10px;
  padding: 0 20px
}
</code></pre>
<p>
	Remarquez la réutilisation du sélecteur parent <code>.Sidebar</code> pour composer celui de l'enfant <code>.Sidebar-li</code>. Simple et nette.</p>
<p>
	Reprenons maintenant notre <em>mix</em> du descendant <code>BodyLayout-sidebar</code> et du composant <code>Sidebar</code>. Surtout ne vous laissez pas embrouiller. Cette explication est réellement facile. Il n'y a à chaque fois qu'un simple pattern de deux niveaux de hiérarchie, lequel se répète de manière imbriquée.</p>
<p>
	Dans l'arbre BEM, <code>BodyLayout-sidebar</code> est le conteneur de <code>Sidebar</code>. La règle CSS du composant <code>Sidebar</code> régit l'intérieur de la barre latérale, elle a été donnée plus haut. Le positionnement échoit au conteneur dont voici la règle :</p>
<pre class="code">
<code class="css">.BodyLayout-sidebar {
  float: right;
  width: 25%;
}
</code></pre>
<p>
	La largeur du conteneur est définie en pourcentage : <code>25%</code>. Celle du composant <code>Sidebar</code> est indéfinie, ce dernier prendra donc automatiquement la largeur allouée par le conteneur. Rappelons-nous que, dans le cas qui nous préoccupe, le composant et son conteneur sont en réalité le même élément HTML. Or, en CSS, un <em>padding</em> à gauche ou à droite, ou encore une bordure, s'ajoute à la largeur prise par l'élément HTML. Voilà pourquoi un <em>mix</em> demande de la rigueur : ici le composant ne doit pas utiliser ces propriétés CSS sous peine d'agrandir son propre conteneur.</p>
<p>
	Si l'on ne peut contrôler les règles CSS qui s'appliquent sur un composant, comme cela est le cas, notamment, dans une application JavaScript modulaire, alors mieux vaut éviter les <em>mix</em> en dissociant dans le DOM les descendants et les composants.</p>
<p>
	Le contenu complet du fichier <code>hello-bem.scss</code> :</p>
<pre class="code">
<code class="css">@charset "UTF-8";
// Reset CSS (partial)
html, body, div, p, a, ul, li, footer, header, main {
  border: 0;
  font: inherit;
  margin: 0;
  padding: 0;
  vertical-align: baseline;
}
body {
  line-height: 1;
}
ul {
  list-style: none;
}
// CSS Objects
<b>.ob-formattedText</b> {
  p {
    margin-bottom: .5em;
  }
}
// CSS Components
body {
  background-color: #EEB;
}
<b>.PageWrapper</b> {
  background-color: #CCC;
  margin: 0 auto;
  width: 750px;
}
<b>.SiteHeader</b> {
  height: 120px;
  position: relative;
  &amp;<b>-titles</b> {
    display: inline-block;
    left: 80px;
    position: absolute;
    top: 20px;
  }
  &amp;<b>-h1</b> {
    font-size: 3em;
    font-weight: bold;
  }
  &amp;<b>-h2</b> {
    font-size: 1.5em;
    font-style: italic;
  }
}
<b>.BodyLayout</b> {
  &amp;<b>-mainContent</b> {
    float: left;
    width: 73%;
  }
  &amp;<b>-sidebar</b> {
    float: right;
    width: 25%;
  }
  &amp;::after {
    clear: both;
    content: "";
    display: block;
  }
}
<b>.MainContent</b> {
  background-color: #FFF;
  min-height: 160px;
  padding: 20px 40px;
}
<b>.Sidebar</b> {
  background-color: #998;
  min-height: 160px;
  padding: 20px 0;
  &amp;<b>-li</b> {
    margin-bottom: 10px;
    padding: 0 20px;
  }
}
<b>.SmallBox</b> {
  background-color: #665;
  color: #fff;
  line-height: 50px;
  text-align: center;
  &amp;<b>.sticky</b> {
    font-weight: bold;
  }
}
<b>.SiteFooter</b> {
  line-height: 2em;
  text-align: center;
}
</code></pre>
<h4 id="discussion-css">
	Discussion CSS</h4>
<p>
	Intéressons-nous tout d'abord à l'objet CSS <code>ob-formattedText</code>. Il est fait pour habiller des textes provenant d'un éditeur WYSIWYG. En situation réelle, il accueillera l'ensemble des règles d'affichage des éléments de formatage : du paragraphe aux listes à puces en passant par les sous-titres. Puisque les noms des balises HTML apparaissent directement, la séparation des contextes pour les éventuels sous-blocs est brisée. Cela n'est pas conforme à BEM mais il faut bien faire avec la réalité. Seuls des sous-blocs « résistants aux formatages » comme des médias devront être autorisés à l'intérieur de cet objet CSS.</p>
<p>
	Un mot encore à propos du positionnement. Le principe général est que les composants CSS et leurs modificateurs ne contiennent pas leur propre positionnement dans leur conteneur. Cela implique, la plupart du temps, de ne définir aucune marge sur l'élément HTML du composant (attention à la fusion des marges) et de ne toucher à aucune propriété qui influencerait le positionnement du composant dans son conteneur.</p>
<p>
	Ce principe n'est pas absolu. Le vrai principe sous-jacent est la réutilisation. Un positionnement est utilisé à bon escient dès qu'il fait partie intégrante du composant et ne gène donc aucunement sa réutilisation. Par exemple, le composant <code>PageWrapper</code> dans le code donné ci-dessus contient son propre positionnement centré. Ou encore, un composant <code>InlineFig</code> encapsulant une image avec sa légende, à l'intérieur d'un texte formaté, sera aligné en flottant à gauche ou à droite au moyen d'un modificateur :</p>
<pre class="code">
<code class="css">.InlineFig {
  &amp;.alignLeft {
    float: left;
    margin: 10px 10px 10px 0;
  }
  &amp;.alignRight {
    float: right;
    margin: 10px 0 10px 10px;
  }
}
</code></pre>
<h3 id="conclusion">
	Conclusion</h3>
<p>
	Tant que sera respecté le principe d'une séparation rigoureuse entre les contextes des composants CSS, BEM fournira une robuste armature à nos pages Web et à nos applications JavaScript. Mais le Web autorise également des manipulations transversales puissantes. Les objets CSS décoratifs et les traitements en JavaScript travaillant en dehors de toute hiérarchie tirent parti des capacités si particulières des navigateurs, ne nous en privons pas.</p>
<p>
	Un parallèle parlera aux amateurs de langages à objets. Un composant CSS est un contexte, de la même manière qu'en programmation un objet en est un. À l'intérieur du composant, toutes sortes de descendants s'appuient sans façon les uns sur les autres, en programmation les membres privés d'un objet font de même. Vu depuis l'extérieur, le composant CSS apparait comme une « boite noire » réutilisable dont le mode d'implémentation n'importe plus. De telles considérations ont donné leur nom aux « objets CSS » de OOCSS.</p>
<p>
	Dans le cadre d'une application JavaScript, une bonne ergonomie fera toujours correspondre la ressemblance visuelle à une similitude du comportement programmé en JavaScript. Aussi, les règles CSS doivent être couplées au code JavaScript qui anime la portion du DOM concernée. Terminons alors sur les composants Web, ces briques de construction dans le domaine applicatif et non plus seulement visuel. Ils reposent sur quatre fonctionnalités utilisables séparément :</p>

<p>
	Le support par les navigateurs progresse vite. Les quatre sont implémentées par Chrome et Opera, Firefox est en train de suivre, l'équipe d'Internet Explorer <a href="http://status.modern.ie/">y réfléchit</a>. Safari, en revanche, <a href="http://jonrimmer.github.io/are-we-componentized-yet/#code">reste en dehors</a> de la course.</p>
<p>
	Avec l'avènement du <em>shadow DOM</em>, certains nœuds du DOM deviennent des points de montage pour des portions de DOM encapsulées. Le DOM acquiert, en quelque sorte, du volume. La taille d'une portion de DOM ainsi encapsulée n'a pas de limite, un composant Web peut embarquer toute une application ! À l'intérieur des <em>shadow DOM</em>, de même bien entendu que dans le DOM principal du document, une syntaxe BEM reste appropriée. Du point de vue CSS, le <em>shadow DOM</em> est un espace de nommage pour les composants CSS embarqués.</p>
<p>
	En nous offrant de raisonner « par composants » à tous les niveaux de l'habillage en CSS, la méthodologie BEM et ses syntaxes préfixées s'intègrent naturellement dans un environnement fait de composants Web. Elles sont à la fois le présent et le futur des bonnes pratiques en CSS.</p>
<p class="info">
	<em>26/08/2014 : Mise à jour sur l'état de l'implémentation des Web components par les navigateurs.</em><br/>
	<em>Publication originale <a href="http://tarh.developpez.com/articles/2014/bonnes-pratiques-en-css-bem-et-oocss/">sur Developpez.com</a>.</em></p>