Blogg

Organisera din kodbas i React Native

9 februari 2023 7 min läsning

Bästa praxis för att organisera och strukturera stora React Native-appar. Lär dig om mappstruktur, organisering av komponenter och kodmönster som är lätta att underhålla.

Organisera din kodbas i React Native
React NativeArkitekturKodorganisationBästa praxis

En guide till en skalbar kodbas som är lätt att underhålla

I en React Native-app är det avgörande att organisera kodbasen för att den ska gå att underhålla och skala. Hur du strukturerar filer och mappar kan i hög grad påverka hur lätt det blir att arbeta med kodbasen i framtiden.

Den här artikeln utforskar den funktionsbaserade mappstrukturen för en React Native-app och syftet med varje mapp.

Mappen src

Mappen src är rotkatalogen för all källkod i din app. I den mappen hittar du flera andra undermappar som var och en har ett specifikt syfte.

Types

Mappen types är där du definierar globala typer för din app. Det omfattar modultyper, interface-definitioner och alla andra egna typer som du behöver använda i hela appen.

Att ha en central plats för alla typer gör dem lättare att hantera och underhålla när appen växer. Dessutom säkerställer det att typerna används konsekvent i alla funktioner, vilket minskar risken för typrelaterade buggar och gör dem lättare att upptäcka när de väl uppstår.

Lib

Mappen lib är där du kan lägga appspecifika filer som används globalt i hela appen. Det kan vara axios-instansen för API-anrop, tjänster för felhantering, konstanter, konfiguration av query client i react-query och så vidare.

Att ha de här filerna på en central plats gör dem lättare att underhålla och säkerställer att de är konsekventa i hela appen.

Components

Mappen components är där du lägger alla dina återanvändbara komponenter. De här komponenterna ska vara isolerade och inte knutna till någon särskild funktion eller domän. Exempel på sådana komponenter är headers, knappar och listelement.

Att hålla de här komponenterna separerade från dina funktionsspecifika komponenter gör dem lättare att hantera och återanvända i hela appen, och minskar mängden duplicerad kod.

Hooks

Mappen hooks är där du lägger egna hooks som används i hela appen. En hook är en speciell typ av funktion i React som låter dig återanvända logik med state i dina komponenter.

Att ha alla dina egna hooks som är **återanvändbara eller används på flera ställen **på en central plats gör dem lättare att hantera och underhålla. Det minskar också risken för duplicerad kod och gör det lättare att dela hooks mellan olika delar av appen.

Localization

Mappen localization är där du lägger alla filer som har med internationalisering i appen att göra. Det omfattar språkfiler, strängkonstanter och andra resurser som behövs för att stödja flera språk i appen.

När de här filerna ligger på en central plats blir de lättare att hantera och underhålla. Det minskar också risken för duplicerad kod och gör det lättare att stödja flera språk i appen.

Navigation

Mappen navigation är där du lägger all kod som har med navigation i appen att göra. Det omfattar stackar, typer, routes och andra komponenter eller funktioner som behövs för navigationen.

När all navigationskod ligger på en central plats blir den lättare att hantera och underhålla. Det minskar också risken för duplicerad kod och gör det lättare att dela navigationsfunktionalitet mellan olika delar av appen.

Services

Mappen services är där du lägger all kod som rör den underliggande infrastrukturen i appen. Det omfattar kod för push-notiser, felövervakning och andra tjänster som står för appens underliggande funktionalitet.

Theme

Mappen theme är där du ska lagra appens styling, till exempel mörkt och ljust tema. När styling och temafiler ligger på ett ställe blir det lättare att hantera och uppdatera appens utseende och känsla vid behov.

Utils

Hjälpfunktioner kan vara en viktig del av din React Native-app, eftersom de gör det möjligt att återanvända kod på flera ställen i appen. Mappen utils är ett bra ställe att lagra hjälpfunktioner som används i hela appen. Genom att samla funktionerna på ett ställe ser du till att de är lätta att hitta och använda i andra delar av koden. Till exempel: hjälpfunktioner som rör layout i react-native.

Features

När man bygger komplexa appar är det viktigt att ha en tydlig och koncis mappstruktur som samlar all kod på ett ställe. En features-mapp hjälper till med det, eftersom den delar upp appens olika funktioner i separata kategorier. Det gör att utvecklare snabbt kan hitta och ändra en specifik funktion utan att påverka andra delar av appen.

Dessutom förblir mappstrukturen organiserad när appen växer och fler funktioner läggs till, vilket gör det lättare för nya utvecklare att komma in och förstå hur appen fungerar. Den tydliga ansvarsfördelningen minskar också risken för buggar och förbättrar appens övergripande prestanda.

Så här kan en auth-mapp se ut:

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

Vikten av features-mappen ligger i att den hjälper till att dela upp kodbasen i mindre och mer hanterbara delar. Varje funktion har sina egna undermappar, som api, helpers (eller utils), hooks, screens, services och store, som är specifika för just den funktionen. Det gör det lättare att förstå hur varje funktion fungerar och hur funktionerna samverkar.

Mappen api innehåller all API-relaterad kod som är specifik för autentisering. Det gör API-anropen lättare att hantera och hålla ordning på.

Mappen helpers innehåller hjälpmetoder eller hjälpfunktioner som är specifika för autentiseringsfunktionen. De kan användas enbart inom autentiseringsfunktionen och behöver inte delas med andra delar av appen.

Mappen hooks innehåller hooks som specifikt rör autentisering. Eftersom React bygger så mycket på hooks blir det lättare att hantera dem och hålla ordning på dem.

Mappen screens innehåller alla skärmar för autentiseringsfunktionen. Det omfattar bland annat inloggningsskärmen, registreringsskärmen och skärmen för glömt lösenord.

Mappen services innehåller tjänster som är specifika för autentiseringsfunktionen. Du kan till exempel ha en autentiseringstjänst som ansvarar för att hantera inloggning och registrering av användare.

Till sist innehåller mappen store koden för state management som är specifik för autentiseringsfunktionen. Det kan vara en Redux-store, en Zustand-store eller vilket annat bibliotek för state management du föredrar.

Genom att dela upp appen i mindre, organiserade delar blir det mycket lättare att hantera koden och ändra den vid behov. Det hjälper också till att hålla koden ren och läsbar, vilket gör det lättare för andra utvecklare att förstå och arbeta med den.

Exempel på struktur för funktionsmappen 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

Mappen auth är undermappen för appens autentiseringsfunktion. Filerna i den här mappen hanterar allt som rör autentisering och auktorisering, från API:erna för inloggning och registrering till skärmarna som användaren interagerar med.

Mappen api innehåller API:erna för autentiseringsfunktionen, till exempel filerna login.ts och signup.ts, som hanterar förfrågningar och svar när användaren loggar in eller registrerar sig. Filen refresh-token.ts hanterar förnyelsen av token.

Mappen helpers innehåller hjälpfunktioner som används i autentiseringsprocessen. Filen validateToken.ts används till exempel för att validera token, och filen dataTransformer.ts omvandlar data till och från autentiserings-API:erna.

Mappen screens innehåller de UI-komponenter som användaren interagerar med. Filerna Login.tsx och Signup.tsx innehåller till exempel UI-komponenterna för att logga in respektive registrera sig.

Mappen hooks innehåller egna hooks som rör autentisering. Filerna useLoginAction.ts och useSignupForm.ts innehåller till exempel hooks som hjälper till att hantera state och handlingar för inloggnings- respektive registreringsformuläret.

Mappen services innehåller tjänster som rör autentisering, till exempel filen validation.ts, som innehåller funktioner för att validera användarens input.

Mappen store innehåller state management för autentisering. Filen auth.ts innehåller state och actions för autentisering, med ett bibliotek för state management som Zustand, Redux eller något annat.

FÖRBEHÅLL

Det är viktigt att komma ihåg att namngivningen av mappar och filer kan variera mellan projekt och mellan utvecklare. Det viktiga är mapparnas struktur och organisation, inte exakt vilka namn som används för varje mapp. Mappen utils i appens rot skulle till exempel också kunna heta helpers eller utilities, och i stället för screens skulle den kunna heta pages eller något annat som passar det specifika projektet. Målet är att ha en tydlig och konsekvent struktur som hjälper utvecklare att förstå hur koden är organiserad och gör appen lättare att underhålla och skala.

Typbaserad mappstruktur jämfört med funktionsbaserad mappstruktur

Ett annat vanligt sätt att organisera ett projekts kodbas är den typbaserade mappstrukturen, som har sina egna för- och nackdelar. I nästa avsnitt jämför vi de två mappstrukturerna visuellt.

Jämförelse

    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

Som du ser ovan är skärmarna i den typbaserade mappstrukturen separerade från API-anrop och hjälpfunktioner, vilket kan göra kodbasen svårare att förstå. Lägg märke till hur vi kan hamna med orelaterade skärmar som LoginScreen.tsx och TodoListScreen.tsx i samma mapp i den typbaserade strukturen. Dessutom kan det göra koden svårare att underhålla, eftersom relaterad kod inte är samlad på ett ställe. I den funktionsbaserade mappstrukturen samlas däremot all kod som rör autentisering, inklusive skärmar, API-anrop, hjälpfunktioner och tjänster, i en enda auth-mapp. Det gör kodbasen lättare att förstå, eftersom all relaterad kod finns på ett ställe. Det här sättet ger bättre inkapsling av koden och gör projektet skalbart och flexibelt inför framtida ändringar.

Slutresultatet med en funktionsbaserad mappstruktur

Så här skulle det till slut se ut med den funktionsbaserade mappstrukturen och några påhittade filer:

    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)

Filerna som lagts till i de olika mapparna ovan (t.ex. button.tsx och header.tsx i mappen components, useHeader.ts i mappen hooks osv.) är tänkta som exempel och ska inte ses som hundraprocentigt korrekta. Syftet med att ta med filerna är att ge en visuell bild av mappstrukturen och göra det lättare att förstå hur kodbasen är organiserad. Den faktiska implementationen kan variera beroende på projektets specifika krav. Fokus i den här artikeln ligger på den funktionsbaserade mappstrukturen och hur den kan hjälpa dig att bygga en skalbar och organiserad kodbas, snarare än på detaljerna i enskilda filer.


Slutsats

Enligt mig är den funktionsbaserade mappstrukturen ett användbart sätt att organisera React/React Native-projekt. När koden delas upp i separata funktioner tycker jag att appen blir lättare att underhålla, förstå och utveckla. Strukturen ger bättre inkapsling av koden och gör projektet skalbart och flexibelt inför framtida ändringar. Det är förstås ingen lösning som passar alla, och den exakta strukturen kan variera beroende på projektets storlek och komplexitet. Men huvudidén är att hålla en tydlig gräns mellan olika funktioner och deras respektive komponenter, tjänster och data. Enligt min erfarenhet har den här strukturen hjälpt mig att bygga och underhålla välorganiserade projekt som klarar tillväxt och förändring över tid. Jag ville dela det här sättet med andra som också kan ha nytta av det.

Publicerad på

Den här artikeln är också publicerad på: