React Native или NativeScript: где JavaScript даёт нативный опыт, а где начинаются компромиссы

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

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

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

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

Этот спор уже нельзя вести на уровне лозунгов. Слишком много было сказано, слишком много слайдов показано, слишком много надежд вложено в мобильный JavaScript. Если сегодня сравнивать React Native и NativeScript всерьез, то не в терминах «какой лучше вообще», а в терминах «какой из них честнее решает задачу и где именно разработчику придется платить за удобство». Потому что оба подхода обещают нативный опыт, но ни один не избавляет от цены полностью. Вопрос лишь в том, как именно эта цена распределена.

Почему это сравнение вообще стало важным именно сейчас

До недавнего времени выбор у JavaScript-команды в мобильной среде часто выглядел слишком простым и потому слишком печальным. Либо идти в классическую гибридную разработку с PhoneGap, Cordova, Ionic и всем набором достоинств и хронических ограничений, связанных с WebView. Либо признать, что если нужен по-настоящему высокий стандарт мобильного интерфейса, придется осваивать нативные платформы по их собственным правилам. Иными словами, либо скорость входа и общее веб-мышление, либо более убедительное поведение приложения, но ценой отдельных стеков, отдельных специалистов и отдельной архитектурной культуры.

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

NativeScript оказался именно в такой позиции. Это не «ответ» на React Native, как иногда упрощают спор, а самостоятельная попытка решить похожую проблему иным способом. И когда на рынке одновременно оказываются два подхода, оба обещающие нативный UI без WebView в центре всей конструкции, неизбежно возникает более взрослый вопрос: если оба говорят о нативности, то где именно она проявляется для пользователя, а где компромиссы просто скрыты чуть глубже в техническом устройстве системы?

Главное сходство: это уже не история про браузер в коробке

Чтобы разговор не запутался с самого начала, полезно подчеркнуть самое важное: и React Native, и NativeScript интересны прежде всего потому, что они пытаются уйти от старой веб-оболочной логики. Для рынка мобильного JavaScript это уже почти исторический перелом. Слишком долго слово «JavaScript-приложение» автоматически означало компромисс в самом центре интерфейса. Пользователь касался экрана и рано или поздно чувствовал: перед ним нечто, что только изображает мобильное приложение, но живет по веб-законам.

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

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

React Native: сила компонентного мышления и управляемой абстракции

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

React Native не обещает, что одна и та же кодовая база как по волшебству решит всю мобильную задачу без различий между платформами. И в этом как раз одно из его достоинств. Формула «learn once, write anywhere» звучит трезвее, чем старые мечты о «write once, run anywhere». Она не скрывает, что iOS и Android — разные миры, у которых разные паттерны, разное поведение интерфейса и разные ожидания пользователей. Но она обещает другое: вы можете мыслить в единой архитектурной системе и переносить этот способ работы между платформами.

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

NativeScript: более прямой доступ к платформе и другой характер близости к нативному миру

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

Для некоторых команд это невероятно сильный аргумент. Особенно для тех, кто хочет не столько красивый архитектурный слой поверх мобильной разработки, сколько максимально широкий практический доступ к возможностям iOS и Android, оставаясь в знакомом языке. NativeScript в таком чтении выглядит менее «философским» и более прикладным. Он как будто говорит разработчику: вот платформа, вот ее объекты, вот нативные возможности, работай с ними напрямую, не притворяясь, что мобильная среда полностью растворилась в вашей абстракции.

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

Где пользователь реально чувствует нативный опыт

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

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

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

Где начинаются компромиссы у React Native

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

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

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

Где начинаются компромиссы у NativeScript

У NativeScript компромиссы иного рода. Он выглядит особенно привлекательно там, где нужно быть ближе к платформенным API и не зависеть от слишком узкой модели описания интерфейса и поведения. Но именно эта близость может разрушать то ощущение «единой JavaScript-разработки», ради которого многие вообще приходят в такие инструменты. Чем шире доступ к нативной реальности, тем чаще команда вспоминает, что она работает не с одним абстрактным мобильным миром, а с двумя конкретными платформами, каждая из которых живет по своим правилам.

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

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

Что важнее для команды: современная модель интерфейса или более прямой нативный доступ

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

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

Если же приложение требует особенно тесной работы с нативными возможностями, если команда не боится платформенной конкретики и хочет использовать JavaScript не столько как язык абстракции, сколько как язык доступа к мобильным API, NativeScript может показаться более честным инструментом. Он не так настойчиво старается спрятать платформу за красивой философией. Для кого-то это недостаток. Для кого-то — важнейшее достоинство.

Что это означает для обычного проекта, а не для технологического спора

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

Если же перед вами задача, где мобильное приложение должно глубоко и разнообразно взаимодействовать с платформой, где важно ощущение широкого нативного доступа из JavaScript, где команда готова жить ближе к устройству и не боится того, что платформа будет чаще «просвечивать» сквозь абстракцию, NativeScript может оказаться разумнее. Вопрос не в том, у кого рекламный тезис громче, а в том, какая именно форма компромисса лучше сочетается с вашей задачей.

Именно слово «форма» здесь особенно важно. Потому что компромиссы есть в обоих случаях. React Native жертвует абсолютной близостью к платформе ради более стройной модели разработки. NativeScript жертвует легкостью полного абстрагирования от платформы ради более прямого и мощного доступа к нативной среде. Победителя «вообще» здесь, скорее всего, нет. Зато есть очень ясный выбор между двумя стилями инженерной жизни.

Миф о полном исчезновении нативной сложности

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

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

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

Так где же JavaScript действительно даёт нативный опыт?

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

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

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

Мобильный JavaScript перестал оправдываться и начал предлагать выбор

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

React Native сегодня выглядит как более сильный культурный и архитектурный импульс. За ним стоит мощная волна сообщества, современная модель UI-разработки и чрезвычайно привлекательный мост между фронтендом и мобильным миром. NativeScript выглядит как более прямой, более платформенно смелый и для некоторых задач очень убедительный ответ на вопрос, как дать JavaScript реальный доступ к нативной среде без возвращения к WebView-компромиссу.

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

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

Автор

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

Обновлено

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