Новая архитектура React Native простыми словами: Fabric, TurboModules и зачем это вообще нужно

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

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

У React Native есть одна давняя проблема восприятия. Когда о нем говорят снаружи, особенно люди, которые не живут в его экосистеме каждый день, спор почти всегда сводится к довольно грубой формуле: либо это удобный способ писать мобильные приложения на JavaScript и делить большую часть логики между платформами, либо это компромисс, который рано или поздно упрется в собственные технические ограничения. Долгое время обе стороны в этом споре могли привести достаточно убедительные аргументы. React Native и правда доказал, что способен быть серьезным производственным стеком. Но он также годами тащил за собой архитектурный груз, который особенно неприятно проявлялся именно там, где продукт становился крупнее, интерфейс — богаче, а взаимодействие между JavaScript и нативным слоем — более интенсивным.

Именно поэтому разговор о новой архитектуре React Native в 2022 году перестал быть внутренней темой для людей, которые следят за релизными заметками. Это уже вопрос не только к авторам библиотек и не только к тем, кто любит копаться в устройстве рантайма. Это вопрос ко всей экосистеме: может ли React Native перестать жить с некоторыми из своих самых старых и самых раздражающих ограничений, не потеряв того, что сделало его популярным? Может ли он стать не просто удобным, а более технически зрелым фундаментом для следующего этапа развития?

На этом фоне слова вроде Fabric и TurboModules звучат одновременно важно и утомительно. Важно — потому что за ними стоит реальное изменение внутренней модели работы React Native. Утомительно — потому что сама подача темы часто выглядит так, будто без чтения нескольких инженерных докладов и десятка RFC человеку просто нечего делать в этой дискуссии. На практике всё можно объяснить гораздо проще. Новая архитектура нужна не ради красивого набора новых названий. Она нужна потому, что старая архитектура слишком долго заставляла React Native жить с задержками, лишней сложностью моста между JavaScript и нативным кодом, трудностями масштабирования и неудобной ценой за вполне естественные современные требования к интерфейсу и производительности.

Почему вообще понадобилось что-то ломать и перестраивать

Чтобы понять смысл новой архитектуры, полезно сначала честно назвать старую проблему без лишнего благоговения. React Native долгое время держался на модели, которая в свое время была очень сильной: JavaScript-код живет отдельно, нативный слой живет отдельно, а между ними работает мост, через который передаются команды, данные и события. Для раннего этапа развития React Native это было достаточным и даже элегантным решением. Оно позволяло быстро строить кроссплатформенный слой, не заставляя разработчика писать всё на Swift, Objective-C, Java или Kotlin. На этой модели выросло огромное количество приложений, и она доказала свою жизнеспособность.

Но по мере взросления самого React Native и роста требований к мобильным интерфейсам оказалось, что такой мост — это одновременно и сила, и хронический источник трения. Он делает систему достаточно гибкой, но добавляет стоимость практически любому сложному взаимодействию между JavaScript и нативным миром. Чем чаще и чем интенсивнее эти миры должны разговаривать друг с другом, тем заметнее становится цена такого разговора. А в современном мобильном приложении таких разговоров много. Анимации, жесты, сложные списки, богатые UI-компоненты, синхронные требования интерфейса, интеграции с нативными возможностями — всё это плохо сочетается с архитектурой, где важная часть взаимодействия идет через старый асинхронный мост как через узкий коридор.

Есть и еще одна причина, менее заметная снаружи, но очень важная для экосистемы. Старая архитектура делала сам React Native и библиотеки вокруг него сложнее в сопровождении. Добавлять новые нативные возможности, писать и поддерживать модули, строить более мощные UI-абстракции — всё это часто приходилось делать поверх механизма, который исторически сложился удачно, но не выглядел идеальным для следующего десятилетия развития. В какой-то момент стало ясно: дальше уже недостаточно латать старый фундамент. Нужна более глубокая перестройка.

Главная идея новой архитектуры в одном абзаце

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

Fabric отвечает прежде всего за новый UI-слой и рендеринг. TurboModules — за новый способ работы нативных модулей. Вокруг этого есть и другие важные части, включая более современный подход к вызовам между JavaScript и нативным кодом, но если объяснять без перегруза, то именно Fabric и TurboModules являются двумя самыми заметными опорными столбами новой архитектуры. Один меняет то, как React Native строит и обновляет интерфейс. Второй меняет то, как приложение получает доступ к нативным возможностям.

Вопрос “зачем это вообще нужно” на этом месте уже начинает звучать проще. Нужно затем, чтобы React Native меньше напоминал удачный исторический компромисс и больше — современную платформу, способную жить с конкурентным UI, сложными интеракциями и большим масштабом приложения без постоянного ощущения, что ты всё еще заложник решений, придуманных для более ранней эпохи.

Что такое Fabric простыми словами

Fabric — это новый рендерер пользовательского интерфейса в React Native. Если не уходить в специальные внутренние детали, его можно представить как более современный способ превращать React-компоненты в реальные нативные представления на экране. Старый подход в React Native тоже делал это, конечно, но делал в рамках архитектуры, где между React-логикой и нативным UI было больше исторически накопленного трения. Fabric нужен затем, чтобы этот путь стал короче, согласованнее и лучше встроенным в современную модель React.

Очень важно понять, что Fabric — это не “новый набор красивых компонентов” и не визуальная библиотека. Пользователь не увидит на экране кнопки с надписью “сделано на Fabric”. Это низкоуровневое изменение того, как React Native вообще работает с интерфейсом. Он должен лучше обновлять UI, лучше согласовывать внутреннее состояние React и нативного дерева представлений и, что особенно важно, быть ближе к тому направлению, в котором развивается сам React как система рендеринга и конкурентной работы с интерфейсом.

С точки зрения разработчика продукта это важно потому, что UI в React Native давно перестал быть просто “несколько экранов и список”. Современные приложения требуют сложной анимации, богатых списков, многослойных переходов, более чувствительного отклика и более предсказуемого поведения обновлений. Fabric не обещает магии, которая автоматически сделает каждый интерфейс идеальным. Но он перестраивает сам фундамент так, чтобы React Native лучше переносил эти требования и меньше зависел от старых архитектурных обходов.

Почему старый UI-слой уже выглядел недостаточно современным

Чтобы почувствовать смысл Fabric, не обязательно читать внутренние схемы. Достаточно вспомнить, как часто разговор о производительности React Native раньше сводился к одному и тому же набору симптомов. Сложные списки требуют особого внимания. Интерактивные анимации и жесты приходится проектировать с оглядкой на архитектурные ограничения. Богатый интерфейс начинает особенно чувствительно наказывать за плохую синхронизацию между JavaScript-слоем и нативным UI. Компоненты нередко ведут себя так, будто между намерением React и тем, что реально происходит на экране, живет не совсем прозрачный посредник.

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

Fabric важен именно потому, что он пытается перенести разговор о UI с уровня “как бы обойти старые ограничения” на уровень “как строить современный интерфейс на более подходящем фундаменте”. Это не избавляет разработчика от необходимости думать о производительности, но делает саму платформу менее мешающей. А для зрелой технологии это уже огромный шаг.

Что такое TurboModules простыми словами

Если Fabric — это история про интерфейс, то TurboModules — история про нативные модули. Под нативными модулями в React Native обычно понимают те части приложения, которые дают JavaScript-коду доступ к возможностям устройства или к нативной логике. Камера, файловая система, биометрия, локальное хранилище, интеграции со сторонними SDK, системные сервисы — всё это так или иначе требует связи с нативным слоем.

Старый способ работы с такими модулями во многом зависел от той же архитектуры моста. Это означало, что вызовы были более тяжеловесными, чем хотелось бы, а сама модель подключения модулей — менее современной и менее эффективной, особенно на большом масштабе. TurboModules — это попытка сделать нативные модули более быстрыми, более прямыми в использовании и лучше вписанными в новую архитектуру React Native.

Если объяснять еще проще, то TurboModules нужны затем, чтобы общение JavaScript-кода с нативными возможностями стало менее архаичным и менее дорогим. Не обязательно в каждом отдельном вызове это будет драматический скачок, который пользователь почувствует мгновенно. Но в сумме, на масштабе большого приложения и большой экосистемы, это означает более здоровую модель работы всей платформы. А именно такие изменения и отличают косметическое обновление от настоящей архитектурной перестройки.

Почему старые модули тоже стали узким местом

На раннем этапе развития React Native самой идеей нативных модулей уже можно было восхищаться. Веб-разработчик на JavaScript получает доступ к возможностям мобильной платформы без необходимости полностью уходить в нативный мир. Это действительно было сильным инженерным достижением. Но с годами стало понятно, что сама модель подключения и вызова модулей уже не выглядит такой легкой и естественной, как хотелось бы для зрелой экосистемы.

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

TurboModules — это не просто “быстрее открывается камера”. Это попытка сделать саму систему нативных возможностей менее исторической и более пригодной для будущего. Разница может казаться абстрактной, пока не думаешь о том, сколько библиотек и сколько критических для бизнеса функций в реальном приложении завязаны на этот слой. А когда начинаешь думать, становится понятно, что именно здесь и скрывается одна из самых дорогих старых проблем React Native.

