# Jak uporządkować kod aplikacji w React Native

By Tarik Pinarci (https://tarikpinarci.com). Published 2023-02-09. Canonical: https://tarikpinarci.com/pl/blog/organizing-react-native-codebase

## Przewodnik po skalowalnym i łatwym w utrzymaniu kodzie

W aplikacji React Native uporządkowanie kodu jest kluczowe dla łatwości utrzymania i skalowalności. Sposób, w jaki ułożysz pliki i foldery, może mocno wpłynąć na to, jak wygodnie będzie Ci się pracowało z tym kodem w przyszłości.

W tym artykule omawiam strukturę folderów **_opartą na feature'ach_** dla aplikacji React Native i przeznaczenie każdego folderu.

### Folder src

Folder src to główny katalog całego kodu źródłowego aplikacji. Znajdziesz w nim kilka podfolderów, z których każdy ma konkretne przeznaczenie.

### Types

W folderze types definiujesz globalne typy aplikacji. Należą do nich typy modułów, definicje interfejsów i wszelkie inne własne typy, których potrzebujesz w całej aplikacji.

Jedno centralne miejsce na wszystkie typy ułatwia zarządzanie nimi i ich utrzymanie, gdy aplikacja rośnie. Do tego dzięki temu typy są używane spójnie we wszystkich feature'ach, co zmniejsza ryzyko błędów związanych z typami i ułatwia ich wyłapanie, kiedy już się pojawią.

### Lib

W folderze lib możesz trzymać pliki specyficzne dla aplikacji, które są używane globalnie w całej aplikacji. Mogą to być instancja axios do wywołań API, serwisy obsługi błędów, stałe, konfiguracja query clienta w react-query itd.

Trzymanie tych plików w jednym centralnym miejscu ułatwia ich utrzymanie i zapewnia, że są spójne w całej aplikacji.

### Components

W folderze components trzymasz wszystkie komponenty wielokrotnego użytku. Te komponenty powinny być odizolowane i niezwiązane z żadnym konkretnym feature'em ani domeną. Przykłady takich komponentów to headery, przyciski i elementy listy.

Oddzielenie ich od komponentów specyficznych dla feature'ów ułatwia zarządzanie nimi i ponowne używanie ich w całej aplikacji oraz zmniejsza ilość zduplikowanego kodu.

### Hooks

W folderze hooks trzymasz własne hooki używane w całej aplikacji. Hook to specjalny rodzaj funkcji w React, który pozwala ponownie używać logiki ze state'em w różnych komponentach.

Trzymanie wszystkich własnych hooków **wielokrotnego użytku/używanych w wielu miejscach** w jednym centralnym miejscu ułatwia zarządzanie nimi i ich utrzymanie, zmniejsza ryzyko duplikacji kodu i ułatwia współdzielenie hooków między różnymi częściami aplikacji.

### Localization

W folderze localization trzymasz wszystkie pliki związane z internacjonalizacją aplikacji. Należą do nich pliki językowe, stałe z tekstami i wszelkie inne zasoby potrzebne do obsługi wielu języków w aplikacji.

Kiedy te pliki są w jednym centralnym miejscu, łatwiej nimi zarządzać i je utrzymywać, mniejsze jest ryzyko duplikacji kodu i łatwiej obsłużyć wiele języków w aplikacji.

### Navigation

W folderze navigation trzymasz cały kod związany z nawigacją w aplikacji. Należą do niego stacki, typy, route'y i wszelkie inne komponenty lub funkcje potrzebne do obsługi nawigacji.

Kiedy cały kod nawigacji jest w jednym centralnym miejscu, łatwiej nim zarządzać i go utrzymywać, mniejsze jest ryzyko duplikacji kodu i łatwiej współdzielić funkcje nawigacji między różnymi częściami aplikacji.

### Services

W folderze services trzymasz cały kod związany z infrastrukturą, na której stoi aplikacja. Należy do niego kod do obsługi powiadomień push, monitorowania błędów i wszelkich innych serwisów, które dostarczają podstawowych funkcji aplikacji.

### Theme

W folderze theme powinieneś trzymać style aplikacji, na przykład ciemny i jasny motyw. Trzymanie plików ze stylami i motywami w jednym miejscu ułatwia zarządzanie wyglądem aplikacji i jego zmienianie, kiedy trzeba.

### Utils

Funkcje pomocnicze mogą być ważną częścią aplikacji React Native, bo pozwalają ponownie używać kodu w wielu miejscach aplikacji. Folder utils to świetne miejsce na funkcje pomocnicze używane w całej aplikacji. Kiedy zbierzesz je w jednym miejscu, łatwo je znaleźć i używać w innych częściach kodu. Na przykład: funkcje pomocnicze związane z layoutem w react-native.

### Features

Przy budowaniu złożonych aplikacji kluczowa jest przejrzysta i zwięzła struktura folderów, która trzyma cały kod w jednym miejscu. Folder features w tym pomaga, bo dzieli wszystkie feature'y aplikacji na osobne kategorie. Dzięki temu deweloperzy mogą szybko znaleźć konkretny feature i coś w nim zmienić bez wpływu na inne części aplikacji.

Co więcej, kiedy aplikacja rośnie i dochodzą nowe feature'y, struktura folderów pozostaje uporządkowana, więc nowym deweloperom łatwiej wskoczyć w projekt i zrozumieć, jak działa aplikacja. Wyraźny podział odpowiedzialności pomaga też zmniejszyć ryzyko błędów i poprawia ogólną wydajność aplikacji.

Tak mógłby wyglądać folder auth:

```tsx
    src/
    ├── ...
    └── features/
        ├── auth/
        |   ├── api/
        |   ├── helpers/
        |   ├── hooks/
        |   ├── screens/
        |   ├── services/
        |   └── store/
        └── ... (other features)
```

Znaczenie folderu features polega na tym, że pomaga podzielić kod na mniejsze części, którymi łatwiej zarządzać. Każdy feature ma własne podfoldery, takie jak api, helpers (albo utils), hooks, screens, services i store, przeznaczone tylko dla niego. Dzięki temu łatwiej zrozumieć, jak działa każdy feature i jak feature'y współpracują ze sobą.

Folder api zawiera cały kod związany z API, specyficzny dla uwierzytelniania. Ułatwia to zarządzanie wywołaniami API i utrzymanie w nich porządku.

Folder helpers zawiera metody pomocnicze lub funkcje narzędziowe specyficzne dla feature'a uwierzytelniania. Mogą być używane wyłącznie w ramach tego feature'a i nie muszą być współdzielone z innymi częściami aplikacji.

Folder hooks zawiera hooki związane konkretnie z uwierzytelnianiem. Ponieważ React mocno opiera się na hookach, ułatwia to zarządzanie nimi i utrzymanie w nich porządku.

Folder screens zawiera wszystkie ekrany feature'a uwierzytelniania. Należą do nich między innymi ekran logowania, ekran rejestracji i ekran przypomnienia hasła.

Folder services zawiera serwisy specyficzne dla feature'a uwierzytelniania. Możesz na przykład mieć serwis uwierzytelniania, który odpowiada za obsługę logowania i rejestracji użytkowników.

I wreszcie folder store zawiera kod zarządzania state'em specyficzny dla feature'a uwierzytelniania. Może to być store Reduxa, store Zustanda albo dowolna inna biblioteka do zarządzania state'em, którą wolisz.

Kiedy podzielisz aplikację na mniejsze, uporządkowane części, dużo łatwiej zarządzać kodem i zmieniać go w razie potrzeby. Pomaga to też utrzymać kod czysty i czytelny, dzięki czemu inni deweloperzy łatwiej go zrozumieją i będą z nim pracować.

### Przykładowa struktura folderu feature'a auth

```tsx
    src/
    └── features/
        └── auth/
            ├── api/
            |   ├── login.ts
            |   ├── signup.ts
            |   └── refresh-token.ts
            ├── helpers/
            |   ├── validateToken.ts
            |   └── dataTransformer.ts
            ├── screens/
            |   ├── Login.tsx
            |   └── Signup.tsx
            ├── services/
            |   └── validation.ts
            └── store/
                └── auth.ts
```

Folder auth to podfolder przeznaczony dla feature'a uwierzytelniania w Twojej aplikacji. Pliki w tym folderze obsługują wszystko, co dotyczy uwierzytelniania i autoryzacji, od API do logowania i rejestracji po ekrany UI, z których korzysta użytkownik.

Folder api przechowuje API feature'a uwierzytelniania, na przykład pliki login.ts i signup.ts, które obsługują requesty i response'y dla logowania i rejestracji użytkownika. Plik refresh-token.ts obsługuje odświeżanie tokena.

Folder helpers przechowuje funkcje pomocnicze używane w procesie uwierzytelniania. Na przykład plik validateToken.ts służy do walidacji tokena, a plik dataTransformer.ts przekształca dane wysyłane do API uwierzytelniania i z niego odbierane.

Folder screens przechowuje komponenty UI, z którymi użytkownik wchodzi w interakcję. Na przykład pliki Login.tsx i Signup.tsx zawierają komponenty UI odpowiednio do logowania i rejestracji.

Folder hooks przechowuje własne hooki związane z uwierzytelnianiem. Na przykład pliki useLoginAction.ts i useSignupForm.ts zawierają hooki, które pomagają zarządzać state'em i akcjami odpowiednio formularza logowania i rejestracji.

Folder services przechowuje serwisy związane z uwierzytelnianiem, na przykład plik validation.ts z funkcjami do walidacji danych wpisanych przez użytkownika.

Folder store przechowuje zarządzanie state'em związane z uwierzytelnianiem. Plik auth.ts zawiera state i akcje związane z uwierzytelnianiem, oparte na bibliotece do zarządzania state'em, takiej jak Zustand, Redux czy jakaś inna.

### ZASTRZEŻENIE

> Warto zaznaczyć, że konwencje nazewnictwa folderów i plików mogą się różnić w zależności od projektu i dewelopera. Ważna jest struktura i organizacja folderów, a nie dokładne nazwy poszczególnych folderów. Na przykład folder utils w katalogu głównym aplikacji może się też nazywać helpers albo utilities, a zamiast _screens_ można użyć nazwy _pages_ lub innej, która ma sens w danym projekcie. Celem jest przejrzysta i spójna struktura, która pomaga deweloperom zrozumieć organizację kodu i ułatwia utrzymanie oraz skalowanie aplikacji.

### Struktura folderów oparta na typach a struktura oparta na feature'ach

Innym szeroko stosowanym sposobem organizacji kodu projektu jest struktura folderów oparta na typach, która ma swoje wady i zalety. W kolejnej sekcji porównam wizualnie te dwie struktury folderów.

### Porównanie

```tsx
    Feature-based folder structure:

    src/
    └── features/
        ├── auth/
        |   ├── api/
        |   │     ├── register.tsx
        |   │     ├── login.tsx
        |   │     ├── types.tsx
        |   │     └── helpers.tsx
        |   ├── helpers/
        |   ├── hooks/
        |   └── screens/
        |   │     ├── LoginScreen.tsx
        |   │     ├── SignupScreen.tsx
        |   │     ├── WelcomeScreen.tsx
        |   │     └── HomeScreen.tsx
        |   ├── services/
        |   └── store/
        ├── todo/
        |   └── screens/
        |   │    └── TodoListScreen.tsx
        |   ├── services/
        |   └── store/
        └── ... (other features)

    Type-based folder structure:

    src/
    ├── screens/
    |   ├── LoginScreen.tsx
    |   ├── SignupScreen.tsx
    |   ├── TodoListScreen.tsx
    |   ├── WelcomeScreen.tsx
    |   └── HomeScreen.tsx
    ├── api/
    |   └── auth/
    |       ├── register.ts
    |       ├── login.ts
    |       ├── types.ts
    |       └── helpers.ts
```

Jak widać powyżej, w strukturze opartej na typach ekrany są oddzielone od wywołań API i helperów, co może utrudniać zrozumienie kodu. Zwróć uwagę, że w strukturze opartej na typach możemy skończyć z niepowiązanymi ekranami, takimi jak LoginScreen.tsx i TodoListScreen.tsx, w tym samym folderze. Do tego **_może to utrudniać utrzymanie kodu, bo powiązany kod nie jest zgrupowany w jednym miejscu._** Natomiast w strukturze opartej na feature'ach cały kod związany z uwierzytelnianiem, w tym ekrany, wywołania API, helpery i serwisy, jest zgrupowany w jednym folderze auth. Dzięki temu łatwiej zrozumieć kod, bo cały powiązany kod znajduje się w jednym miejscu. Takie podejście pozwala lepiej enkapsulować kod i sprawia, że projekt jest skalowalny i elastyczny na przyszłe zmiany.

### Końcowy obraz ze strukturą folderów opartą na feature'ach

Poniżej widać, jak ostatecznie wyglądałaby struktura folderów oparta na feature'ach z przykładowymi plikami:

```tsx
    Feature-based folder structure:

    src/
    ├── components/
    │   ├── Button.tsx
    │   └── Header.tsx
    ├── hooks/
    │   └── useHeader.ts
    ├── localization/
    │   ├── languages.ts
    │   └── locales.ts
    ├── lib/
    │   ├── axios-instance.ts
    │   └── constants.ts
    ├── navigation/
    │   ├── root-navigator.tsx
    │   └── auth-stack.tsx
    ├── services/
    │   ├── notification.ts
    │   └── logging.ts
    ├── theme/
    │   └── index.ts
    ├── types/
    │   ├── env.d.ts
    │   └── react-augment.d.ts
    ├── utils/
    │   └── layout.ts
    └── features/
        ├── auth/
        │   ├── api/
        │   │   ├── login.ts
        │   │   ├── signup.ts
        │   │   └── refresh-token.ts
        │   ├── helpers/
        │   │   ├── validateToken.ts
        │   │   └── dataTransformer.ts
        │   ├── hooks/
        │   │   ├── useLoginAction.ts
        │   │   └── useSignupForm.ts
        │   ├── screens/
        │   │   ├── Login.tsx
        │   │   └── Signup.tsx
        │   ├── services/
        │   │   └── validation.ts
        │   └── store/
        │       └── auth.ts (zustand, redux, jotai etc.)
        └── ... (other features)
```

> Pliki dodane powyżej do różnych folderów (np. button.tsx i header.tsx w folderze components, useHeader.ts w folderze hooks itd.) są tylko przykładami i nie należy ich traktować jako w 100% dokładnych. Umieściłem je, żeby pokazać strukturę folderów wizualnie i pomóc lepiej zrozumieć organizację kodu. Rzeczywista implementacja może się różnić w zależności od konkretnych wymagań projektu. Ten artykuł skupia się na strukturze folderów opartej na feature'ach i na tym, jak pomaga ona zbudować skalowalny i uporządkowany kod, a nie na szczegółach poszczególnych plików.

---

### Podsumowanie

Moim zdaniem struktura folderów oparta na feature'ach to przydatne podejście do organizowania projektów w React i React Native. Kiedy dzielę kod na osobne feature'y, łatwiej mi utrzymywać aplikację, rozumieć ją i rozwijać. Ta struktura pozwala lepiej enkapsulować kod, dzięki czemu projekt jest skalowalny i elastyczny na przyszłe zmiany. Oczywiście nie jest to rozwiązanie uniwersalne i dokładna struktura może się różnić w zależności od wielkości i złożoności projektu. Kluczowa idea polega jednak na wyraźnym oddzieleniu od siebie różnych feature'ów oraz ich komponentów, serwisów i danych. Z mojego doświadczenia ta struktura pomogła mi budować i utrzymywać dobrze uporządkowane projekty, które radzą sobie ze wzrostem i zmianami w czasie. Chciałem podzielić się tym podejściem z innymi, którym też może się przydać.

### Opublikowano na

Ten artykuł jest też opublikowany na:

- [Medium](https://medium.com/gitconnected/how-to-structure-react-native-application-679e36c63efd)

