Как испортить CSS. Антипаттерны

Frontend

CSS — самый миролюбивый язык в вебе. Он не ругается, не выбрасывает ошибок, не ломает сборку. Он просто молча игнорирует то, что не понял, и применяет то, что смог. Из-за этого в больших проектах CSS склонен превращаться в свалку из !important, вложенности на десять уровней и магических чисел, которые никто не может объяснить.

Сегодня разберём три классических способа испортить CSS так, чтобы с ним не хотелось иметь дела.

Антипаттерн 1: !important вместо нормальной специфичности

Плохо

.button {
    background: blue;
}
.sidebar .button {
    background: green;
}
.sidebar .button.special {
    background: red !important;
}
/* А потом кто-то добавляет */
.sidebar .button.special.active {
    background: yellow !important; /* не работает, потому что предыдущий !important победил */
}
/* И ещё один */
.sidebar .button.special.active:hover {
    background: purple !important !important; /* так нельзя, но попытка засчитана */
}

!important — это запрещенный прием CSS. Он говорит: «Это правило должно победить всё». Проблема в том, что когда !important встречается с другим !important, побеждает тот, кто ниже в файле или более специфичен. Начинается гонка: каждый новый стиль требует !important, чтобы перебить предыдущий.

Через месяц ваш CSS выглядит ужасно, а вносить новые правки и рефакторить стили уже страшновато.

Что ещё хуже, !important ломает каскадность. Вы не можете переопределить стиль через класс, атрибут или инлайн-стиль. Только через ещё один !important.

Почему это плохо

  • !important нельзя перебить без другого !important.
  • Каскадность перестаёт работать: специфичность теряет смысл.
  • Трудно отлаживать: непонятно, почему стиль применился.
  • Инлайн-стили (style="...") также проигрывают !important.

Хорошо

Способ 1: понять специфичность. Напомню, она растёт в порядке и у каждого типа селекторов свой вес:

  1. Селектор по тегу (div) — 1
  2. Селектор по классу (.button) — 10
  3. Селектор по ID (#header) — 100
  4. Инлайн-стиль (style="...") — 1000

Побеждает селектор с наибольшим весом

.button {
    background: blue; /* вес = 1 */
}
.sidebar .button {
    background: green; /* вес = 2; более специфичен, победит */
}
.sidebar .button.special {
    background: red; /* вес = 3; ещё более специфичен */
}

Способ 2: использовать CSS-переменные.

:root {
    --button-bg: blue;
}
.button {
    background: var(--button-bg);
}
.sidebar .button {
    --button-bg: green; /* переопределяем переменную, а не свойство */
}

Способ 3: инкапсуляция через CSS-модули или Shadow DOM. Тогда стили не конфликтуют вообще.

Правило: !important — только для переопределения сторонних библиотек, которые вы не можете изменить. И только с комментарием, почему это необходимо.

Антипаттерн 2: глубокая вложенность

Плохо

.page {
    .content {
        .sidebar {
            .menu {
                .menu-item {
                    .menu-item-link {
                        .icon {
                            color: red; /* чтобы изменить цвет иконки, нужен селектор на 7 классов */
                        }
                    }
                }
            }
        }
    }
}

С Sass/SCSS легко писать вложенность. Слишком легко. Через месяц у вас селектор из семи уровней, который:

  • Невозможно переиспользовать в другом месте.
  • Ломается при малейшем изменении HTML-структуры.
  • Имеет огромную специфичность (в примере выше — 7), которую трудно перебить.
  • Увеличивает размер CSS-файла.
  • Замедляет рендеринг (браузер дольше матчит селекторы).

Проблема: вложенность создаёт иллюзию структуры. Вы думаете, что организуете код, а на самом деле создаёте хрупкую иерархию, которую нельзя переиспользовать.

Почему это плохо

  • Компонент нельзя переиспользовать вне родителя.
  • Изменение HTML ломает стили.
  • Высокая специфичность, трудно переопределить.
  • Медленный рендеринг.
  • Сложно искать, где определён стиль.

Хорошо

Способ 1: БЭМ (Block Element Modifier).

.menu { }
.menu__item { }
.menu__link { }
.menu__icon { }
.menu__icon--active { }

Плоские селекторы, понятная структура, легко переиспользовать.

Способ 2: CSS-модули.

/* Menu.module.css */
.menu { }
.item { }
.link { }
.icon { }

Каждый класс уникален, конфликтов нет.

Способ 3: ограничить вложенность.

.card {
    .title { }
    .body { }
    
    &:hover {
        .title { color: red; } /* максимум 2 уровня */
    }
}

Правило: вложенность — максимум 2 уровня. Лучше — вообще без неё, через БЭМ или CSS-модули.

Антипаттерн 3: магические числа

Плохо

.header {
    height: 73px; /* почему 73? */
    padding: 17px 23px; /* откуда эти числа? */
    margin-bottom: 37px; /* магия */
}
.button {
    top: 142px; /* подогнали под макет */
    left: 89px;
}

Магические числа — это значения, которые работают, но никто не знает почему. Они появились, потому что «на макете так было» или «подогнал, пока не стало красиво».

Проблема: через месяц дизайнер поменяет макет. Вам нужно будет поменять 73px на 80px. Вы поменяете в одном месте, но забудете, что это число используется ещё в пяти местах. Или наоборот: поменяете в пяти местах, а где-то останется 73px.

Ещё хуже: магические числа не адаптивны. На экране 1440px всё красиво, на 1024px — ломается.

Почему это плохо

  • Непонятно, откуда взялось число.
  • Трудно менять: нужно искать все вхождения.
  • Нет системы: каждый компонент использует свои числа.
  • Не адаптивно.
  • Дизайнер и разработчик не говорят на одном языке.

Хорошо

Способ 1: система отступов (spacing scale).

:root {
    --space-xs: 4px;
    --space-sm: 8px;
    --space-md: 16px;
    --space-lg: 24px;
    --space-xl: 32px;
    --space-2xl: 48px;
}
.header {
    padding: var(--space-md) var(--space-lg);
    margin-bottom: var(--space-xl);
}

Способ 2: относительные единицы.

.header {
    height: auto; /* пусть высота определяется контентом */
    padding: 1rem 1.5rem; /* rem вместо px */
    margin-bottom: 2rem;
}

Способ 3: CSS-переменные для всех значений.

:root {
    --header-height: 4.5rem;
    --button-padding: 0.75rem 1.5rem;
    --card-radius: 0.5rem;
}
.header {
    height: var(--header-height);
}
.button {
    padding: var(--button-padding);
}

Правило: ни одного магического числа. Все значения — через переменные или систему отступов.

Бонус: ещё три способа испортить CSS

z-index: 9999

/* Плохо */
.modal { z-index: 9999; }
.tooltip { z-index: 99999; }
.dropdown { z-index: 999999; }
/* Хорошо — система слоёв */
:root {
    --z-dropdown: 100;
    --z-sticky: 200;
    --z-modal: 300;
    --z-tooltip: 400;
}
.modal { z-index: var(--z-modal); }

Соренование «у кого больше z-index» — классика. Разобравшись с тем как работает контекст наложения, вы решите проблему без огромных чисел.

Стили через JavaScript

// Плохо
element.style.marginTop = '10px';
element.style.backgroundColor = 'red';
element.style.fontSize = '14px';
// Хорошо
element.classList.add('active');

Инлайн-стили через JS:

  • Не кэшируются.
  • Трудно переиспользовать.
  • Смешивают логику и представление.
  • Не работают с медиазапросами и псевдоклассами.

Отсутствие методологии

/* Плохо — каждый пишет как хочет */
.header { }
.top-bar { }
#navigation { }
.main_menu { }
.MenuItem { }
/* Хорошо — единая методология (БЭМ) */
.header { }
.nav { }
.nav__item { }
.nav__item--active { }

Без методологии каждый разработчик придумывает свои имена. Через месяц в проекте пять стилей именования, и никто не понимает, какой класс за что отвечает.

Правило: выберите методологию (БЭМ, CSS-модули, Tailwind) и следуйте ей всей командой.

Итог: что запомнить

АнтипаттернЧем плохКак исправить
!importantГонка вооружений, ломает каскадПонять специфичность, CSS-переменные
Глубокая вложенностьХрупкость, высокая специфичностьБЭМ, CSS-модули, максимум 2 уровня
Магические числаНепонятно, не адаптивноСистема отступов, CSS-переменные
z-index: 9999Гонка вооруженийСистема слоёв, понимание stacking context
Стили через JSНе кэшируются, не переиспользуютсяКлассы и CSS-переменные
Нет методологииХаос в именахБЭМ, CSS-модули, Tailwind

Оглавление серии

  1. Как испортить всё: 10 способов уничтожить фронтенд-проект
  2. Как испортить JavaScript-код. Антипаттерны
  3. Как испортить React-приложение. Антипаттерны
  4. Как испортить TypeScript. Антипаттерны
  5. Как испортить CSS. Антипаттерны (вы здесь)
  6. Как испортить архитектуру фронтенда. Антипаттерны
  7. Как испортить тестирование. Антипаттерны
  8. Как испортить Git-репозиторий. Антипаттерны
  9. Как испортить производительность. Антипаттерны
  10. Как испортить безопасность приложения. Антипаттерны
  11. Как испортить командную работу. Антипаттерны

Симо Мофин
Симо Мофин

Senior Frontend Developer
Главный по блогу