Почему все время всплывает тема моста

Почти любой разговор о новой архитектуре React Native рано или поздно возвращается к мосту между JavaScript и нативным слоем. Для людей, которые не любят копаться во внутренностях платформы, это часто начинает звучать как какой-то культовый инженерный символ. Но причина, по которой мост так важен, довольно проста. Если ваша платформа построена вокруг идеи, что логика живет в одном мире, интерфейс и системные возможности — в другом, а между ними идет постоянный обмен, то характер этого обмена определяет практически всё: отзывчивость, стоимость сложных сценариев, удобство библиотек, поведение UI и даже эмоциональное ощущение “современности” стека.

Старый мост в React Native не был ошибкой. Он был решением своего времени. Но сегодня всё заметнее, что он стал ограничением не только для экстремальных кейсов, но и для вполне обычной эволюции платформы. React Native больше не живет в эпохе, когда достаточно “как-то” связать JavaScript и нативный код. Теперь требуется более плотная, более быстрая и более естественная модель взаимодействия.

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

Зачем это нужно обычной команде, а не только авторам библиотек

Есть соблазн сказать, что Fabric и TurboModules — это тема для платформенных инженеров, а обычной продуктовой команде важны только экраны, формы, списки и релизы. В короткой перспективе это может звучать убедительно. Но проблема в том, что архитектурные ограничения платформы рано или поздно просачиваются в повседневную жизнь любой серьезной команды. Они проявляются в виде странных компромиссов при проектировании интерфейса, в виде дополнительных усилий вокруг производительности, в виде более хрупких интеграций, в виде библиотек, которые живут сложнее, чем хотелось бы.

Обычная команда не обязана знать каждую внутреннюю деталь новой архитектуры. Но ей важно понимать, что всё это делается не ради абстрактного “технического долга Meta”, а ради вполне прикладных последствий. Более предсказуемый UI, более современный рендеринг, более здоровые нативные модули, меньше зависимости от старых архитектурных уступок — всё это влияет на то, насколько комфортно React Native будет жить в проекте через год, два и три.

Проще говоря, даже если ваш бизнес не обсуждает TurboModules на планерках, он вполне обсуждает скорость команды, надежность интеграций и стоимость поддержки приложения. А новая архитектура нужна как раз затем, чтобы улучшить фундамент под этими вещами. Это не значит, что результат придет мгновенно. Но это значит, что направление движения у платформы наконец стало достаточно ясным и достаточно важным, чтобы его нельзя было игнорировать.

Что новая архитектура не обещает

Вокруг таких больших перестроек всегда легко возникает лишний энтузиазм. Самая вредная реакция на новость про Fabric и TurboModules — услышать слово “новая архитектура” и решить, что теперь производительность станет чьей-то чужой проблемой. Поэтому полезно сразу сказать, чего новая архитектура не обещает. Она не делает плохое приложение хорошим автоматически. Она не отменяет необходимость писать аккуратный UI, думать о списках, следить за состоянием, уважать ограничения мобильных устройств и не строить безумные интерфейсные монстры только потому, что слово Fabric звучит современно. Новая архитектура не выдает бесплатную производительность каждому проекту без оглядки на качество самого кода.

Она также не означает, что весь рынок React Native внезапно проснется завтра в идеальном состоянии. Большая экосистема всегда движется постепенно. Библиотеки адаптируются не мгновенно. Команды мигрируют не одновременно. У кого-то переход пройдет спокойно, у кого-то он станет источником усталости, потому что крупные архитектурные обновления почти никогда не бывают полностью безболезненными. И это нормальная цена эволюции зрелой платформы.

Самое главное — новая архитектура не является чисто маркетинговой победой. Она не нужна, чтобы просто написать “у нас теперь Fabric” в презентации для руководства. Если использовать ее именно так, разочарование наступит быстро. Ее ценность в том, что она должна постепенно изменить качество самого фундамента, на котором строится React Native. Это история про годы и про масштаб экосистемы, а не про мгновенный вау-эффект на одном демо.

Этот разговор важен не сам по себе, а из-за фазы зрелости платформы

React Native сейчас находится в интересной фазе зрелости. Он уже достаточно взрослый, чтобы никто не мог списывать его как красивый эксперимент для MVP. Но он также уже достаточно взрослый, чтобы старая архитектура начала восприниматься не как просто “историческая особенность”, а как реальное препятствие к следующему этапу развития. Именно в такой момент платформе особенно нужна внутренняя перестройка. Иначе она рискует оказаться в неприятной ловушке: снаружи все еще популярная, внутри — всё более дорогая в сопровождении и всё менее естественная для новых требований.

В этом смысле текущий момент — не точка, а поворот. React Native не просто полирует края. Он пытается доказать, что способен меняться на уровне архитектурного ядра. Для бизнеса это важно потому, что выбор платформы — всегда ставка не только на настоящее, но и на будущее. Для экосистемы это важно потому, что без такого движения все разговоры о зрелости React Native постепенно начали бы звучать неубедительно.

Новая архитектура — это по сути ответ на вопрос: готов ли React Native к следующему десятилетию как платформа, а не просто как популярный набор компромиссов. И сам факт, что этот вопрос уже задается в столь практической форме, многое говорит о том, насколько серьезным стал сам стек.

Как это объяснить совсем без технической шелухи

Если представить React Native как большой офис, то старая архитектура долго работала так: дизайнеры и менеджеры сидят в одном крыле, инженеры интерфейса — в другом, а все важные поручения и ответы ходят через длинный коридор с секретарем, который передает бумажки туда-сюда. Офис работает. Иногда даже очень неплохо. Но как только задач становится много, начинается ощущение пробки. Кто-то ждет. Кто-то пересылает одно и то же. Кто-то страдает не потому, что его идея плохая, а потому что путь между частями системы слишком неудобен.

Новая архитектура пытается не просто ускорить секретаря. Она перестраивает офис так, чтобы отделы были ближе друг к другу, чтобы часть общения происходила естественнее, а сами роли были организованы современнее. Fabric — это про то, как быстрее и понятнее строится и обновляется сам рабочий зал, то есть интерфейс. TurboModules — про то, как проще и прямее сотрудники получают доступ к специальным инструментам и внешним службам, то есть к нативным возможностям.

Никто снаружи не придет в восторг от одного факта, что вы перестроили офис. Но если после этого сотрудники меньше тратят время на пересылку бумажек и больше — на саму работу, то через некоторое время разница становится заметной всем. Примерно в этом и состоит смысл новой архитектуры React Native.

Что стоит думать об этом продуктовой команде прямо сейчас

Продуктовой команде полезно думать о новой архитектуре спокойно. Не как о срочной религиозной обязанности и не как о чем-то, что можно полностью игнорировать. Это не тот случай, когда нужно в панике переписывать приложение только потому, что появились новые слова в документации. Но и не тот случай, когда можно отмахнуться фразой “нас это не касается, у нас просто мобильное приложение”. Если вы живете в React Native, это касается вас уже хотя бы потому, что экосистема библиотек, модулей и UI-компонентов постепенно будет двигаться именно в эту сторону.

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

То есть думать нужно не в режиме “срочно ли нам нужен Fabric”, а в режиме “насколько мы готовы жить на платформе, которая меняет фундамент, и как это совпадает с нашим горизонтом развития”. Это куда взрослее и полезнее, чем просто спорить о терминах.

Итак, зачем всё это вообще нужно?

Если подвести всё к самому простому выводу, то новая архитектура React Native нужна затем, чтобы платформа перестала быть слишком зависимой от своего прошлого. Fabric нужен, чтобы UI-слой работал современнее, ближе к сегодняшнему React и лучше выдерживал требования богатого мобильного интерфейса. TurboModules нужны, чтобы доступ к нативным возможностям был быстрее, чище и менее архаичным. Вместе они нужны затем, чтобы React Native меньше походил на удачно выжившую архитектуру 2015 года и больше — на платформу, готовую к требованиям второй половины 2020-х.

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

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

Итог

Новая архитектура нужна не ради красивого набора названий: Fabric перестраивает UI-слой и рендеринг, TurboModules — способ работы нативных модулей, а вместе они ослабляют зависимость React Native от старого асинхронного моста между JavaScript и нативным миром. Важно не свалиться в энтузиазм: это не революция, после которой каждое приложение мгновенно ускоряется, и не завершённый переход — для большинства проектов в августе 2022 года это скорее область подготовки, совместимости и оценки зависимостей, чем повседневность.

Если сформулировать главный вывод совсем прямо, он будет таким: новая архитектура — это не маркетинговая победа и не мгновенный вау-эффект на одном демо, а инвестиция в фундамент: её ценность проявляется на масштабе экосистемы и горизонте лет, и продуктовой команде важно не “срочно ли нам нужен Fabric”, а насколько её горизонт развития совпадает с платформой, которая меняет своё ядро.

Автор

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

Обновлено

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