CSS — самый миролюбивый язык в вебе. Он не ругается, не выбрасывает ошибок, не ломает сборку. Он просто молча игнорирует то, что не понял, и применяет то, что смог. Из-за этого в больших проектах CSS склонен превращаться в свалку из !important, вложенности на десять уровней и магических чисел, которые никто не может объяснить.
Сегодня разберём три классических способа испортить CSS так, чтобы с ним не хотелось иметь дела.
- Антипаттерн 1: !important вместо нормальной специфичности
- Плохо
- Почему это плохо
- Хорошо
- Антипаттерн 2: глубокая вложенность
- Плохо
- Почему это плохо
- Хорошо
- Антипаттерн 3: магические числа
- Плохо
- Почему это плохо
- Хорошо
- Бонус: ещё три способа испортить CSS
- z-index: 9999
- Стили через JavaScript
- Отсутствие методологии
- Итог: что запомнить
- Оглавление серии
Антипаттерн 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: понять специфичность. Напомню, она растёт в порядке и у каждого типа селекторов свой вес:
- Селектор по тегу (
div) — 1 - Селектор по классу (
.button) — 10 - Селектор по ID (
#header) — 100 - Инлайн-стиль (
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 |
Оглавление серии
- Как испортить всё: 10 способов уничтожить фронтенд-проект
- Как испортить JavaScript-код. Антипаттерны
- Как испортить React-приложение. Антипаттерны
- Как испортить TypeScript. Антипаттерны
- Как испортить CSS. Антипаттерны (вы здесь)
- Как испортить архитектуру фронтенда. Антипаттерны
- Как испортить тестирование. Антипаттерны
- Как испортить Git-репозиторий. Антипаттерны
- Как испортить производительность. Антипаттерны
- Как испортить безопасность приложения. Антипаттерны
- Как испортить командную работу. Антипаттерны







