Blog

Deine React-Native-Codebase organisieren

9. Februar 2023 7 Min. Lesezeit

Best Practices zum Organisieren und Strukturieren großer React-Native-Anwendungen. Lerne mehr über Ordnerstruktur, Komponenten-Organisation und wartbare Code-Patterns.

Deine React-Native-Codebase organisieren
React NativeArchitekturCode-OrganisationBest Practices

Ein Leitfaden für eine skalierbare und wartbare Codebase

In einer React-Native-Anwendung ist die Organisation der Codebase entscheidend für Wartbarkeit und Skalierbarkeit. Wie du deine Dateien und Ordner strukturierst, hat großen Einfluss darauf, wie leicht du in Zukunft mit der Codebase arbeiten kannst.

Dieser Artikel stellt die featurebasierte Ordnerstruktur für eine React-Native-Anwendung vor und erklärt den Zweck jedes Ordners.

Der Ordner src

Der Ordner src ist das Wurzelverzeichnis für den gesamten Quellcode deiner Anwendung. Darin findest du mehrere Unterordner, die jeweils einen bestimmten Zweck erfüllen.

Types

Im Ordner types definierst du die globalen Typen deiner Anwendung. Dazu gehören Modultypen, Interface-Definitionen und alle anderen eigenen Typen, die du in der gesamten Anwendung brauchst.

Ein zentraler Ort für alle Typen macht es leichter, sie zu verwalten und zu pflegen, während deine Anwendung wächst. Außerdem stellt er sicher, dass deine Typen in allen Features einheitlich verwendet werden, was das Risiko typbezogener Bugs senkt und es leichter macht, sie zu finden, wenn sie doch auftreten.

Lib

Im Ordner lib kannst du anwendungsspezifische Dateien ablegen, die global in der ganzen App genutzt werden. Das kann die axios-Instanz für API-Aufrufe sein, Services zur Fehlerbehandlung, Konstanten, das Setup des Query Clients in react-query und so weiter.

Wenn diese Dateien an einem zentralen Ort liegen, sind sie leichter zu pflegen, und es ist sichergestellt, dass sie in der gesamten Anwendung einheitlich sind.

Components

Im Ordner components liegen alle deine wiederverwendbaren Komponenten. Diese Komponenten sollten isoliert sein und zu keinem bestimmten Feature oder keiner bestimmten Domäne gehören. Beispiele für solche Komponenten sind Header, Buttons und List Items.

Wenn du diese Komponenten von deinen feature-spezifischen Komponenten trennst, lassen sie sich leichter verwalten und in der ganzen Anwendung wiederverwenden, und dein Code enthält weniger Duplikate.

Hooks

Im Ordner hooks liegen alle eigenen Hooks, die in deiner Anwendung verwendet werden. Ein Hook ist in React eine besondere Art von Funktion, mit der du zustandsbehaftete Logik über mehrere Komponenten hinweg wiederverwenden kannst.

Wenn alle deine **wiederverwendbaren bzw. an mehreren Stellen genutzten **eigenen Hooks an einem zentralen Ort liegen, sind sie leichter zu verwalten und zu pflegen. Gleichzeitig sinkt das Risiko doppelten Codes, und es wird einfacher, Hooks zwischen verschiedenen Teilen deiner Anwendung zu teilen.

Localization

Im Ordner localization liegen alle Dateien, die mit der Internationalisierung deiner Anwendung zu tun haben. Dazu gehören Sprachdateien, String-Konstanten und alle anderen Ressourcen, die nötig sind, um mehrere Sprachen zu unterstützen.

Wenn diese Dateien an einem zentralen Ort liegen, sind sie leichter zu verwalten und zu pflegen. Gleichzeitig sinkt das Risiko doppelten Codes, und es wird einfacher, mehrere Sprachen in deiner Anwendung zu unterstützen.

Navigation

Im Ordner navigation liegt der gesamte Code, der mit der Navigation deiner Anwendung zu tun hat. Dazu gehören die Stacks, Typen, Routen und alle anderen Komponenten oder Funktionen, die für die Navigation nötig sind.

Wenn dein gesamter Navigationscode an einem zentralen Ort liegt, ist er leichter zu verwalten und zu pflegen. Gleichzeitig sinkt das Risiko doppelten Codes, und es wird einfacher, Navigationsfunktionen zwischen verschiedenen Teilen deiner Anwendung zu teilen.

Services

Im Ordner services liegt der gesamte Code, der mit der zugrunde liegenden Infrastruktur deiner Anwendung zu tun hat. Dazu gehört Code für Push Notifications, Error Monitoring und alle anderen Services, die die grundlegende Funktionalität deiner Anwendung bereitstellen.

Theme

Im Ordner theme solltest du das Styling deiner App ablegen, zum Beispiel ein dunkles/helles Theme. Wenn deine Styling- und Theme-Dateien an einem Ort liegen, kannst du Look and Feel deiner App leichter verwalten und bei Bedarf anpassen.

Utils

Utility-Funktionen können ein wichtiger Teil deiner React-Native-Anwendung sein, weil sie Code wiederverwendbar machen, der an mehreren Stellen gebraucht wird. Der Ordner utils ist ein guter Ort für Utility-Funktionen, die in der ganzen Anwendung verwendet werden. Wenn du diese Funktionen an einem Ort bündelst, sind sie leicht zu finden und in anderen Teilen deines Codes zu nutzen. Zum Beispiel: Utility-Funktionen rund um das Layout in React Native.

Features

Wenn man komplexe Anwendungen baut, ist eine klare und übersichtliche Ordnerstruktur unerlässlich, die den gesamten Code an einem Ort bündelt. Ein Ordner features hilft dabei, weil er die verschiedenen Features der Anwendung in eigene Kategorien aufteilt. So können Entwickler ein bestimmtes Feature schnell finden und ändern, ohne andere Teile der Anwendung zu beeinflussen.

Außerdem bleibt die Ordnerstruktur organisiert, wenn die Anwendung wächst und mehr Features hinzukommen. Das macht es neuen Entwicklern leichter, einzusteigen und zu verstehen, wie die Anwendung funktioniert. Die klare Trennung der Verantwortlichkeiten hilft außerdem, das Risiko von Bugs zu senken, und verbessert die Gesamtperformance der Anwendung.

So könnte ein Ordner auth aussehen:

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

Die Bedeutung des Ordners features liegt darin, dass er die Codebase in kleinere, besser handhabbare Teile aufteilt. Jedes Feature hat eigene Unterordner wie api, helpers (oder utils), hooks, screens, services und store, die speziell zu diesem Feature gehören. So ist leichter zu verstehen, wie jedes Feature funktioniert und wie die Features miteinander interagieren.

Der Ordner api enthält den gesamten API-Code speziell für die Authentifizierung. So lassen sich die API-Aufrufe leichter verwalten und organisiert halten.

Der Ordner helpers enthält Hilfsmethoden oder Utility-Funktionen, die speziell zum Authentifizierungs-Feature gehören. Sie werden ausschließlich innerhalb dieses Features verwendet und müssen nicht mit anderen Teilen der Anwendung geteilt werden.

Der Ordner hooks enthält Hooks, die speziell mit der Authentifizierung zu tun haben. Da React stark auf Hooks setzt, lassen sie sich so leichter verwalten und organisiert halten.

Der Ordner screens enthält alle Screens des Authentifizierungs-Features. Dazu gehören unter anderem der Login-Screen, der Registrierungs-Screen und der Screen für vergessene Passwörter.

Der Ordner services enthält Services, die speziell zum Authentifizierungs-Feature gehören. Du könntest zum Beispiel einen Authentifizierungs-Service haben, der für Logins und Registrierungen von Nutzern zuständig ist.

Und schließlich enthält der Ordner store den State-Management-Code speziell für das Authentifizierungs-Feature. Das kann ein Redux Store sein, ein Zustand Store oder jede andere State-Management-Library, die du bevorzugst.

Wenn du die Anwendung in kleinere, organisierte Teile aufteilst, wird es viel einfacher, den Code zu verwalten und bei Bedarf zu ändern. Außerdem bleibt der Code sauber und lesbar, sodass andere Entwickler ihn leichter verstehen und damit arbeiten können.

Beispielstruktur des Feature-Ordners auth

    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

Der Ordner auth ist der Unterordner für das Authentifizierungs-Feature deiner Anwendung. Die Dateien darin kümmern sich um alles rund um Authentifizierung und Autorisierung, von den APIs für Login und Registrierung bis zu den UI-Screens, mit denen der Nutzer interagiert.

Der Ordner api enthält die APIs für das Authentifizierungs-Feature, etwa die Dateien login.ts und signup.ts, die Requests und Responses für Login und Registrierung des Nutzers verarbeiten. Die Datei refresh-token.ts kümmert sich um das Erneuern des Tokens.

Der Ordner helpers enthält Hilfsfunktionen, die im Authentifizierungsprozess verwendet werden. Die Datei validateToken.ts dient zum Beispiel zur Validierung des Tokens, und die Datei dataTransformer.ts wandelt Daten von und zu den Authentifizierungs-APIs um.

Der Ordner screens enthält die UI-Komponenten, mit denen der Nutzer interagiert. Die Dateien Login.tsx und Signup.tsx enthalten zum Beispiel die UI-Komponenten für Login und Registrierung.

Der Ordner hooks enthält eigene Hooks rund um die Authentifizierung. Die Dateien useLoginAction.ts und useSignupForm.ts enthalten zum Beispiel Hooks, die helfen, den State und die Aktionen der Login- und Registrierungsformulare zu verwalten.

Der Ordner services enthält Services rund um die Authentifizierung, etwa die Datei validation.ts mit Funktionen zur Validierung der Nutzereingaben.

Der Ordner store enthält das State-Management rund um die Authentifizierung. Die Datei auth.ts enthält den State und die Aktionen für die Authentifizierung und nutzt eine State-Management-Library wie Zustand, Redux oder eine andere.

ACHTUNG

Wichtig: Die Namenskonventionen für Ordner und Dateien können von Projekt zu Projekt und von Entwickler zu Entwickler unterschiedlich sein. Entscheidend sind Struktur und Organisation der Ordner, nicht die genauen Namen. Der Ordner utils im Root der App könnte zum Beispiel auch helpers oder utilities heißen, oder statt screens könnte er auch pages heißen oder anders, je nachdem, was für das jeweilige Projekt sinnvoll ist. Das Ziel ist eine klare und einheitliche Struktur, die Entwicklern hilft, die Organisation des Codes zu verstehen, und die es leichter macht, die Anwendung zu pflegen und zu skalieren.

Typbasierte Ordnerstruktur vs. featurebasierte Ordnerstruktur

Eine weitere verbreitete Methode, die Codebase eines Projekts zu organisieren, ist die typbasierte Ordnerstruktur, die ihre eigenen Vor- und Nachteile hat. Im folgenden Abschnitt vergleichen wir diese beiden Ordnerstrukturen visuell.

Vergleich

    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

Wie oben zu sehen ist, sind die Screens in der typbasierten Ordnerstruktur von den API-Aufrufen und Helpers getrennt, was es schwerer machen kann, die Codebase zu verstehen. Beachte, wie wir in der typbasierten Ordnerstruktur am Ende Screens, die nichts miteinander zu tun haben, etwa LoginScreen.tsx und TodoListScreen.tsx, im selben Ordner ablegen könnten. Außerdem kann es die Wartung des Codes erschweren, weil zusammengehöriger Code nicht an einem Ort gebündelt ist. In der featurebasierten Ordnerstruktur dagegen ist der gesamte Code rund um die Authentifizierung, einschließlich Screens, API-Aufrufen, Helpers und Services, in einem Ordner auth gebündelt. Das macht die Codebase leichter verständlich, weil der gesamte zusammengehörige Code an einem Ort liegt. Dieser Ansatz ermöglicht eine bessere Kapselung des Codes und macht das Projekt skalierbar und flexibel für zukünftige Änderungen.

Das Gesamtbild mit einer featurebasierten Ordnerstruktur

So würde es am Ende mit der featurebasierten Ordnerstruktur und Platzhalterdateien aussehen:

    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)

Die Dateien, die oben in den verschiedenen Ordnern ergänzt wurden (z. B. button.tsx und header.tsx im Ordner components, useHeader.ts im Ordner hooks usw.), dienen als Beispiele und sind nicht als 100 % exakt zu verstehen. Sie sollen die Ordnerstruktur visuell darstellen und helfen, die Organisation der Codebase besser zu verstehen. Die tatsächliche Umsetzung kann je nach den Anforderungen des Projekts abweichen. Der Fokus dieses Artikels liegt auf der featurebasierten Ordnerstruktur und darauf, wie sie hilft, eine skalierbare und organisierte Codebase aufzubauen, nicht auf den Details einzelner Dateien.


Fazit

Meiner Meinung nach ist die featurebasierte Ordnerstruktur ein nützlicher Ansatz, um Projekte mit React/React Native zu organisieren. Wenn ich den Code in separate Features aufteile, finde ich es einfacher, die Anwendung zu pflegen, zu verstehen und weiterzuentwickeln. Diese Struktur ermöglicht eine bessere Kapselung des Codes und macht das Projekt skalierbar und flexibel für zukünftige Änderungen. Natürlich ist das keine Lösung, die für alle passt, und die genaue Struktur kann je nach Größe und Komplexität des Projekts variieren. Die Kernidee ist aber, verschiedene Features und ihre jeweiligen Komponenten, Services und Daten klar voneinander zu trennen. Meiner Erfahrung nach hat mir diese Struktur geholfen, gut organisierte Projekte zu bauen und zu pflegen, die mit Wachstum und Veränderungen über die Zeit umgehen können. Ich wollte diesen Ansatz mit anderen teilen, die ihn vielleicht ebenfalls nützlich finden.

Veröffentlicht auf

Dieser Artikel ist auch erschienen auf: