Tận dụng các kiểu dữ liệu của React Navigation
Ngày nay, navigation là tính năng cơ bản của mọi ứng dụng mobile. Trong thế giới React Native, chúng ta đã có sẵn React Navigation trong tay.
Bài viết này sẽ đi qua cách triển khai một cấu trúc React Navigation điển hình bằng TypeScript, đồng thời so sánh các cách dùng TypeScript khác nhau.
Quan trọng hơn, bài viết cũng sẽ nói về cách tận dụng tối đa các tính năng của TypeScript để xây dựng một kiến trúc navigation dễ mở rộng hơn.
Lưu ý: Các ví dụ trong bài viết này được viết với phiên bản @react-navigation@6.x.
Lưu ý: Các phương pháp và chiến lược trong bài viết này không phải là thứ bắt buộc bạn phải tuân theo một cách nghiêm ngặt, chúng chỉ là sở thích cá nhân của tôi và tôi thấy chúng hữu ích nên muốn chia sẻ với người đọc. React Navigation đã có một phần tài liệu rất tuyệt vời và chi tiết về cách dùng TypeScript. Nói vậy để thấy rằng bạn đã có thể xây dựng một cấu trúc react-navigation với TypeScript rất tốt chỉ bằng cách làm theo tài liệu này.
Tạo Stack Navigator
Hãy cùng xem cách tạo một stack navigator bằng package React Navigation .
Xem ví dụ bên dưới, lấy từ 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>
);
}
Có thể thấy ở đây chưa có gì liên quan đến TypeScript, vậy hãy thêm một chút TypeScript vào đoạn code này.
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>
);
}
Ở trên, chúng ta đã thêm kiểu ParamList cho createStackNavigator. Nhưng khoan đã, làm sao chúng ta biết createStackNavigator nhận generic type? Có vài cách để tìm ra điều này. Đọc tài liệu trước luôn là một thói quen tốt. Với ví dụ này, bạn sẽ thấy ngay trong tài liệu đã có một phần dành riêng cho nó.
Mặt khác, giả sử kiểu dữ liệu cụ thể này của createStackNavigator không được ghi trong tài liệu trên website, thì một cách để biết hàm có kiểu dữ liệu đó hay không là nhảy thẳng tới type definition của hàm. Ban đầu việc này có thể hơi đáng sợ vì sẽ có rất nhiều type, interface, generic khắp nơi, nhưng càng quen với việc nhảy tới type definition, bạn sẽ càng thấy bớt choáng ngợp.
Cập nhật!
Nếu bạn muốn chấp nhận thêm độ phức tạp với TypeScript và bỏ qua tiện ích TS tuyệt vời từ đội React (React.ComponentProps), bạn có thể tiếp tục đọc đến cuối bài viết.
Nhưng tôi e rằng phần này có thể chính là phần kết!
Chúng ta có thể lấy kiểu dữ liệu cho từng stack screen và cấu hình của chúng bằng React.ComponentProps
Xem ví dụ đầy đủ bên dưới:
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>
);
}
Và đúng vậy, bạn vẫn có intellisense, và nó vẫn sẽ cảnh báo nếu bạn đưa một screen không liên quan* (ví dụ: một screen không có trong khai báo kiểu stack của bạn)* vào stack, như sau:
Screen không hợp lệ
Intellisense cũng sẽ có mặt:

Cách này cũng gọn gàng, dễ cấu hình và linh hoạt hơn:
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...
},
},
},
];
};
Tóm lại, cách tiếp cận này giúp chúng ta quản lý các cấu trúc navigation phức tạp một cách dễ dàng*(ít nhất là khi so sánh với các cách tiếp cận khác trong bài viết này)*. Đó là vì bạn vừa có JSX gọn gàng hơn, vừa có thể cấu hình các route theo cách linh hoạt và module hóa hơn.
Đưa việc dùng TypeScript tiến thêm một bước
Thực ra, việc này không chỉ dừng ở khai báo generic type cho createStackNavigator. Còn kiểu của các children element mà Stack.Navigator sẽ có thì sao? Dù khái niệm này đã được định nghĩa khá rõ trong tài liệu chính thức, hãy xem bên dưới cách chúng ta có thể biến tấu nó để có một cách tạo cấu trúc tách biệt hơn.
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>
);
}
Ối, có quá nhiều thứ đang diễn ra ở đây… Hãy chia đoạn code thành từng phần riêng.
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";
Ở đầu đoạn code, chúng ta import các module cần thiết. Những import này gồm type, hàm và các thứ cần thiết khác. Chúng không thú vị nhưng cần thiết :)
// mocking the screen components for the sake of example
const Home = () => <View />;
const Notifications = () => <View />;
const Profile = () => <View />;
const Settings = () => <View />;
Ở trên, chúng ta import component View từ react-native để ví dụ được minh họa đơn giản hơn.
// type of the single route in app stack
type AppStackRoutesType = RouteConfig<
AppStackParamList,
keyof AppStackParamList,
StackNavigationState<AppStackParamList>,
StackNavigationOptions,
StackNavigationEventMap
>;
Giờ là phần thú vị. RouteConfig, được import từ @react-navigation/core, nhận đúng năm type làm generic type. Type definition cụ thể này không được ghi trong website chính thức của react-navigation, tuy nhiên bạn vẫn có thể tự tìm ra nó bằng cách nhảy tới type definition như đã nói ở trên.
Dù trong một dự án react-native TypeScript thông thường, việc này có vẻ thừa hoặc không cần thiết, nó mang lại vài lợi ích sẽ được nói đến ở phần bên dưới.
IntelliSense
Vì chúng ta có một mảng stack routes (hay app routes) được định kiểu chặt chẽ, mọi phần tử của mảng giờ bắt buộc phải tuân theo type definition của mảng. Điều này có nghĩa là IntelliSense sẽ hoạt động ngay khi thêm một phần tử mới vào mảng.
Hơn nữa, việc áp dụng kiểu này buộc chúng ta phải cập nhật AppStackRoutesType* mỗi khi có một phần tử mới được thêm vào app routes. Nếu không, chúng ta sẽ không thể thêm một phần tử mới không tồn tại trong AppStackRoutesType(AppStackParamList).*
Map các route
Đến phần cuối cùng, chúng ta tạo stack navigator bằng createStackNavigator. Sau đó chỉ cần map qua mảng đã tạo ở trên cùng với kiểu dữ liệu chặt chẽ của nó.
Cuối cùng, chúng ta có thể tin tưởng mọi phần tử trong mảng, chúng sẽ được định kiểu đúng, vì vậy dùng spread syntax là an toàn.
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>
);
}
Đó thực sự là phần cuối cùng?
Ừm… Không!
Chúng ta vẫn có thể cải thiện kiểu dữ liệu trong ví dụ vừa rồi.
// 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,
},
];
Điểm khác biệt có lẽ bạn đã nhận ra là chúng ta có StackRoutesType, nhận một generic type và bằng với kiểu mà chúng ta đã thấy trước đó. Nhưng bạn có thể hỏi lợi ích ở đây là gì. Tốt nhất là trả lời câu hỏi này bằng hình ảnh.
// 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
>;
Nếu không chọn dùng StackRoutesType generic*, *chúng ta sẽ phải lặp lại kiểu dữ liệu cho mọi stack có trong app.
Vì vậy, đây sẽ là một cơn ác mộng khi app ngày càng lớn. (ý ở đây là số lượng stack trong app tỉ lệ thuận với độ phức tạp của app; thực tế, giả định này không phải lúc nào cũng đúng 100%, nhưng nó phù hợp với ví dụ cụ thể này)
// 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>;
Mặt khác, hãy xem ở trên mọi thứ trở nên đơn giản và gọn gàng thế nào khi dùng generic type.
Hình ảnh cuối cùng
Hãy so sánh một hàm Stack điển hình trông như thế nào trong hai trường hợp khác nhau:
Hình 1: Render toàn bộ stack screen từng cái một trong 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>
);
}
Hình 2: Render các screen bằng mảng stack routes được tạo với TypeScript định kiểu chặt chẽ. 🎉
function AppStack() {
return (
<Stack.Navigator>
{appStackRoutes.map((stackRoute) => (
<Stack.Screen key={stackRoute.name} {...stackRoute} />
))}
</Stack.Navigator>
);
}
Còn một điều nữa… Props của Navigator thì sao
Có lẽ chúng ta còn một điều cần xem xét, đó là props của stack navigator. Nhìn vào StackNavigator bên dưới*, *có cả một khối cấu hình cho chỉ một navigator. Tại sao không tách các cấu hình này ra khỏi 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>
);
}
Từ dòng 13, chúng ta hẳn đã quen với lý do dùng generic type. Điểm khác biệt duy nhất về kiểu dữ liệu so với stack routes ở đây có lẽ là kiểu DefaultNavigatorOptions, được import từ @react-navigation/core. Ngay tên của kiểu đã tự giải thích: nó là các option cho navigator.
Tương tự kiểu *RouteConfig ** mà chúng ta đã nói ở trên, *nó cũng nhận nhiều generic type. Ngoài ra, hãy nhớ rằng chúng ta đang chủ động *omit key children vì chúng ta đã render children của Stack.Navigator tương ứng với Stack.Screen.*
Ở dòng 22, chúng ta tạo một object hoàn toàn mới (hoặc có thể là một hàm, miễn là nó trả về một object thỏa mãn kiểu navigator options), đại diện cho các option của navigator.
Kết quả là ở dòng 50, object này có thể được dùng an toàn với spread syntax, miễn là nó thỏa mãn kiểu đã cho.
JSX gọn gàng hơn nhiều… theo ý kiến của tôi…
Hình ảnh cuối cùng - Props của Navigator
Hãy cùng so sánh lại một hàm Stack điển hình trông như thế nào trong hai trường hợp khác nhau:
Hình 1: Để cấu hình stack navigator trong 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>
);
}
Hình 2: Tách cấu hình stack navigator ra khỏi JSX.
// ...
function AppStack() {
return (
<Stack.Navigator {...appStackNavigatorProps}>
{appStackRoutes.map((stackRoute) => (
<Stack.Screen key={stackRoute.name} {...stackRoute} />
))}
</Stack.Navigator>
);
}
Kết luận
Trong bài viết này, chúng ta đã tìm hiểu cách thực sự tận dụng TypeScript và đạt được một cách gọn gàng hơn để tổ chức các navigator trong react-native.
Chúc mọi người một ngày không bug.
Đã đăng trên
Bài viết này cũng được đăng trên: