Jak zacząć projekt w React Native – Expo czy React Native CLI?

Expo – definicja i zastosowanie

Expo to otwartoźródłowa platforma oraz framework oparty na React Native, zaprojektowany, aby upraszczać tworzenie aplikacji mobilnych. Można o nim myśleć jak o odpowiedniku Create React App ze świata webowego, ale dla aplikacji mobilnych – Expo buduje za Ciebie podstawową strukturę projektu, dzięki czemu nie musisz od razu zagłębiać się w natywne konfiguracje​. Expo dostarcza tzw. zarządzany workflow (managed workflow), gdzie wiele aspektów natywnej konfiguracji jest obsługiwanych automatycznie przez narzędzia Expo.

W praktyce Expo składa się z kilku elementów. Głównym z nich jest Expo CLI – narzędzie wiersza poleceń, za pomocą którego tworzysz i obsługujesz projekt Expo. Kolejny ważny element to Expo Go – aplikacja mobilna dostępna w Google Play i App Store, która pozwala uruchamiać i testować tworzoną aplikację bez potrzeby budowania natywnego pliku APK/IPA. Wystarczy zeskanować kod QR wygenerowany przez Expo CLI, aby w kilka sekund zobaczyć swoją aplikację na telefonie​. Expo oferuje również usługi takie jak EAS (Expo Application Services), m.in. EAS Build do budowania aplikacji w chmurze oraz EAS Update do wdrażania aktualizacji over-the-air.

Zalety Expo:

• Niski próg wejścia – Expo jest przyjazne dla początkujących i pozwala szybko rozpocząć pracę z React Native.
• Prosta konfiguracja – nie musisz instalować Android Studio ani Xcode, by stworzyć aplikację. Wystarczy Node.js oraz Expo CLI.
• Bogaty zestaw gotowych modułów (Expo SDK) – od razu masz dostęp do API takich jak: aparat, powiadomienia push, lokalizacja, akcelerometr i innych.
• Szybkie prototypowanie – możesz skupić się na pisaniu kodu JavaScript/React, zamiast na skomplikowanej konfiguracji natywnej.
• Łatwe testowanie na urządzeniach – aplikację uruchomisz błyskawicznie dzięki Expo Go, bez potrzeby budowania plików APK/IPA.
• Automatyczne odświeżanie (Fast Refresh) – zmiany w kodzie są natychmiast widoczne na telefonie/emulatorze, co przyspiesza development.
• Wsparcie dla OTA updates – dzięki Expo możesz aktualizować aplikację „over-the-air” bez konieczności ponownego publikowania w sklepach.

Wady Expo

• Ograniczony dostęp do natywnych modułów – w zarządzanym workflow nie masz pełnej kontroli nad kodem natywnym. Niektóre biblioteki nie są dostępne w standardowym Expo SDK.
• Brak wsparcia dla wszystkich bibliotek natywnych – jeśli Twoja aplikacja wymaga specyficznych bibliotek natywnych, które nie są zintegrowane z Expo, możesz napotkać trudności.
• Mniejsza elastyczność – choć Expo wprowadziło config plugins oraz development builds, korzystanie z nich wiąże się z dodatkowymi krokami konfiguracyjnymi, a w niektórych przypadkach konieczne może być przejście na bare workflow.
• Większy rozmiar aplikacji – aplikacje zbudowane w Expo bywają większe niż te same aplikacje stworzone w czystym React Native, ponieważ zawierają kod niewykorzystanych modułów Expo.
• Potencjalny wpływ na wydajność – większa waga aplikacji może skutkować nieco gorszą wydajnością na starszych urządzeniach.
• Inny proces budowania aplikacji produkcyjnej – nie możesz używać standardowych komend, takich jak gradlew assembleRelease czy Xcode Archive. Expo wymaga korzystania z usługi EAS Build.
• Koszty EAS Build – darmowa wersja pozwala na ograniczoną liczbę budowań miesięcznie. Wersja płatna może generować dodatkowe koszty (od ~$1 do $4 za pojedyncze buildowanie).
• Lokalne budowanie wymaga dodatkowych kroków – możesz zbudować aplikację lokalnie (eas build --local), ale wtedy tracisz część uproszczeń oferowanych przez Expo i konfiguracja staje się bardziej zbliżona do React Native CLI.

Szukasz wykonawcy aplikacji mobilnej?

Skontaktuj się z nami!

React Native CLI – definicja i zastosowanie

React Native CLI to tradycyjne podejście do tworzenia aplikacji w React Native, polegające na korzystaniu z wiersza poleceń React Native (react-native) i ręcznej konfiguracji środowiska natywnego. Często nazywa się je bare workflow (czystym lub “gołym” trybem) dla odróżnienia od workflow zarządzanego przez Expo. Gdy inicjujesz projekt za pomocą React Native CLI, otrzymujesz pełny, natywny projekt Xcode dla iOS oraz projekt Android (Gradle) dla Androida. Daje Ci to pełną kontrolę nad kodem natywnym aplikacji – możesz modyfikować konfigurację projektu natywnego, dodawać własne pliki Objective-C/Swift lub Java/Kotlin, oraz instalować dowolne biblioteki natywne. Innymi słowy, React Native CLI nie abstrahuje przed Tobą natywnej warstwy, co z jednej strony zapewnia maksymalną elastyczność, a z drugiej wymaga więcej wiedzy i pracy przy konfiguracji.

Zalety React Native CLI:

• Pełna kontrola nad kodem natywnym – możesz modyfikować pliki Android i iOS bez ograniczeń narzuconych przez Expo.
• Brak ograniczeń w użyciu bibliotek natywnych – masz możliwość korzystania z dowolnych bibliotek native modules, nawet tych, które nie są wspierane przez Expo SDK.
• Możliwość tworzenia własnych modułów natywnych – jeśli standardowe rozwiązania nie wystarczą, możesz samodzielnie napisać kod w Java/Kotlin (Android) lub Objective-C/Swift (iOS).
• Lepsza optymalizacja wydajności – masz dostęp do zaawansowanych ustawień kompilacji, np. Gradle i Xcode, co pozwala na lepszą optymalizację aplikacji.
• Mniejszy rozmiar aplikacji – do projektu trafia tylko ten kod i biblioteki, które są faktycznie używane, co przekłada się na mniejsze pliki instalacyjne i lepszą wydajność.
• Elastyczność w budowaniu aplikacji – możesz ręcznie kontrolować procesy kompilacji (gradlew assembleRelease, Xcode Archive) bez konieczności korzystania z usług chmurowych.
• Łatwiejsza integracja z istniejącymi aplikacjami natywnymi – jeśli chcesz dodać React Native do już istniejącej aplikacji iOS/Android, CLI daje pełną swobodę w integracji.
• Popularność w środowisku biznesowym – duże aplikacje produkcyjne częściej wybierają React Native CLI, ponieważ umożliwia dostosowanie projektu do niestandardowych wymagań klientów.

Wady React Native CLI:

• Złożona konfiguracja początkowa – wymaga ręcznej instalacji i konfiguracji środowiska, w tym: Node.js, JDK (Java Development Kit) dla Androida, Android Studio (wraz z Android SDK i emulatorami), Xcode (na macOS) oraz CocoaPods do obsługi zależności iOS.
• Długi czas konfiguracji – w porównaniu do Expo, pierwsze uruchomienie projektu może zająć znacznie więcej czasu, zwłaszcza jeśli środowisko nie było wcześniej skonfigurowane.
• Wysoka krzywa nauki – wymaga znajomości podstaw Androida/iOS, co może stanowić wyzwanie dla początkujących programistów.
• Wymagania sprzętowe – do tworzenia aplikacji na iOS konieczny jest komputer Mac, a uruchamianie emulatorów Androida może wymagać wydajnego sprzętu.
• Problemy z debugowaniem – w razie błędów często trzeba analizować logi Gradle (Android) lub Xcode (iOS), co wymaga dodatkowej wiedzy technicznej.
• Manualna konfiguracja bibliotek natywnych – niektóre biblioteki wymagają ręcznego dodania kluczy API, linkowania zależności czy edycji plików konfiguracyjnych.
• Dłuższy czas uruchamiania aplikacji od zera – zanim zobaczysz pierwsze efekty swojej pracy, musisz przejść przez kilka dodatkowych kroków konfiguracji.
• Brak gotowego rozwiązania dla OTA updates – w przeciwieństwie do Expo, które umożliwia łatwe wdrażanie aktualizacji over-the-air, tutaj musisz samodzielnie zadbać o ten proces.
• Zależność od natywnych procesów kompilacji – kompilacja projektu może być czasochłonna i podatna na problemy wynikające z aktualizacji Android Studio lub Xcode.

Mimo tych trudności, React Native CLI jest niezastąpiony, gdy potrzebujesz pełnej kontroli i skalowalności. Większość dużych aplikacji produkcyjnych tworzona jest właśnie w tym trybie – daje on pewność, że nie napotkasz ograniczeń w miarę rozbudowy projektu i umożliwia integrację z natywnymi projektami (np. dołączenie React Native do istniejącej natywnej aplikacji).

Zobacz także: React Native vs Flutter.

Porównanie Expo i React Native CLI

Poniżej przedstawiamy porównanie najważniejszych aspektów obu podejść:

Praktyczna instalacja Expo

Przejdźmy do praktyki – poniżej znajdziesz instrukcje, jak zainstalować Expo i stworzyć oraz uruchomić nowy projekt React Native za pomocą Expo.

Kroki instalacji i uruchomienia projektu Expo:

1. Zainstaluj Node.js – jeśli jeszcze go nie masz, pobierz aktualną wersję LTS Node.js ze strony nodejs.org i zainstaluj. Expo wymaga Node.js do działania swojego CLI.

2. Zainstaluj Expo CLI – najlepszym sposobem jest użycie npx do uruchomienia narzędzia create-expo-app, które utworzy projekt Expo. W terminalu uruchom komendę:

npx create-expo-app@latest AwesomeProject

Powyższe polecenie stworzy nowy projekt Expo o nazwie “AwesomeProject” z domyślnymi ustawieniami​. Alternatywnie możesz zainstalować Expo CLI globalnie poleceniem npm install -g expo-cli i następnie użyć expo init AwesomeProject – efekt będzie podobny​. Podczas inicjalizacji Expo zapyta Cię o kilka rzeczy, m.in. wybór szablonu projektu.

3. Wybierz szablon (template) – Expo udostępnia różne szablony startowe. Najczęściej do wyboru masz: blank (czysty projekt z jednym ekranem) oraz tabs (projekt z gotową nawigacją tab-bar i kilkoma przykładowymi ekranami). Jeśli dopiero zaczynasz, wybierz blank (pusty szablon) – otrzymasz minimalną aplikację React Native. Szablon tabs zawiera od razu skonfigurowaną bibliotekę React Navigation i przykładowe ekrany z menu zakładkowym​. Możesz także zobaczyć opcję wyboru workflow: managed (domyślnie) lub bare. Upewnij się, że wybrany jest tryb Managed workflow (czyli standardowy Expo), aby móc korzystać ze wszystkich ułatwień Expo.

4. Zainstaluj zależności i uruchom projekt – po pomyślnym utworzeniu projektu przejdź do folderu projektu i uruchom serwer deweloperski:

cd AwesomeProject
npm start  # lub: expo start

Powinieneś zobaczyć w konsoli uruchomiony pakiet Metro Bundler oraz informację, że aplikacja jest gotowa do połączenia. Pojawi się również kod QR.

5. Uruchom aplikację na urządzeniu lub emulatorze – teraz możesz podejrzeć działanie aplikacji:

• Na fizycznym urządzeniu: Zainstaluj aplikację Expo Go ze sklepu (Google Play lub App Store) na swoim telefonie. Upewnij się, że telefon i komputer są w tej samej sieci Wi-Fi. Zeskanuj kamerą telefonu kod QR wyświetlony w terminalu/oknie Expo – aplikacja Expo Go połączy się z Twoim serwerem deweloperskim i uruchomi aplikację. Każda zapisana zmiana w kodzie automatycznie odświeży podgląd na telefonie.

• Na emulatorze/symulatorze: Jeśli masz zainstalowany emulator Android (AVD) lub symulator iOS, upewnij się, że jest uruchomiony. W oknie terminala z Metro Bundlerem naciśnij klawisz a, aby otworzyć aplikację na Android Emulator, lub i, aby otworzyć na iOS Simulator (na macOS)​

Expo CLI automatycznie zbuduje wersję debug i prześle ją do emulatora. Po chwili powinieneś zobaczyć aplikację startową React Native (domyślnie jest to ekran z napisem “Welcome to React Native…”).

6. Modyfikacja i hot-reload: Teraz możesz otworzyć plik App.js w edytorze, wprowadzić zmiany (np. zmienić tekst powitalny) i zapisać. Expo natychmiast przeładuje aplikację na urządzeniu/emulatorze, pokazując wprowadzone zmiany, dzięki włączonemu domyślnie mechanizmowi Fast Refresh.

Gratulacje! Twój projekt Expo jest uruchomiony. Cały proces – od instalacji po zobaczenie aplikacji – jest bardzo szybki i przyjazny dla początkującego. Więcej szczegółów znajdziesz w oficjalnej dokumentacji Expo.

Instalacja React Native CLI

Przy podejściu React Native CLI konfiguracja jest nieco bardziej czasochłonna. Wymaga zainstalowania kilku narzędzi i zależności natywnych, ale pozwoli Ci to budować aplikację od podstaw na własnym komputerze. Poniżej instrukcje:

Kroki konfiguracji i uruchomienia projektu React Native CLI:

1. Przygotuj środowisko:

• Node.js: Zainstaluj Node.js (jeśli już go nie masz) – podobnie jak w Expo, Node jest wymagany do zarządzania pakietami JavaScript i uruchamiania Metro Bundler.
• JDK (Java Development Kit): Pobierz i zainstaluj JDK w wersji 11 lub nowszej (React Native zaleca obecnie JDK 11 LTS). Na Windowsie/Mac upewnij się, że zmienna środowiskowa JAVA_HOME wskazuje na katalog instalacyjny JDK.
• Android Studio (Android SDK): Zainstaluj Android Studio – podczas instalacji wybierz opcję zainstalowania najnowszego Android SDK oraz konfiguratora AVD (Android Virtual Device), ponieważ będziesz ich potrzebować do emulacji aplikacji na Androidzie. Po instalacji Android Studio uruchom je raz i przejdź przez konfigurator „SDK Manager”, aby zainstalować platformy Android (np. Android 13/API 33) oraz „AVD Manager”, aby utworzyć wirtualne urządzenie (np. Pixel 5 z Androidem). Dodatkowo, dodaj do zmiennej PATH ścieżkę do narzędzi Android SDK (platform-tools), aby móc korzystać z poleceń adb w terminalu.
• Xcode (tylko macOS, dla iOS): Jeśli używasz Maca i planujesz tworzyć aplikacje na iOS, zainstaluj najnowsze Xcode ze sklepu Mac App Store. Po instalacji otwórz Xcode i doinstaluj dodatkowe narzędzia (mogą pojawić się monity o instalację narzędzi wiersza poleceń). Zainstaluj także narzędzie CocoaPods (poleceniem sudo gem install cocoapods w Terminalu), które będzie potrzebne do zarządzania bibliotekami iOS. Uwaga: na Windows/Linux nie ma możliwości budowania ani uruchamiania natywnej aplikacji iOS – do tego wymagany jest macOS.
• React Native CLI: Nie musisz nic osobno instalować – React Native posiada wbudowane narzędzie CLI. Będziemy z niego korzystać poprzez npx, które zawsze odpali najświeższą wersję CLI​.

2. Utwórz nowy projekt React Native: Po skonfigurowaniu powyższych, możesz stworzyć projekt. Użyj następującego polecenia w Terminalu/Powershellu:

npx react-native init MyProject

gdzie „MyProject” to nazwa Twojej aplikacji. Polecenie to wygeneruje strukturę katalogów z przykładową aplikacją (zawierającą komponent App.js z prostym ekranem powitalnym). Za pomocą npx używasz zawsze aktualnej wersji React Native CLI – nie ma potrzeby instalacji globalnej pakietu react-native-cli​. Po kilku minutach (w zależności od szybkości łącza i komputera) projekt zostanie utworzony.

3. Uruchom Metro Bundler: Wejdź do folderu projektu: cd MyProject. Następnie (najlepiej w oddzielnym oknie terminala) uruchom serwer Metro:

npx react-native start

Metro Bundler to serwer, który będzie odpowiedzialny za dostarczanie pakietu JavaScript do Twojej aplikacji. Powinien wystartować na domyślnym porcie 8081 i nasłuchiwać na zmiany w kodzie​.
(Uwaga: Wiele poleceń, takich jak run-android/run-ios, automatycznie uruchamia Metro, więc ten krok możesz pominąć – jednak zaleca się mieć osobne okno z Metro, aby śledzić ewentualne logi błędów w JavaScript).

4. Uruchom aplikację na Androidzie: Upewnij się, że masz uruchomiony emulator Android (AVD) lub podłączony fizyczny telefon z włączonym debugowaniem USB. Następnie w głównym katalogu projektu wydaj polecenie:

npx react-native run-android

Spowoduje to zbudowanie aplikacji Android i zainstalowanie jej na emulatorze/urządzeniu. Przy pierwszym uruchomieniu Gradle pobierze wszystkie potrzebne zależności, co może potrwać kilka minut. Jeśli wszystko jest poprawnie skonfigurowane, po kompilacji zobaczysz na emulatorze ekran aplikacji MyProject (tak jak w Expo, domyślnie jest to ekran powitalny React Native)​

Jeśli pojawią się błędy, sprawdź komunikaty w konsoli – najczęstsze problemy to nieuruchomiony emulator lub brak zaakceptowanych licencji SDK (w razie czego uruchom Android Studio, które podpowie, jak zaakceptować licencje). Po udanym uruchomieniu, Metro Bundler zacznie przesyłać kod JavaScript do aplikacji.

5. Uruchom aplikację na iOS (macOS): Jeśli pracujesz na Macu, możesz uruchomić aplikację na iOS Simulator. Upewnij się, że masz otwarty symulator (np. iPhone 14). W katalogu projektu wykonaj:

npx react-native run-ios

Polecenie to otworzy projekt iOS w Xcode, zbuduje go i uruchomi w symulatorze​. Pierwsze uruchomienie spowoduje również automatyczne zainstalowanie zależności przez CocoaPods (to może potrwać). Po chwili powinieneś zobaczyć aplikację na wirtualnym iPhonie. Jeśli coś pójdzie nie tak, upewnij się, że Xcode zostało zainstalowane i zaktualizowane, a symulator jest poprawnie skonfigurowany. (Alternatywnie aplikację iOS możesz uruchomić ręcznie – otwierając projekt .xcworkspace w Xcode i klikając „Run”, co czasem daje lepszy wgląd w błędy).

6. Edytuj kod i korzystaj z Fast Refresh: Otwórz plik App.js w swoim projekcie CLI i zmień np. tekst nagłówka. Następnie zapisz plik – na emulatorze/telefonie zobaczysz, że aplikacja automatycznie się przeładuje, prezentując wprowadzone zmiany (dzięki mechanizmowi Fast Refresh, który działa tu podobnie jak w Expo). W przypadku poważniejszych zmian natywnych (np. dodanie nowej biblioteki native), może zajść potrzeba ponownego zbudowania aplikacji.

Teraz masz uruchomiony projekt React Native stworzony za pomocą CLI. Od tego momentu możesz budować swoją aplikację, dodawać biblioteki poprzez npm/yarn i w pełni kształtować projekt. Pamiętaj, że więcej szczegółowych informacji (np. o generowaniu plików release APK/IPA, konfiguracji podpisów aplikacji, itp.) znajdziesz w dokumentacji React Native.

Które rozwiązanie wybrać?

Wybór między Expo a React Native CLI zależy od Twojego poziomu zaawansowania oraz specyfiki projektu, nad którym chcesz pracować. Poniżej znajdziesz rekomendacje dostosowane do różnych grup użytkowników:

Dla początkujących

Jeśli dopiero zaczynasz przygodę z React Native lub w ogóle z tworzeniem aplikacji mobilnych, Expo będzie prawdopodobnie lepszym wyborem na start. Dzięki niemu unikniesz komplikacji związanych z konfiguracją środowiska natywnego i od razu skupisz się na pisaniu kodu w JavaScript/React. Expo oferuje łagodniejsze wprowadzenie – szybkie prototypowanie i podgląd działania aplikacji bez frustracji konfiguracją Gradle czy Xcode​. W praktyce wiele tutoriali dla początkujących rekomenduje Expo jako pierwszy krok​. Expo sprawdzi się także, jeśli chcesz szybko przygotować prosty projekt lub prototyp – np. na potrzeby demonstracji pomysłu lub projektu na studia. Zarządzany workflow sprawia, że nie musisz martwić się o detale – np. dodanie obsługi aparatu czy lokalizacji sprowadza się do zainstalowania paczki Expo (expo-camera, expo-location) i wykorzystania jej od razu, bez grzebania w natywnych plikach konfiguracyjnych. Dodatkowo społeczność Expo i świetna dokumentacja pomogą Ci na początku drogi – gdy napotkasz problem, prawdopodobnie nie będziesz pierwszą osobą, która go ma, a fora Expo są pełne wskazówek.

Dla średniozaawansowanych

Jeżeli masz już za sobą pierwsze kroki i zaczynasz czuć się pewniej w React Native, odpowiedź na pytanie „Expo czy CLI?” brzmi: to zależy od potrzeb projektu. Możesz nadal korzystać z Expo, zwłaszcza jeśli projekt nie wymaga nietypowych funkcjonalności natywnych. Expo w ostatnich latach bardzo się rozwinęło i nawet niektóre całkiem rozbudowane aplikacje mogą w nim powstać bez ograniczeń. Warto jednak ocenić, czy nie zbliżasz się do granic możliwości Expo. Jeśli wiesz, że w projekcie będziesz potrzebować np. integracji z natywnym SDK jakiegoś producenta (którego nie ma w Expo), albo zależy Ci na maksymalnej optymalizacji rozmiaru i wydajności – może to być sygnał, by rozważyć przejście na React Native CLI. Dobrą strategią bywa rozpoczęcie developmentu w Expo (dla szybkości) i ewentualne „eject” do bare workflow, gdy Expo zacznie Cię ograniczać​.

Pamiętaj, że opuszczenie Expo będzie wymagało skonfigurowania środowiska jak dla CLI, ale Expo udostępnia komendę expo prebuild, która wygeneruje za Ciebie wstępnie projekty natywne. Dla średniozaawansowanych deweloperów ważne jest również poszerzanie kompetencji – być może warto spróbować stworzyć mniejszy poboczny projekt w React Native CLI od zera, by zrozumieć różnice i mechanizmy natywne.

Podsumowując: jeśli Twój projekt mieści się w ramach możliwości Expo i cenisz sobie szybkość developmentu – zostań przy Expo. Jeśli zaczynasz odczuwać ograniczenia lub chcesz pogłębić wiedzę o natywnym developmentcie – React Native CLI będzie kolejnym krokiem. Sprawdź co to jest aplikacja natywna.

Dla zaawansowanych

Dla doświadczonych programistów React Native, szczególnie tych, którzy mają też wiedzę o Androidzie/iOS, wybór częściej pada na React Native CLI. Na tym poziomie prawdopodobnie zależy Ci na pełnej kontroli nad projektem, integracji ciągłej (CI/CD), testach jednostkowych i end-to-end na prawdziwych urządzeniach, profilowaniu wydajności itp. React Native CLI daje Ci do tego pełne pole do popisu – nie ma „czarnej skrzynki” która coś za Ciebie robi, sam kontrolujesz każdy aspekt. W środowisku profesjonalnym CLI bywa preferowane również dlatego, że łatwiej jest utrzymać i długofalowo rozwijać duży projekt bez obaw o ograniczenia narzucone z zewnątrz​. Ponadto, wielu zaawansowanych deweloperów wybiera CLI, bo często muszą oni i tak łączyć pracę nad częścią React Native z pracą nad częścią natywną aplikacji (np. dodając natywne ekrany lub moduły pisane w Swift/Kotlin). Jeśli jesteś zaawansowany, Expo może Ci nadal służyć do szybkiego prototypowania albo tworzenia mniejszych aplikacji/demo, jednak do poważnych, dużych wdrożeń prawdopodobnie wybierzesz React Native CLI dla jego elastyczności.

Warto zaznaczyć, że Expo nie stoi w opozycji do zaawansowanych zastosowań – możesz np. używać części ekosystemu Expo (biblioteki z Expo SDK) w projekcie utworzonym przez CLI, ponieważ pod spodem to wciąż React Native. Jednakże ogólna zasada to: Expo dla wygody, CLI dla pełnej kontroli. Jak ujął to jeden z artykułów, Expo jest idealne dla początkujących lub szybkiego prototypowania, podczas gdy React Native CLI przemawia do developerów potrzebujących głębokiego dostępu do modułów natywnych i maksymalnej kontroli nad projektem​.

Podsumowanie

Expo vs React Native CLI – oba podejścia mają swoje mocne i słabe strony, a zrozumienie ich różnic jest kluczowe przed rozpoczęciem projektu w React Native. Expo zapewnia szybki start, prostotę i bogaty zestaw narzędzi na starcie, co czyni go świetnym wyborem dla osób początkujących w świecie aplikacji mobilnych i do projektów, które można zrealizować w ramach dostępnych modułów Expo. Z kolei React Native CLI daje pełną swobodę, kontrolę nad kodem natywnym i skalowalność, co jest niezbędne w dużych, wymagających projektach komercyjnych.

Wybierając rozwiązanie dla siebie, kieruj się zarówno poziomem doświadczenia, jak i wymaganiami projektu. Jeśli zależy Ci na czasie i łatwości – zacznij od Expo. Jeśli od początku wiesz, że potrzebujesz niestandardowych rozwiązań natywnych lub chcesz uczyć się “natywnego” podejścia – React Native CLI może być lepszy. Pamiętaj, że zawsze istnieje możliwość migracji – projekt stworzony w Expo możesz w razie potrzeby przekonwertować na projekt bare React Native (CLI) i odwrotnie, możesz w projekcie CLI używać wielu bibliotek Expo (dzięki tzw. bare workflow w Expo).