Dra nytta av typerna i React Navigation
Navigation har blivit en grundläggande funktion i alla mobilappar nu för tiden. I React Native-världen har vi React Navigation i fickan.
Den här artikeln går igenom hur en typisk React Navigation-uppsättning kan implementeras med TypeScript, och jämför samtidigt olika strategier för att använda TypeScript.
Och viktigare: den visar också hur vi kan få ut det mesta av TypeScripts funktioner för att bygga en mer skalbar arkitektur för navigationen.
Förbehåll: Exemplen i den här artikeln bygger på version @react-navigation@6.x.
Förbehåll: Metoderna och strategierna i den här artikeln är inga oumbärliga regler som du strikt måste följa. De är bara mina egna preferenser, och jag tyckte att de var värda att dela med läsarna. React Navigation har redan ett fantastiskt väldokumenterat avsnitt om användning med typescript. Med det sagt kan du redan bygga en riktigt bra typescript-struktur för react-navigation genom att bara följa den här dokumentationen.
Skapa en stack navigator
Låt oss titta på hur man skapar en stack navigator med paketet React Navigation .
Se exemplet nedan, hämtat från React Navigation:
import { createStackNavigator } from "@react-navigation/stack";
import * as React from "react";
import { View } from "react-native";
const Stack = createStackNavigator();
const Home = () => <View />;
const Notifications = () => <View />;
const Profile = () => <View />;
const Settings = () => <View />;
function AppStack() {
return (
<Stack.Navigator>
<Stack.Screen name="Home" component={Home} />
<Stack.Screen name="Notifications" component={Notifications} />
<Stack.Screen name="Profile" component={Profile} />
<Stack.Screen name="Settings" component={Settings} />
</Stack.Navigator>
);
}
Som du ser finns det inget TypeScript-specifikt här, så låt oss lägga till lite TypeScript i kodsnutten.
import { createStackNavigator } from "@react-navigation/stack";
import * as React from "react";
import { View } from "react-native";
type AppStackParamList = {
Home: undefined;
Notifications: undefined;
Profile: undefined;
Settings: undefined;
};
const Home = () => <View />;
const Notifications = () => <View />;
const Profile = () => <View />;
const Settings = () => <View />;
const Stack = createStackNavigator<AppStackParamList>();
function AppStack() {
return (
<Stack.Navigator>
<Stack.Screen name="Home" component={Home} />
<Stack.Screen name="Notifications" component={Notifications} />
<Stack.Screen name="Profile" component={Profile} />
<Stack.Screen name="Settings" component={Settings} />
</Stack.Navigator>
);
}
Ovan har vi lagt till typen ParamList för createStackNavigator. Men vänta, hur vet vi att createStackNavigator tar en generisk typ? Det finns ett par sätt att ta reda på det. Det har alltid varit god praxis att först läsa dokumentationen. I just det här exemplet ser du att det redan finns ett avsnitt om det i dokumentationen.
Om vi å andra sidan antar att just den här typningen av createStackNavigator inte är dokumenterad på webbplatsen, så är ett sätt att avgöra om funktionen har typningen att helt enkelt hoppa till funktionens typdefinition. Det kan kännas skrämmande i början eftersom det flyger runt massor av typer, interfaces och generics, men ju mer du gör det till en vana att hoppa till typdefinitionen, desto mindre överväldigande blir det.
Uppdatering!
Om du vill hantera extra komplexitet med typescript och dessutom vill ignorera ett briljant TS-verktyg från React-teamet (React.ComponentProps) kan du läsa vidare till slutet av artikeln.
Men jag är rädd att det här avsnittet kan vara slutet!
Vi kan hämta typningarna för varje stack screen och deras konfiguration med React.ComponentProps
Se det fullständiga exemplet nedan:
import { createStackNavigator } from "@react-navigation/stack";
import * as React from "react";
import { View } from "react-native";
type AppStackParamList = {
Home: undefined;
Notifications: undefined;
Profile: undefined;
Settings: undefined;
};
const Home = () => <View />;
const Notifications = () => <View />;
const Profile = () => <View />;
const Settings = () => <View />;
const Stack = createStackNavigator<AppStackParamList>();
const routes: Array<React.ComponentProps<typeof Stack.Screen>> = [
{
name: "Home",
component: Home,
},
{
name: "Notifications",
component: Notifications,
},
{
name: "Profile",
component: Profile,
},
{
name: "Settings",
component: Settings,
},
];
function AppStack() {
return (
<Stack.Navigator>
{routes.map((routeConfig) => (
<Stack.Screen key={routeConfig.name} {...routeConfig} />
))}
</Stack.Navigator>
);
}
Och ja, du får fortfarande intellisense, och du får fortfarande en varning om du lägger till en skärm som inte hör hemma* (till exempel en skärm som inte finns i typdeklarationen för din stack)* i din stack, så här:
Ogiltig skärm
Intellisense finns också där:

Det är också renare, mer konfigurerbart och mer dynamiskt:
const getAuthStackRoutes = (
// other parameters...
theme: ThemeType
): Array<React.ComponentProps<typeof Stack.Screen>> => {
// more business logic...
return [
{
name: "Home",
component: Home,
options: {
headerStyle: {
backgroundColor: theme.colors.primary,
// other theme stylings...
},
},
},
];
};
Sammanfattningsvis gör det här sättet att vi enkelt kan hantera komplexa navigationsstrukturer (åtminstone jämfört med de andra sätten i den här artikeln). Det beror på att du får renare JSX och samtidigt kan konfigurera dina routes på ett mer dynamiskt och modulärt sätt.
Ta användningen av TypeScript ett steg längre
Det är förstås inte begränsat till att bara deklarera den generiska typen för createStackNavigator. Vad sägs om typen för de barnelement som Stack.Navigator kommer att ha? Även om det här konceptet redan är väl beskrivet i den officiella dokumentationen ska vi se nedan hur vi kan leka med det för att få ett mer frikopplat sätt att bygga strukturen.
import type { RouteConfig, StackNavigationState } from "@react-navigation/core";
import {
createStackNavigator,
StackNavigationEventMap,
StackNavigationOptions,
} from "@react-navigation/stack";
import * as React from "react";
import { View } from "react-native";
// stack param list type
type AppStackParamList = {
Home: undefined;
Notifications: undefined;
Profile: undefined;
Settings: undefined;
};
// type of the single route in app stack
type AppStackRoutesType = RouteConfig<
AppStackParamList,
keyof AppStackParamList,
StackNavigationState<AppStackParamList>,
StackNavigationOptions,
StackNavigationEventMap
>;
// mocking the screen components for the sake of example
const Home = () => <View />;
const Notifications = () => <View />;
const Profile = () => <View />;
const Settings = () => <View />;
// strictly typed array of app stack routes
const appStackRoutes: Array<AppStackRoutesType> = [
{
name: "Home",
component: Home,
},
{
name: "Notifications",
component: Notifications,
},
{
name: "Profile",
component: Profile,
},
{
name: "Settings",
component: Settings,
},
];
const Stack = createStackNavigator<AppStackParamList>();
function AppStack() {
return (
<Stack.Navigator>
{/** mapping the app stack routes */}
{appStackRoutes.map((stackRoute) => (
<Stack.Screen key={stackRoute.name} {...stackRoute} />
))}
</Stack.Navigator>
);
}
Hoppsan, det händer väldigt mycket här… Låt oss dela upp koden i separata delar.
import type { RouteConfig, StackNavigationState } from "@react-navigation/core";
import {
createStackNavigator,
StackNavigationEventMap,
StackNavigationOptions,
} from "@react-navigation/stack";
import * as React from "react";
import { View } from "react-native";
Högst upp i kodsnutten importerar vi de moduler som behövs. Importerna omfattar typer, funktioner och annat nödvändigt. De är inte spännande men nödvändiga :)
// mocking the screen components for the sake of example
const Home = () => <View />;
const Notifications = () => <View />;
const Profile = () => <View />;
const Settings = () => <View />;
Ovan importerar vi komponenten View från react-native så att exemplet blir enklare att visa.
// type of the single route in app stack
type AppStackRoutesType = RouteConfig<
AppStackParamList,
keyof AppStackParamList,
StackNavigationState<AppStackParamList>,
StackNavigationOptions,
StackNavigationEventMap
>;
Nu kommer den intressanta delen. RouteConfig, som importeras från @react-navigation/core, tar exakt fem typer som generisk typ. Just den här typdefinitionen är inte dokumenterad på den officiella webbplatsen för react-navigation, men du kan ändå lista ut den genom att hoppa till typdefinitionen, som vi nämnde ovan.
Även om det kan verka överflödigt eller onödigt i ett typiskt react-native-projekt med typescript ger det flera fördelar, som vi går igenom i avsnittet nedan.
IntelliSense
Eftersom vi har en strikt typad array med stack routes (alltså appens routes) måste varje element i arrayen nu följa arrayens typdefinition. Det betyder att IntelliSense fungerar direkt när vi lägger till ett nytt element i arrayen.
Dessutom tvingar den här typen oss att uppdatera AppStackRoutesType* varje gång ett nytt element ska läggas till i appens routes. Annars skulle vi inte kunna lägga till ett nytt element som inte finns i AppStackRoutesType(AppStackParamList).*
Mappa routes
Nu kommer den sista delen: vi skapar en stack navigator med createStackNavigator. Sedan handlar det bara om att mappa arrayen vi skapade ovan, tillsammans med dess strikta typ.
Vi kan till slut lita på varje element i vår array, eftersom elementen är korrekt typade. Därför är det säkert att använda spread-syntax.
const Stack = createStackNavigator<AppStackParamList>();
function AppStack() {
return (
<Stack.Navigator>
{/** mapping the app stack routes */}
{appStackRoutes.map((stackRoute) => (
<Stack.Screen key={stackRoute.name} {...stackRoute} />
))}
</Stack.Navigator>
);
}
Var det verkligen den sista delen?
Tja… Nej!
Vi kan fortfarande förbättra typningarna i exemplet vi har gått igenom.
// generic stack routes type
export type StackRoutesType<ParamList extends ParamListBase> = Array<
RouteConfig<
ParamList,
keyof ParamList,
StackNavigationState<ParamList>,
StackNavigationOptions,
StackNavigationEventMap
>
>;
type AppStackRoutesType = StackRoutesType<AppStackParamList>;
// mocking the screen components for the sake of example
const Home = () => <View />;
const Notifications = () => <View />;
const Profile = () => <View />;
const Settings = () => <View />;
// strictly typed array of app stack routes
const appStackRoutes: AppStackRoutesType = [
{
name: "Home",
component: Home,
},
{
name: "Notifications",
component: Notifications,
},
{
name: "Profile",
component: Profile,
},
{
name: "Settings",
component: Settings,
},
];
Skillnaden du kanske har lagt märke till är att vi har StackRoutesType, som tar en generisk typ och motsvarar typen vi redan har sett. Men vad är fördelen, kanske du undrar? Den frågan besvaras bäst visuellt.
// too much duplicated code...
type AppStackRoutesType = RouteConfig<
AppStackParamList,
keyof AppStackParamList,
StackNavigationState<AppStackParamList>,
StackNavigationOptions,
StackNavigationEventMap
>;
type OtherStackRoutesType = RouteConfig<
OtherStackParamList,
keyof OtherStackParamList,
StackNavigationState<OtherStackParamList>,
StackNavigationOptions,
StackNavigationEventMap
>;
type AnotherStackRoutesType = RouteConfig<
AnotherStackParamList,
keyof AnotherStackParamList,
StackNavigationState<AnotherStackParamList>,
StackNavigationOptions,
StackNavigationEventMap
>;
Om vi inte hade valt att använda den generiska StackRoutesType* *hade vi behövt duplicera typningar för varje stack i appen.
Det skulle bli en mardröm när appen växer. (tanken här är att antalet stackar i appen och appens komplexitet är direkt proportionella. Det är inte alltid ett hundraprocentigt giltigt antagande, men det passar just det här exemplet)
// generic stack routes type
export type StackRoutesType<ParamList extends ParamListBase> = Array<
RouteConfig<
ParamList,
keyof ParamList,
StackNavigationState<ParamList>,
StackNavigationOptions,
StackNavigationEventMap
>
>;
// becomes one line typings for each stack
type AppStackRoutesType = StackRoutesType<AppStackParamList>;
type OtherStackRoutesType = StackRoutesType<OtherStackParamList>;
type AnotherStackRoutesType = StackRoutesType<AnotherStackParamList>;
Se å andra sidan ovan hur mycket enklare och renare det blir med en generisk typ.
Slutresultatet
Låt oss jämföra hur en typisk Stack-funktion skulle se ut i två olika scenarier:
Bild 1: Alla stack screens renderas en och en i JSX.
// ...imports, components
function AppStack() {
return (
<Stack.Navigator>
<Stack.Screen name="Home" component={Home} />
<Stack.Screen name="Notifications" component={Notifications} />
<Stack.Screen name="Profile" component={Profile} />
<Stack.Screen name="Settings" component={Settings} />
{/** n more screens... */}
</Stack.Navigator>
);
}
Bild 2: Skärmarna renderas med arrayen av stack routes som skapats med strikt typad typescript. 🎉
function AppStack() {
return (
<Stack.Navigator>
{appStackRoutes.map((stackRoute) => (
<Stack.Screen key={stackRoute.name} {...stackRoute} />
))}
</Stack.Navigator>
);
}
En sak till… Vad gäller för navigatorns props?
Vi har kanske en sak kvar att fundera på, nämligen stack navigatorns props. Om vi tittar på StackNavigator* *nedan finns det en hel del konfiguration för en enda navigator. Varför inte frikoppla den konfigurationen från JSX?
import type {
DefaultNavigatorOptions,
ParamListBase,
StackNavigationState,
} from "@react-navigation/core";
import {
StackNavigationEventMap,
StackNavigationOptions,
} from "@react-navigation/stack";
// other necessary imports for screens...
// generic typing for stack navigator options
type StackNavigatorOptions<ParamList extends ParamListBase> =
DefaultNavigatorOptions<
ParamList,
StackNavigationState<ParamList>,
StackNavigationOptions,
StackNavigationEventMap
>;
// omit the children as it corresponds to stack screen
const appStackNavigatorProps: Omit<
StackNavigatorOptions<AppStackParamList>,
"children"
> = {
initialRouteName: "Home",
screenOptions: {
headerShown: false,
cardOverlayEnabled: true,
gestureEnabled: false,
cardStyle: {
backgroundColor: "royalblue",
},
headerLeftContainerStyle: {
backgroundColor: "firebrick",
},
presentation: "modal",
headerTitleStyle: {
fontSize: 24,
color: "olivedrab",
},
},
// ...rest
};
// screen components and stack routes...
function AppStack() {
return (
<Stack.Navigator {...appStackNavigatorProps}>
{appStackRoutes.map((stackRoute) => (
<Stack.Screen key={stackRoute.name} {...stackRoute} />
))}
</Stack.Navigator>
);
}
Från rad 13 och framåt borde vi redan känna till varför vi använder en generisk typ. Den enda skillnaden i typningen jämfört med stack routes är kanske typen DefaultNavigatorOptions, som importeras från @react-navigation/core. Själva namnet på typen säger allt: det är inställningar för navigatorn.
Precis som typen *RouteConfig ** som vi nämnde ovan *tar den också flera generiska typer. Kom dessutom ihåg att vi uttryckligen u*tesluter nyckeln children eftersom vi redan renderar Stack.Navigators barn, som motsvarar Stack.Screen.*
På rad 22 skapar vi ett helt nytt objekt (eller en funktion, så länge den returnerar ett objekt som uppfyller typen för navigatorns inställningar) som representerar inställningarna för vår navigator.
Resultatet blir att objektet på rad 50 kan användas säkert med spread-syntax så länge det uppfyller den angivna typen.
Mycket renare JSX… enligt mig…
Slutresultatet: navigatorns props
Låt oss återigen jämföra hur en typisk Stack-funktion skulle se ut i två olika scenarier:
Bild 1: Stack navigatorns konfiguration ligger i JSX.
function AppStack() {
return (
<Stack.Navigator
initialRouteName="Home"
screenOptions={{
headerShown: false,
cardOverlayEnabled: true,
gestureEnabled: false,
cardStyle: {
backgroundColor: "royalblue",
},
headerLeftContainerStyle: {
backgroundColor: "firebrick",
},
presentation: "modal",
headerTitleStyle: {
fontSize: 24,
color: "olivedrab",
},
}}
// rest...
>
{appStackRoutes.map((stackRoute) => (
<Stack.Screen key={stackRoute.name} {...stackRoute} />
))}
</Stack.Navigator>
);
}
Bild 2: Stack navigatorns konfiguration är frikopplad från JSX.
// ...
function AppStack() {
return (
<Stack.Navigator {...appStackNavigatorProps}>
{appStackRoutes.map((stackRoute) => (
<Stack.Screen key={stackRoute.name} {...stackRoute} />
))}
</Stack.Navigator>
);
}
Slutsats
I den här artikeln har vi gått igenom hur vi faktiskt kan dra nytta av TypeScript och få ett renare sätt att strukturera våra navigatorer i react-native.
Ha en buggfri dag allihop.
Publicerad på
Den här artikeln är också publicerad på: