JSX без боли: как объяснить себе и команде, зачем HTML внутри JavaScript
Текст написан с позиции ноября 2014 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.
Стоит впервые показать JSX разработчику, который привык к классическому разделению HTML, CSS и JavaScript, и реакция почти всегда одна и та же. Сначала — лёгкое недоумение. Потом — раздражение. А затем неизбежный вопрос: зачем вообще тащить HTML внутрь JavaScript, если мы столько лет старались держать разметку отдельно? Это не просто техническая придирка, а почти культурный конфликт. Многих учили, что хорошая структура проекта начинается с разведения слоёв: HTML отвечает за содержимое, CSS — за внешний вид, JavaScript — за поведение. И вдруг появляется синтаксис, который на вид нарушает это правило демонстративно и даже вызывающе.
Именно поэтому разговор о JSX почти всегда начинается не с преимуществ, а с внутреннего сопротивления. Люди видят что-то похожее на HTML внутри JavaScript-кода и воспринимают это как шаг назад — в те времена, когда в шаблоны беспорядочно впихивали логику, а потом пытались понять, где заканчивается представление и начинается приложение. Опасение понятное: никому не хочется легализовать хаос под видом нового подхода. Но проблема в том, что первое впечатление о JSX строится на старых категориях, которые плохо подходят для описания современных интерфейсов.
И здесь важно зафиксировать сразу главное противопоставление, на котором держится вся статья. Спор идёт не о том, смешивать ли HTML и JavaScript в одном файле. Спор о том, что именно считать единицей разделения в приложении. JSX — это не попытка буквально взять HTML и засунуть его в код по капризу авторов React. Точнее так: это способ описывать структуру интерфейса рядом с логикой этого интерфейса в рамках одного компонента. Разница кажется тонкой, но на практике она огромна.
Сразу оговорюсь и про другую крайность, чтобы не было ложных ожиданий. JSX не делает код хорошим автоматически и не заменяет архитектурного мышления. Это инструмент с понятной ценой и понятными границами, а не победа над сложностью интерфейсов. Дальше я попробую честно разобрать и то, и другое.
Разделение по технологиям проигрывает разделению по компонентам
Классическая идея разделения слоёв исторически была очень полезной. Когда страницы оставались сравнительно простыми, действительно имело смысл хранить разметку отдельно, стили отдельно, поведение отдельно. Но современный интерфейс всё чаще состоит не из цельной страницы, а из множества небольших, повторяющихся, взаимосвязанных блоков: карточек, списков, форм, кнопок, панелей, виджетов, меню, модальных окон. У каждого такого блока есть не только внешний вид, но и собственная логика отображения. Он ведёт себя по-разному в зависимости от входных данных, состояния и действий пользователя. В этот момент разделение по технологиям начинает проигрывать разделению по компонентам.
Вот это и есть главная мысль, которую JSX помогает зафиксировать. Он предлагает хранить вместе не «всё подряд», а то, что в реальном интерфейсе и так живёт как единое целое. Если у вас есть компонент кнопки, логично, что её структура, логика рендера и реакция на свойства находятся рядом. Если у вас есть карточка товара, её шаблон тесно связан с тем, какие данные в неё приходят, что показывается условно, какие части списка рендерятся циклом, где меняется класс, а где скрывается блок. JSX не пытается разрушить архитектуру. Наоборот, он пытается приблизить архитектуру к реальной природе интерфейса.
Многие возражают: но ведь шаблоны и раньше решали ту же задачу, зачем изобретать ещё один синтаксис? Вопрос хороший. Идея шаблонов не нова — во фронтенде давно существуют разные способы описывать представление декларативно. Однако в классических шаблонизаторах остаётся заметный разрыв между логикой и отображением. Данные подготавливаются в одном месте, шаблон живёт в другом, условия и циклы оформляются через отдельные правила, а потом возникает ещё слой связки между всем этим. JSX убирает часть этой искусственной дистанции: он позволяет описывать UI как выражение на том же языке, на котором вы и так пишете логику компонента.
Интерфейс перестал быть документом и стал функцией от состояния
Самое сложное при первом знакомстве с JSX — перестать воспринимать разметку как нечто священно отдельное. В традиционном мышлении HTML кажется почти документом: вот структура страницы, вот текст, вот блоки. JavaScript должен приходить потом и аккуратно оживлять это извне. Но в приложениях с активным интерфейсом представление давно перестало быть статичным документом. Это теперь функция от состояния. Один и тот же блок сейчас отображается так, а через секунду — иначе. Кнопка становится неактивной. Список обновляется. Часть интерфейса исчезает. Появляются ошибка, индикатор загрузки, пустое состояние, новый набор элементов.
Когда представление постоянно зависит от данных, держать его отдельно от логики, которая этими данными управляет, не всегда удобно. Именно здесь JSX выглядит не странностью, а прямым инструментом. Он позволяет писать не инструкции для ручной сборки DOM, а описание того, каким интерфейс должен быть при текущем состоянии. По сути, компонент возвращает структуру, которая зависит от данных. Это гораздо ближе к реальной задаче, чем бесконечные манипуляции вида «найди элемент, добавь класс, замени текст, вставь кусок HTML, скрой блок, потом где-то не забудь всё это обновить ещё раз».
Объяснять JSX стоит не с синтаксиса, а с боли, которую он снимает
Один из лучших способов объяснить JSX команде — не начинать с синтаксиса. Спор о фигурных скобках, тегах и внешнем виде кода обычно бесполезен, пока люди не увидят, от какой именно сложности новый подход избавляет. В jQuery-подходе или в разрозненной шаблонной системе проблема редко в том, что что-то невозможно сделать. Почти всё можно. Проблема в том, что со временем интерфейс становится трудно удерживать в голове. Отображение разбросано по кускам, условия живут где-то отдельно, данные подготавливаются в одном месте, а DOM обновляется в другом. Любая мелкая правка начинает требовать археологии по проекту. JSX интересен тем, что делает зависимость между данными и отображением локальной и видимой.
Есть ещё одна причина раздражения: JSX визуально похож на HTML, и кажется, будто разработчик «вернулся к шаблонам», только в более странной форме. Но сходство обманчиво. JSX не про то, чтобы вставлять в JavaScript готовые куски страницы как строку. Наоборот, он позволяет выражать структуру интерфейса средствами языка, а затем преобразуется в вызовы, которые описывают элементы приложения. Это не свободное смешение текста и логики, а вполне формальная запись. Именно поэтому JSX обычно безопаснее и управляемее, чем конкатенация HTML-строк или шаблоны, где легко ошибиться в контексте и получить трудноуловимый баг.
Некрасиво — это про привычку, а не про управление сложностью
Полезно честно признать: на уровне привычки JSX сначала кажется некрасивым. Особенно тем, кто долго работал с чистым JavaScript и отделёнными шаблонами. Код выглядит непривычно. В одном месте оказываются и функции, и условия, и визуальная структура. Это ломает автоматические ожидания. Но очень многое в разработке сначала кажется «неправильным» только потому, что не совпадает с уже сложившейся эстетикой. Вопрос не в том, выглядит ли JSX привычно, а в том, помогает ли он лучше управлять сложностью интерфейса. Для многих команд ответ постепенно оказывается положительным.
Сильный аргумент в пользу JSX — читабельность компонентов в контексте их же поведения. Когда открываешь компонент и сразу видишь, что он рендерит, по каким условиям показывает разные состояния, где пробрасывает свойства дальше, где формирует список дочерних элементов, код воспринимается цельнее. Не нужно прыгать между несколькими файлами, мысленно склеивая шаблон, данные и поведение. Это особенно важно в команде, где код читают чаще, чем пишут. Хороший компонент на JSX бывает понятнее, чем набор отдельных файлов, между которыми приходится постоянно восстанавливать причинно-следственные связи.
JSX не отменяет дисциплину — он переносит границу разделения
Конечно, это не значит, что любой JSX-код автоматически читаем. Плохой компонент можно написать и с JSX, и без него. Если внутрь рендера запихнуть половину бизнес-логики, обвязать всё вложенными условиями и перегрузить один компонент ответственностью за слишком многое, получится тяжёлый и неуклюжий код. Но это аргумент не против JSX, а против плохой декомпозиции. Более того, компонентный подход обычно лучше подталкивает к правильной разбивке интерфейса на небольшие части. Когда разметка и поведение живут рядом, легче заметить, что компонент стал слишком большим, и вынести из него отдельные куски.
Часто команде мешает не сам JSX, а страх потерять чистоту проекта. Кажется, что если разрешить «HTML в JavaScript», дальше начнётся полное смешение всего со всем. Но это происходит только там, где нет дисциплины на уровне компонентов. JSX не требует отказываться от архитектуры, именования, композиции, правил по размеру компонентов, стилей или границ ответственности. Он лишь предлагает другое место для разделения: не между HTML-файлом и JS-файлом, а между независимыми UI-блоками. Когда команда понимает это, напряжение заметно снижается.
Интуиция функции объясняет JSX лучше любого спора об эстетике
JSX — это не религиозная декларация о том, что HTML и JavaScript «должны быть вместе». Это практический компромисс ради более естественной разработки интерфейсов, где представление тесно связано с логикой рендера. Если бы интерфейсы по-прежнему оставались в основном статичными страницами с редкими вкраплениями поведения, потребность в JSX не ощущалась бы так остро. Но когда UI всё больше напоминает живую систему состояний, декларативное описание рядом с компонентной логикой становится соблазнительным вариантом.
Хорошо работает сравнение с функцией. В обычном коде нас не смущает, что внутри функции рядом находятся вычисления, ветвления и возврат результата. Мы не требуем выносить условие в отдельный файл только потому, что оно «логически другого типа», чем выражение return. Мы смотрим на функцию как на единицу поведения. JSX предлагает ту же интуицию для UI-компонента: есть входные данные, есть немного логики, есть результат в виде описания интерфейса. Если принять это, синтаксис начинает казаться не кощунством, а последовательным решением.
Спорить полезнее о сопровождении, чем о вкусе
Есть и чисто командный аспект. Когда новая технология вызывает у коллектива раздражение, спор уходит в область вкуса и идентичности. Кто-то говорит, что это «грязно», кто-то — что «гениально». Но намного полезнее обсуждать не вкус, а сценарии поддержки кода. Как проще ввести в проект нового человека? Где легче понять, что именно рендерит компонент? Где быстрее найти условие, по которому скрывается кнопка? Где меньше шансов, что шаблон и логика разойдутся? Где проще переиспользовать кусок интерфейса? Разговор о JSX становится конструктивным именно тогда, когда переходит с эстетики на сопровождение и масштабирование.
Важно и то, что JSX хорошо ложится на повторное использование компонентов. Если интерфейс собирается из небольших блоков, каждый из которых принимает свойства и возвращает кусок UI, команда начинает мыслить не страницами и шаблонами целиком, а библиотекой элементов. Это меняет качество разработки. Появляется шанс иметь более единообразные кнопки, формы, панели, списки. Появляется привычка не копировать разметку снова и снова, а собирать приложение из уже понятных частей. JSX здесь полезен не сам по себе, а как удобный язык для такой композиции.
JSX не лечит проект, в котором нет компонентов
Иногда для снятия боли помогает максимально приземлённая формулировка: JSX нужен не затем, чтобы смешать HTML и JavaScript, а затем, чтобы перестать собирать интерфейс из строк, селекторов и ручных манипуляций над DOM. Это попытка заменить хрупкий императивный стиль на более описательный и локальный. Когда это сформулировано именно так, у команды появляется шанс увидеть в JSX не нарушение порядка, а средство против другого, гораздо более неприятного беспорядка.
И всё же не стоит обещать чудес. JSX не наводит порядок сам и не думает за того, кто проектирует компоненты. Он не спасёт проект, в котором не умеют выделять компоненты, злоупотребляют состоянием или смешивают бизнес-логику с отображением без всякой меры. Более того, при неаккуратном использовании JSX способен усилить проблемы, потому что делает визуальную часть очень доступной для быстрых и не всегда продуманных правок. Поэтому честное объяснение команде должно включать и это: JSX полезен только как часть более широкого компонентного подхода, а не как волшебный синтаксис, который сам по себе всё чинит.
Не стоит и превращать разговор о JSX в культ новизны. Это пока не общепринятый стандарт мышления для всего фронтенда, и многие возражения против него заслуживают уважения. Не каждому проекту нужен такой подход. Не каждая команда готова к компонентной дисциплине. Не всем нравится внешний вид синтаксиса, и это тоже нормально. Но если ваш интерфейс уже растёт в сторону приложения — много состояний, повторяющихся блоков, условий и клиентской логики, — игнорировать JSX только из-за нарушенной эстетической привычки может оказаться слишком дорогой осторожностью.
Итог
Защищать JSX стоит не как красивую идею, а как рабочий язык описания интерфейса в компонентной модели. Его сила не в том, что он «позволяет писать HTML в JavaScript». Его сила в том, что он держит рядом то, что в реальном UI и так связано: структуру компонента, условия его отображения и композицию с другими компонентами. Для сложных интерфейсов это часто оказывается более честным и более поддерживаемым решением, чем попытка любой ценой сохранить старую границу между шаблоном и логикой.
Сопротивление обычно уходит не после абстрактного слайда с «Hello, world», а после первого живого компонента: со списком, условиями, обработчиками, разбивкой на подкомпоненты и ясным потоком данных. Когда люди видят, что такой код читается сверху вниз и в нём сразу видна структура интерфейса и причины его изменений, напряжение спадает. JSX редко убеждает в теории — он убеждает практикой, когда после него труднее вернуться к разбросанным шаблонам, строковым вставкам HTML и вечному поиску того места, где именно обновляется нужный фрагмент DOM.
Если сформулировать совсем прямо: не говорите команде «мы смешиваем HTML и JavaScript» — говорите «мы описываем интерфейс там же, где определяем поведение компонента, потому что в живом UI эти вещи уже невозможно эффективно разносить по разным углам без потерь», и тогда JSX перестаёт выглядеть провокацией и становится логичным шагом фронтенда, который взрослеет и учится работать со сложностью.