Архитектура маленького SPA: как не превратить код в мешанину
Текст написан с позиции декабря 2014 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.
У маленьких SPA есть одна обманчивая особенность: они почти всегда начинаются легко, бодро и с некоторой самоуверенностью. Кажется, что ничего сложного тут не будет. Один экран, пара роутов, список данных, форма, фильтры, авторизация, небольшая админка — да что там вообще можно испортить? На этом этапе разработчик чувствует себя в безопасности. Не нужно строить тяжёлую систему, не нужно думать как архитектор корпорации, не нужно закладывать масштаб на десять лет вперёд. Нужно просто быстро собрать приложение. И именно в этот момент чаще всего закладываются проблемы, которые через несколько недель делают даже маленький SPA неприятным в поддержке.
Здесь важно сразу зафиксировать главное: проблема не в самом формате single-page application. Проблема в иллюзии, что раз приложение маленькое, то архитектура ему почти не нужна. На практике выходит наоборот. Маленькие SPA особенно легко скатываются в мешанину, потому что в них никто не ожидает хаоса заранее. В большом проекте все хотя бы морально готовы к структуре, слоям, правилам, декомпозиции. В маленьком соблазн велик: написать всё попроще, сложить рядом пару файлов, быстро связать роуты, DOM-обработчики, AJAX и шаблоны, а потом «если что» привести в порядок. Это «если что» обычно наступает очень быстро.
Почему так происходит? Потому что SPA даже небольшого размера почти сразу живёт в более сложной среде, чем обычная страница с несколькими скриптами. Здесь уже есть состояние приложения. Есть маршруты. Есть клиентская логика, которая не исчезает после перехода по ссылке. Есть данные, приходящие с сервера. Есть рендеринг, который может происходить многократно. Есть пользовательские действия, которые меняют не только DOM, но и внутреннюю картину того, что сейчас происходит в приложении. Даже если экранов всего два или три, это уже не просто страница с кнопками. Это маленькая система. А у любой системы очень быстро проявляется цена беспорядка.
Поэтому дальше речь не о том, как сделать приложение «красивым на бумаге». Речь о том, как удержать компактный SPA в границах, за которыми код перестаёт быть набором случайных реакций и начинает вести себя предсказуемо. И, что не менее важно, про то, где у дисциплины есть цена и где не нужно перегибать палку в обратную сторону.
Первая задача архитектуры — не паттерны, а понятные границы
Обычно путь к мешанине выглядит знакомо. Сначала появляется файл app.js, в котором создаётся приложение, прописывается инициализация и навешиваются глобальные события. Потом рядом оказывается router.js с маршрутами. Затем добавляется api.js для запросов к серверу. Потом появляется views.js или несколько view-файлов. Потом где-то заводится utils.js, потом helpers.js, потом отдельный auth.js. А дальше кусок логики фильтрации почему-то уезжает в view, часть состояния неожиданно начинает жить прямо в роутере, потому что так было быстрее. И вроде бы всё пока работает. Но очень скоро выясняется, что проект не имеет внятного центра тяжести: непонятно, где на самом деле начинается экран, кто отвечает за загрузку данных, где лучше хранить текущее состояние, кто реагирует на ошибки и кто имеет право менять отображение напрямую.
Из этого следует простой вывод. Не нужно строить дворец из паттернов. Но нужно хотя бы договориться с самим собой, какие части у приложения есть и за что они отвечают. Без этого код быстро превращается в среду, где всё знает обо всём и всё может вмешаться во всё. Сегодня это кажется удобным. Завтра становится невыносимым. Архитектура маленького SPA — это в первую очередь не про абстракции, а про границы.
Состояние и представление — это не одно и то же
Первое, с чего стоит начать, — различать состояние приложения и представление. Очень легко попасть в ловушку, когда источником правды становится DOM: где-то стоит активный класс, где-то скрыт блок, где-то заполнено поле, где-то на странице есть нужный текст — значит, вроде бы по интерфейсу можно понять, в каком состоянии находится приложение. Но такой подход почти всегда ломает сопровождение. DOM должен быть следствием состояния, а не его заменой. Даже при очень простой архитектуре полезно держать в голове одну мысль: приложение должно знать, что с ним происходит, не только по тому, что нарисовано на экране.
Это особенно важно там, где есть загрузка данных. Маленький SPA почти всегда работает с сервером хотя бы в минимальном виде. И тут начинается одна из самых частых ошибок: запросы оказываются размазаны по всем слоям. Один view сам стучится в API, другой обновляет DOM после ответа, третий ещё и записывает что-то в глобальный объект, роутер иногда тоже инициирует загрузку, а обработчик формы прямо внутри себя перерисовывает кусок интерфейса после успешного ответа. На короткой дистанции это выглядит как скорость. На средней — как расползающийся хаос. Чем меньше приложение, тем важнее заранее договориться: кто отвечает за запросы, кто получает данные, кто хранит результат и кто решает, что теперь должно отобразиться.
Роутер должен маршрутизировать, а не становиться складом логики
Хорошая новость в том, что для наведения порядка не нужна тяжёлая теория. Достаточно нескольких практических принципов. Первый из них: роутер должен маршрутизировать, а не превращаться в склад бизнес-логики. Его задача — понять, какой экран или состояние нужно показать по данному URL. Он может запускать нужный процесс, но не должен разрастаться до места, где хранятся данные, происходит рендер, проверяется авторизация, собираются шаблоны и решаются все прочие вопросы. Как только роутер начинает знать слишком много, он становится трудно изменяемым узлом, от которого зависит почти всё приложение.
Второй принцип касается представлений. Они должны отвечать за отображение, а не за весь жизненный цикл данных. Это не значит, что view обязан быть абсолютно тупым и ничего не уметь. Но полезно избегать ситуации, где он и рендерит, и сам загружает данные, и знает о маршрутах, и решает, куда перенаправить пользователя, и формирует уведомления, и меняет глобальное состояние. Когда один UI-блок берёт на себя столько ролей, он перестаёт быть представлением и превращается в бесформенный центр приложения. Снаружи это часто выглядит как «ну так же удобнее, всё в одном месте». На деле это один из самых быстрых путей к мешанине.
Третий принцип — выделить отдельный слой для работы с данными или модель состояния, даже если он выглядит скромно. Фронтенд уже достаточно взрослый, чтобы перестать делать вид, будто вся логика может безнаказанно жить прямо в DOM-обработчиках. Не обязательно сразу строить сложную MV*-конструкцию только потому, что так делают большие фреймворки. Но хотя бы минимальный центр, который знает текущее состояние экрана, загруженные данные, выбранный элемент, активный фильтр или текущего пользователя, заметно упрощает жизнь. Как только состояние становится явным, код перестаёт быть набором реакций и начинает выглядеть как система с понятными правилами.
Глобальные события и переменные стирают границы незаметно
Отдельная опасная зона маленького SPA — глобальные события и глобальные переменные. Они кажутся удобными, потому что позволяют быстро связать части приложения без лишней формальности. Нужно сообщить одному модулю, что другой что-то сделал? Бросили глобальное событие. Нужно быстро сохранить выбранный объект? Положили его в общий namespace. Нужно из любой точки дотянуться до данных пользователя? Завели глобальный currentUser. Всё это кажется безобидным, пока приложение совсем маленькое. Беда в том, что такие решения накапливаются незаметно. В один момент вы обнаруживаете, что уже не понимаете, кто и когда меняет важные данные, какое событие откуда прилетает и почему очередной экран ведёт себя странно после перехода назад.
Глобальные механизмы стоит использовать осторожно. Не потому, что они всегда зло, а потому, что они стирают границы. И здесь кроется парадокс: чем меньше приложение, тем сильнее соблазн связывать всё напрямую — но именно для маленького SPA прямые и неформальные связи часто оказываются особенно разрушительными. Структура и так хрупкая, и любая неявность быстро становится центром путаницы. Гораздо полезнее, когда зависимости видны: если модуль зависит от хранилища данных, он получает его явно; если экран требует загрузки сущностей, это видно в его инициализации; если действие меняет состояние, понятно, где именно это происходит.
Структура папок не обязана быть сложной, но обязана быть предсказуемой
Беспорядок в маленьком SPA часто начинается именно с папок и файлов. Нет ничего плохого в том, чтобы стартовать просто. Но «просто» не должно означать «без принципа». Если сегодня в проекте пять файлов, это не повод складывать в каждый из них всё, что поместится. Хорошая структура не обязана быть сложной, зато обязана быть предсказуемой. Если у вас есть представления, модели, маршруты, утилиты и шаблоны, пусть у них будут понятные места. Если приложение делится на экраны или модули, это тоже стоит отразить в структуре. Желательно, чтобы новый человек, открыв проект, мог быстро понять, где искать рендер, где — работу с API, где — логику маршрутов, а где — общие функции. Это не педантизм, а способ снизить хаос заранее.
Один из самых неприятных симптомов мешанины — когда код организуется не по смыслу, а по истории появления. Появилась новая задача — добавили файл рядом. Потом ещё один. Потом часть старой логики пришлось скопировать и чуть изменить. Потом выяснилось, что функции из helpers.js используются только на одном экране, но никто не хочет их переносить. Потом view разросся, и в него просто начали добавлять методы, потому что «он уже всё равно большой». Так проект превращается в археологическую карту решений, принятых под давлением момента. Чтобы этого избежать, нужно время от времени смотреть на структуру не с точки зрения «оно работает», а с точки зрения «понятно ли, как этим жить дальше».
У каждого модуля — ограниченный набор обязанностей
Маленькому SPA особенно полезна дисциплина простых интерфейсов между частями приложения. Звучит академично, но на практике речь о банальной вещи: каждому модулю нужно дать ограниченный набор обязанностей и не разрешать ему общаться со всем миром без меры. Если view умеет рендериться и реагировать на действия пользователя — отлично, но ему не обязательно знать детали всех API-запросов. Если слой работы с данными общается с сервером — хорошо, но ему не нужно вручную менять DOM. Если роутер переключает экран — замечательно, но он не обязан сам формировать HTML. Чем меньше пересечений между ролями, тем меньше вероятность, что через месяц любую правку придётся протаскивать через полпроекта.
Здесь же стоит сказать про рендер и шаблоны, потому что разметка часто становится жертвой спешки. Её или вставляют строками прямо в JavaScript, или размазывают по кускам, или держат в шаблонах, слишком далёких от логики экрана. Универсального рецепта нет, выбор зависит от инструментария. Но общий принцип прост: способ рендеринга должен быть единообразным. Если часть приложения строится через шаблоны одного типа, часть — через ручную сборку HTML-строк, а часть — через прямые DOM-манипуляции, поддерживать станет тяжело даже простые экраны. Маленький SPA выигрывает не от самого модного способа рендера, а от последовательности. Один подход, понятный всем, почти всегда лучше трёх смешанных.
Жизненный цикл экрана нельзя оставлять на волю случая
Распространённая ошибка — недооценка жизненного цикла экрана. В обычной странице это ощущается слабее: открыл, посмотрел, ушёл. В SPA экран может появляться, обновляться, скрываться, открываться снова. У него бывают подписки на события, таймеры, обработчики, временное состояние, результаты загрузки. Если не думать о том, как экран создаётся и как уничтожается или очищается, код начинает течь в разных смыслах сразу. Остаются висящие обработчики. Старые данные подмешиваются к новым. Визуальные состояния переживают навигацию, хотя не должны. Поэтому даже в небольшом приложении полезно иметь ясные правила: когда view инициализируется, когда запрашивает данные, когда рендерится повторно, когда снимает подписки и когда очищает за собой следы.
Это, кстати, ещё одна причина не смешивать всё в одном месте. Когда рендер, запросы, события и состояние живут вперемешку, аккуратно управлять жизненным циклом невозможно. Всё держится на надежде, что конкретная последовательность действий всегда будет именно такой, как ожидалось. Но пользователь рано или поздно найдёт способ пройти по приложению не тем маршрутом, который разработчик прокрутил у себя в голове.
Главный диагностический вопрос: где сейчас источник правды
Маленькие SPA очень выигрывают от одного вопроса, который стоит задавать при каждом заметном изменении: где теперь находится источник правды? После фильтрации списка это состояние хранится в DOM, в view, в роуте, в модели данных или в URL? После логина информация о пользователе живёт где? После сохранения формы кто знает, что данные изменились? Если на такие вопросы нельзя быстро ответить, значит, архитектура уже начинает расползаться. Прелесть маленького приложения в том, что такие проблемы ещё можно заметить рано. И именно поэтому ими стоит заниматься сразу, а не ждать, пока беспорядок закрепится как норма.
Сюда же примыкает тестируемость, о которой в небольших проектах часто вспоминают в последнюю очередь. Хорошая архитектура полезна не только для тестов, но тесты отлично показывают, где структура хрупкая. Если кусок логики невозможно проверить без поднятия всего интерфейса, если API-запросы намертво привязаны к view, если состояние размазано по обработчикам, если бизнес-правило спрятано внутри DOM-манипуляции — это почти всегда симптом неудачного разделения обязанностей. Даже без полного набора тестов мысль о том, можно ли отдельно проверить важную логику, заметно дисциплинирует проектирование.
Слой абстракции на два экрана вредит не меньше, чем хаос
Здесь важно не свалиться в другую крайность. Иногда архитектура превращается в беду не из-за недостатка структуры, а из-за попытки заранее покрыть все возможные будущие сценарии. Разработчик начитывается про паттерны, смотрит на большие фреймворки и встраивает в крошечное приложение все уровни абстракции сразу. В результате проект становится тяжёлым раньше, чем возникает реальная сложность. Архитектура нужна не для самоуспокоения, а для управления текущей сложностью. Поэтому лучшая архитектура маленького SPA обычно не самая умная, а самая ясная. Она решает реальные проблемы приложения, а не гипотетические задачи масштаба, которого пока нет.
Приземлим до конкретики. Если у вас два экрана — список сущностей и форма редактирования, — совершенно не обязательно строить гигантский слой абстракции над каждым запросом и над каждой кнопкой. Но уже полезно иметь единый модуль API, единый способ хранения текущих данных, понятные view для экранов и простой роутинг без лишней логики. Такой уровень дисциплины почти не замедляет старт, зато резко уменьшает шанс, что через месяц приложение будет трудно менять даже в мелочах. Цена у дисциплины есть — это несколько минут на договорённости с собой в самом начале. Но это самая дешёвая инвестиция из всех возможных.
Есть и психологическая ловушка: желание «переписать потом нормально». В маленьком SPA эта фраза особенно коварна, потому что кажется, будто проект небольшой и привести его в порядок позже будет легко. На практике позже появляются новая функциональность, сроки, баги, ещё один экран, ещё одна интеграция, и никакого «потом» уже нет. Плохая архитектура закрепляется привычкой: люди учатся обходить её углы, а не исправлять основу. Поэтому лучший момент для наведения порядка — не после хаоса, а за шаг до него. Не нужно строить монумент, но нужно хотя бы не разбрасывать кирпичи как попало.
Итог
Если свести всё к одной формуле, архитектура маленького SPA — это искусство не переусложнить и не распустить. С одной стороны, не хочется тянуть в проект все тяжёлые идеи больших приложений. С другой — нельзя делать вид, что single-page application можно без последствий строить как набор случайных jQuery-реакций и файлов без чёткой роли. Хороший баланс обычно выглядит так: явное состояние, понятный роутинг, аккуратные представления, отдельная работа с данными, минимум глобальной магии, последовательный способ рендера и ясная структура файлов. Этого достаточно, чтобы маленький проект оставался маленьким не только по размеру, но и по уровню боли.
Это особенно актуально сейчас, когда «немного JavaScript на странице» всё чаще превращается в полноценное приложение в браузере. А у приложений есть неприятная привычка расти быстрее, чем ожидалось. Сегодня ваш SPA маленький. Завтра у него появятся новые состояния, формы, маршруты, права доступа, кеширование, синхронизация с сервером и несколько сценариев загрузки. Если основа изначально сделана как мешанина, любой рост будет стоить вдвойне.
Относитесь к маленькому SPA как к приложению с первого дня, но не притворяйтесь, что это гигантская платформа: дайте коду границы раньше, чем он обрастёт случайными связями, не храните смысл в DOM, не позволяйте роутеру, view и API-слою слиться в один неразличимый ком — и добейтесь, чтобы в любой момент было понятно, кто за что отвечает. Именно это отличает компактную архитектуру от мешанины, даже когда проект ещё совсем небольшой.