CSS-in-JS, CSS Modules или BEM: как выбрать подход для React-команды

•
Опубликовано
•
15 мин чтения

Текст написан с позиции июля 2017 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.

Споры о стилях во фронтенде почти никогда не бывают только про стили. На поверхности обсуждение обычно выглядит как разговор о синтаксисе, именовании классов, удобстве импорта и борьбе с конфликтами селекторов. Но если всмотреться внимательнее, почти всегда речь идет о более глубокой вещи: как команда вообще понимает устройство интерфейса, границы компонентов и ответственность между разметкой, логикой и оформлением. Именно поэтому вопрос «CSS-in-JS, CSS Modules или BEM?» для React-команды нельзя считать чисто вкусовым. Это уже вопрос архитектуры повседневной разработки.

React за последние годы заметно изменил способ мышления о UI. Интерфейс все чаще воспринимается как дерево компонентов, а не как набор страниц с глобальными шаблонами и общим слоем стилей, который живет где-то отдельно. Это, в свою очередь, поставило под давление старые привычки работы с CSS. Когда интерфейс был более страничным и более плоским, можно было долго терпеть большие глобальные таблицы стилей, договоренности на словах и общие naming conventions, которые удерживали проект от распада. Но когда приложение разрастается до десятков и сотен компонентов, а над ним работает команда, вопрос изоляции, повторного использования и локальности стилей становится намного острее.

На этом фоне и усилилось внимание к трем подходам, которые сейчас чаще всего обсуждают рядом с React: классический BEM, CSS Modules и CSS-in-JS. У каждого из них есть сильные стороны, у каждого есть цена, и у каждого есть свой тип обещания команде. BEM обещает дисциплину именования и предсказуемость в глобальном CSS. CSS Modules обещают локальность классов без отказа от привычного CSS как языка. CSS-in-JS обещает максимально тесно привязать стили к компонентной модели и программно управлять оформлением. Проблема в том, что эти обещания легко звучат убедительно в статьях и докладах, но выбор в реальном проекте зависит не от красивого лозунга, а от того, какие боли у команды уже есть и какие компромиссы она готова принять.

Самая вредная реакция на эти споры — услышать слово «CSS-in-JS», увидеть, как о нем рассказывают на конференциях, и решить, что вопрос изоляции стилей наконец-то решен раз и навсегда. Поэтому зафиксируем сразу: ни один из трех вариантов не является магическим решением самой природы CSS. Все три — это не разные степени прогресса, а разные способы управлять сложностью. И если команда не понимает, где именно у нее источник хаоса, выбор инструмента легко превратится в подмену проблемы. Это и есть та призма, через которую дальше стоит смотреть на каждый подход: не «что моднее», а какой тип сложности он реально берет на себя и какой ценой.

Сначала боль, потом инструмент: что вообще нужно решить

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

Почему это так важно проговорить заранее? Потому что почти все ошибки выбора начинаются с пропуска этого шага. Можно перейти на CSS-in-JS, но продолжать писать плохо организованные визуальные правила и получить те же самые архитектурные трудности, только в другой форме. Можно ввести BEM, но не следить за структурой компонентов и утонуть в многословных классах без реальной локальности. Можно использовать CSS Modules, но так и не договориться, как проектировать повторное использование и общие дизайн-примитивы. Инструмент не лечит непонимание собственной боли — он только меняет ее обертку.

BEM борется с хаосом не изоляцией, а договоренностью

Начать логично с BEM, потому что это самый «классический» из трех подходов и в то же время самый показательный. Сила BEM в том, что он не требует революции в инструментах. По сути, это дисциплина именования и организации CSS, которая помогает сделать глобальные классы более предсказуемыми. Вместо расплывчатых названий вроде .title, .item или .box команда использует более структурированные имена, где уже зашита принадлежность к блоку, элементу и модификатору. Это сильно снижает вероятность случайных конфликтов и делает HTML вместе с CSS более читаемыми с точки зрения структуры интерфейса.

Для React-команды это не такая уж маленькая выгода, как иногда кажется. Даже в компонентном приложении многие проблемы с CSS по-прежнему начинаются с того, что классы слишком общие, связи слишком неявные, а одно изменение неожиданно влияет на соседние части UI. BEM заставляет быть честнее в именовании и тем самым помогает проекту, особенно если в команде пока нет желания или возможности серьезно менять сборку и подход к стилям. Он хорошо ложится на существующую привычку писать обычный CSS и в этом смысле имеет низкий порог входа.

Но важно не перепутать: BEM решает не техническую, а дисциплинарную проблему. Главное его ограничение в том, что он все равно остается дисциплиной поверх глобального пространства имен. Да, имена становятся лучше. Да, конфликты встречаются реже. Да, структура выразительнее. Но классы все еще глобальны, и поддержание порядка по-прежнему сильно зависит от аккуратности команды. Иначе говоря, BEM борется с хаосом не технической изоляцией, а договоренностью. Пока договоренность жива, все относительно спокойно. Когда проект растет и командная дисциплина проседает, боли возвращаются.

Кроме того, BEM нередко делает разметку и стили более многословными. В небольшом компоненте это еще не страшно. В большом интерфейсе с множеством блоков, элементов и модификаторов названия начинают разрастаться, а HTML иногда выглядит так, будто несет на себе архитектурную документацию целиком. Для кого-то это допустимая цена за ясность. Для кого-то — усталость и повод искать более локальные способы организации. Особенно это чувствуется в React, где сама компонентная модель уже задает часть структуры, и многим хочется, чтобы CSS лучше ей соответствовал, а не требовал второй параллельной системы описания иерархии.

CSS Modules дают локальность имен, но не архитектуру стилей

Именно здесь CSS Modules выглядят как очень привлекательный компромисс. Они не требуют отказаться от CSS как языка и не заставляют переносить стили в JavaScript, но при этом предлагают то, чего BEM дать не может сам по себе: техническую локальность имен. Идея довольно проста и потому сильна. Вы пишете обычный CSS-файл, но импортируете его как модуль, а классы внутри получают локальную область видимости. На уровне автора это остается привычным CSS с классами вроде .root, .title, .button, но на уровне собранного приложения имена становятся уникальными и не конфликтуют между компонентами.

Для React-команды это очень естественное обещание. Компоненту соответствует свой файл стилей, классы локальны, зависимость явно выражена через импорт, страх случайного глобального влияния заметно снижается. По сути, CSS Modules хорошо попадают в саму логику компонентного UI: стили живут рядом с компонентом, но при этом не перестают быть CSS. Это важное качество, потому что для многих команд ценность привычного CSS все еще очень велика. В нем есть понятный синтаксис, зрелый опыт работы, устоявшиеся инструменты и отсутствие ощущения, что ради решения одной проблемы нужно тащить в проект совершенно другой способ мыслить оформление.

С практической точки зрения CSS Modules часто выигрывают там, где команда уже устала от глобального CSS, но не хочет резко менять модель мышления. Они довольно быстро убирают большую часть боли вокруг конфликтов имен и «невидимого» влияния одних селекторов на другие. Кроме того, они психологически упрощают рефакторинг. Когда стиль локален компоненту, его проще удалять, переносить и менять, потому что вероятность случайной скрытой зависимости меньше. Для React-приложения с большим количеством средних и мелких компонентов это очень ощутимое облегчение.

И все же не стоит терять здравый смысл. CSS Modules дают локальность имен, но не отвечают за то, насколько хорошо продуманы состояния компонента, вариации, общие переменные оформления, повторно используемые примитивы и отношение между локальными стилями и глобальной темой проекта. Очень легко начать воспринимать CSS Modules как полный ответ на все проблемы и обнаружить через несколько месяцев, что в проекте теперь не глобальный хаос, а набор локальных хаосов, разбросанных по компонентам. В таком мире конфликты имен исчезают, но проблемы дублирования, непоследовательного дизайна и неудачного переиспользования никуда не деваются.

Есть и более тонкий момент. React-команда почти неизбежно сталкивается с необходимостью общих визуальных примитивов: кнопок, форменных элементов, сеток, отступов, типографики, тем, состояний интерфейса. Если буквально все стили понимаются как локальные, может стать труднее выстраивать цельную систему повторного использования. Это не делает CSS Modules плохим выбором, но требует зрелости. Локальность — это средство защиты компонентов, а не повод отрицать существование общего дизайн-слоя. В хорошей кодовой базе почти всегда есть и локальные стили компонента, и общий язык визуальной системы. Просто они должны быть разведены осмысленно.

CSS-in-JS — не про моду, а про динамику оформления

На другом конце спектра находится CSS-in-JS — самый обсуждаемый и одновременно самый поляризующий подход из трех. Вокруг него сейчас особенно много шума, и это понятно. Он очень хорошо попадает в настроение времени: если React уже предложил писать разметку рядом с логикой компонента, почему бы не сделать то же самое со стилями? Если компонент — главная единица UI, почему не позволить ему полностью владеть своим оформлением? Если стили зависят от props, состояния и темы, может быть, действительно удобнее описывать это не через внешние CSS-файлы, а внутри JavaScript-мира, где уже живет сама логика компонента?

Соблазн здесь огромный. CSS-in-JS обещает не просто локальность, а почти полную компонентную замкнутость. Стили могут жить рядом с компонентом или прямо внутри него. Можно использовать переменные языка, условную логику, тему, вычисления и динамические вариации без постоянного прыжка между разными файлами и разными слоями проекта. Для React-команды, которая уже мыслит UI как композицию компонентов и состояний, такой подход звучит очень современно. Он будто бы доводит компонентную идею до логического конца.

Особенно хорошо CSS-in-JS чувствует себя там, где у интерфейса действительно много динамики. Когда внешний вид тесно зависит от props, темизации, состояний, сочетаний модификаторов, адаптивных сценариев и программной композиции, перенос части работы в JavaScript может казаться гораздо естественнее, чем постоянное манипулирование классами и внешними таблицами стилей. В таком контексте CSS-in-JS не выглядит странной экзотикой, а становится способом приблизить слой оформления к реальной логике UI. Ключевая мысль здесь именно такая: ценность подхода — не эстетика «современности», а динамика, которую он позволяет выразить напрямую.

Цена CSS-in-JS: стили теряют собственную среду

Именно здесь и начинается цена, которую нельзя игнорировать. Во-первых, CSS-in-JS заметно меняет привычную культуру работы со стилями. Команда, которая хорошо чувствует обычный CSS, должна принять, что часть оформления теперь живет в JavaScript-контексте, со своими библиотечными соглашениями, синтаксисом и паттернами. Для одних это облегчение. Для других — ощущение, что стили потеряли собственную среду и стали зависимы от инструмента сильнее, чем хотелось бы. Во-вторых, вокруг CSS-in-JS неизбежно возникает вопрос долгосрочной стоимости. Когда оформление слишком тесно переплетается с компонентной логикой, граница между визуальным и поведенческим слоем может стать менее ясной, чем кажется на старте.

Есть и еще одно важное соображение. CSS-in-JS очень легко начать воспринимать как символ современности, а не как ответ на конкретную боль. Если команда выбирает его потому, что ей действительно нужна сильная динамичность стилей, выраженная через props и композицию, это одно. Если же он берется просто потому, что «React-команды сейчас так делают», можно быстро оказаться в ситуации, где цена инструмента уже есть, а реальная польза не так велика. Для сравнительно спокойных интерфейсов с понятными состояниями и не слишком драматической вариативностью CSS-in-JS может оказаться более мощным, чем нужно, и потому более дорогим в повседневной жизни. Не сам по себе CSS-in-JS избыточен — избыточен он там, где у задачи нет той динамики, под которую он создан.

Стиль выбирают не только под архитектуру, но и под команду

Отдельно стоит сказать о команде как о человеческой системе. Выбор подхода к стилям — это не только вопрос чистой архитектуры, но и вопрос того, как работают конкретные люди. Если в команде сильна традиция работы с CSS, если визуальный слой обсуждается отдельно и люди уверенно мыслят селекторами, каскадом, структурой файлов и дизайн-системой, резкий переход на CSS-in-JS может вызвать не ускорение, а трение. Если же команда уже почти полностью живет в компонентном мышлении, любит держать все рядом, не боится логики в представлении и ценит программную композицию, этот подход может дать очень хороший эффект. Иначе говоря, выбирать нужно не только под идеальную архитектуру, но и под реальную культуру разработки.

То же самое относится и к BEM с CSS Modules. BEM особенно хорошо работает в командах, которым нужна строгая дисциплина без радикального технологического сдвига. Он может быть отличным выбором для проектов, где важно улучшить существующий CSS-подход без полной перестройки. CSS Modules часто особенно удачны там, где команда уже перешла на компонентное мышление, но хочет сохранить обычный CSS и получить локальность имен с минимальной идеологической нагрузкой. CSS-in-JS сильнее всего раскрывается там, где динамика интерфейса и программная природа стилей действительно составляют существенную часть задачи, а команда готова принять новый уровень связности между компонентом и оформлением.

Есть и вопрос долгой поддержки. На короткой дистанции почти любой подход можно заставить выглядеть аккуратно. Настоящая проверка начинается через несколько месяцев, когда проект разрастается, появляются новые люди, старые решения начинают переоцениваться, а дизайн-система требует согласованности. Здесь BEM выигрывает своей прозрачностью: почти любой фронтендер понимает, что происходит, даже если ему не знакома конкретная сборка проекта. CSS Modules выигрывают балансом: локальность уже есть, но CSS остается CSS. CSS-in-JS выигрывает там, где команда действительно хочет жить в этой модели и последовательно строить вокруг нее систему. Но если уверенности в такой модели нет, его долгосрочная цена может оказаться выше, чем казалось на волне энтузиазма.

Смешанный подход допустим, если он осознан, а не случаен

Очень полезно и то, что выбор не всегда обязан быть абсолютно чистым. Реальные проекты часто живут в смешанном мире. Например, команда может использовать CSS Modules как базовый способ локальных стилей компонентов, но при этом сохранять небольшой общий слой для типографики, reset-правил и дизайн-токенов. Или проект может использовать BEM для части существующего кода и постепенно вводить CSS Modules в новых компонентах. Даже вокруг CSS-in-JS многие уже приходят к мысли, что не обязательно переводить туда буквально весь визуальный слой.

Но здесь снова важно быть честным до конца. Смешение подходов — это не свобода от дисциплины, а более сложная дисциплина. Гибрид помогает, когда он подчинен ясной модели: где локальные стили, где общий язык визуальной системы, где динамика, которую честнее держать в JavaScript. Гибрид вредит, когда он становится не решением, а следствием архитектурной усталости — когда новый подход вводят, не убирая старый, и проект медленно превращается в склад несвязанных соглашений. Разница между этими двумя гибридами не в технологиях, а в том, есть ли за ними осознанная модель.

Чтобы приземлить выбор до конкретики, команде полезно задать несколько довольно простых вопросов. Где сейчас больше боли: в конфликтах имен, в удалении старых стилей, в переиспользовании, в динамических состояниях, в поддержке темы, в запутанности глобального CSS? Насколько команда готова менять инструменты и привычки? Насколько велика роль динамических визуальных вариаций в продукте? Насколько важно сохранить обычный CSS как самостоятельный слой? Есть ли сейчас в проекте сильная компонентная дисциплина или она пока только формируется? Ответы на эти вопросы почти всегда подсказывают направление лучше, чем любые общие декларации.

Выбирают не ступень эволюции, а тип сложности под контроль

Если говорить совсем практично, то для многих React-команд CSS Modules выглядят наиболее спокойным выбором по умолчанию. Они дают значимую пользу в виде локальности, хорошо сочетаются с компонентной структурой и не требуют полного пересмотра природы стилей. Это не делает их идеальными, но делает очень удобной серединой. BEM остается хорошим вариантом там, где команда хочет дисциплины без серьезной технологической смены или работает в среде, где обычный CSS по-прежнему естественен. CSS-in-JS выглядит наиболее сильным инструментом для команд, которым действительно нужна программируемость стилей и тесная интеграция с компонентной логикой, и которые готовы платить за это большей инструментальной и концептуальной сложностью.

Самое неудачное, что можно сделать, — выбирать подход как знак принадлежности к модной школе. Для React-команды это особенно опасно, потому что экосистема и без того быстро меняется, а соблазн принять новое решение как маркер современности очень велик. Но стили — это слишком повседневный слой проекта, чтобы позволять себе в нем чисто символический выбор. То, как команда пишет CSS или его эквивалент, влияет на скорость интерфейсной работы каждый день. Здесь почти не бывает победы от красивой теории, если она не совпадает с реальными задачами и навыками людей.

Поэтому стоит зафиксировать главное прямо. BEM, CSS Modules и CSS-in-JS — это не три ступени эволюции, где каждый следующий автоматически «лучше» предыдущего. Это три разных ответа на проблему масштабирования стилей в компонентном UI. BEM делает ставку на дисциплину именования и структуру. CSS Modules — на локальность при сохранении привычного CSS. CSS-in-JS — на максимальное сближение стилей с компонентной и программной моделью. Правильный выбор зависит не от лозунга, а от того, какой тип сложности команда хочет контролировать и какой тип цены готова платить.

Если команда не уверена, выбирайте подход, который снимает вашу текущую боль, а не обещает прекрасное будущее на всех уровнях сразу: стили в UI — это не место для архитектурной романтики, а слой, с которым придется жить каждый день, и чем спокойнее команда может с ним жить, тем правильнее был выбор.

Автор

Senior Principal JavaScript Developer, Tech Lead. Пишет о React, TypeScript, React Native, архитектуре фронтенда и бэкенда и о том, как AI меняет работу разработчика.

Обновлено

Читайте также