La gestion de formulaires de niveau supérieur en React Native
Améliorer la gestion des formulaires en React Native avec Zod et React Hook Form
La gestion des formulaires est une partie fondamentale de toute application qui demande une saisie à l’utilisateur, et avec les bons outils et les bonnes bibliothèques, elle peut être simple et fluide. Cet article vous montre comment gérer des formulaires dans une application react-native avec react-hook-form et zod. En combinant les deux, nous obtiendrons un mécanisme de gestion de formulaires efficace. Créons un formulaire d’inscription basique pour l’illustrer.
Le code source complet est fourni à la fin de l’article.
Déclarer le schéma avec Zod
Pour commencer, nous déclarons notre schéma avec zod. Ce schéma décrit la forme attendue des données du formulaire et définit les validations de chaque champ. Zod fournit de nombreuses fonctions de validation puissantes pour définir ces règles.
Voici le schéma zod complet :
Cet article part du principe que vous connaissez les bases de zod.
import z from "zod";
const phoneNumberRegexp = new RegExp(
/^[\+]?([0-9][\s]?|[0-9]?)([(][0-9]{3}[)][\s]?|[0-9]{3}[-\s\.]?)[0-9]{3}[-\s\.]?[0-9]{4,6}$/im
);
const FIELD_REQUIRED_STR = "This field is required";
export const GENDER_OPTIONS = ["Male", "Female", "Other"] as const;
export const signUpFormSchema = z.object({
name: z
.string({
invalid_type_error: "Name must be a string",
required_error: FIELD_REQUIRED_STR,
})
.min(3, "Minimum 3 characters")
.max(20, "Maximum 20 characters")
.trim(),
surname: z
.string({
invalid_type_error: "Surname must be a string",
required_error: FIELD_REQUIRED_STR,
})
.min(3, "Minimum 3 characters")
.max(20, "Maximum 20 characters")
.trim(),
phoneNumber: z
.string({
invalid_type_error: "Phone number must be a number",
required_error: FIELD_REQUIRED_STR,
})
.regex(phoneNumberRegexp, "Invalid phone number"),
email: z
.string({
invalid_type_error: "Email must be a string",
required_error: FIELD_REQUIRED_STR,
})
.email("Email is invalid"),
gender: z.enum(GENDER_OPTIONS, {
required_error: FIELD_REQUIRED_STR,
invalid_type_error: `Invalid gender, must be one of the followings: ${GENDER_OPTIONS.join(
", "
)}`,
}),
birthDate: z
.date({
invalid_type_error: "Birth date must be a date",
required_error: FIELD_REQUIRED_STR,
})
.min(new Date("1900-01-01"), "Invalid date time, too old")
.max(new Date("2023-01-01"), "Invalid date time, too young")
.default(new Date()),
});
export type SignUpFormSchema = z.infer<typeof signUpFormSchema>;
Dans ce schéma, nous utilisons zod pour préciser ce que chaque champ doit contenir. Par exemple, les champs name et surname doivent être des chaînes de 3 à 20 caractères, tandis que le champ phoneNumber doit être un nombre.
Certains champs ont aussi des règles plus complexes. Par exemple, le champ email doit être une chaîne et n’accepter que des adresses e-mail valides. Le champ gender doit correspondre à l’une des options prédéfinies ('Male', 'Female' ou 'Other').
Enfin, le champ birthDate est de type date et doit contenir une date valide comprise entre le 1900-01-01 et le 2023-01-01. Par défaut, il prend la date du jour si aucune n’est fournie.
Avec zod, on crée facilement des règles de validation complexes. Ainsi, les données reçues de notre formulaire correspondront forcément à ce que nous attendons.
L’étape suivante consiste à inférer le type du schéma. Zod propose une méthode infer, qui déduit le type TypeScript d’un schéma zod donné.
export type SignUpFormSchema = z.infer<typeof signUpFormSchema>;
Ce type inféré est ensuite utilisé dans useForm pour garantir que les données de notre formulaire correspondent à notre schéma.
Configurer le formulaire avec React Hook Form
Ensuite, nous configurons notre formulaire avec le hook useForm de 'react-hook-form'. Ce hook prend en argument notre schéma zod (via zodResolver) pour gérer la validation du formulaire.
const methods = useForm<SignUpFormSchema>({
resolver: zodResolver(signUpFormSchema),
defaultValues: {
birthDate: new Date(),
},
mode: "onBlur",
});
C’est dans resolver que nous passons notre schéma. La propriété defaultValues permet de fournir des valeurs par défaut aux champs du formulaire. Ici, nous définissons la date du jour comme valeur par défaut de birthDate. La propriété mode détermine à quel moment la validation a lieu. Ici, la validation se fera onBlur, c’est-à-dire quand l’utilisateur quitte un champ.
Affichage et validation des champs
Nous utilisons le composant Controller de react-hook-form pour gérer chaque champ du formulaire. Il nous fournit les props field et fieldState, qui servent à gérer la valeur du champ, son état d’erreur et sa validation.
Par exemple, voici comment nous configurons le champ name :
<Controller
control={methods.control}
name="name"
render={({ field: { onChange, onBlur, value }, fieldState: { error } }) => {
return (
<TextInput
label="Name"
onBlur={onBlur}
value={value}
onChangeText={onChange}
errorMessage={error?.message}
/>
);
}}
/>
Voici le rôle de chaque prop :
-
control : c’est ici que vous passez la prop control du hook useForm. Elle est nécessaire pour que le Controller puisse interagir avec le state du formulaire.
-
name : c’est la clé qui permet d’accéder à la valeur du champ dans le formulaire. Quand vous récupérez ou définissez des valeurs du formulaire, c’est cette clé qui est utilisée. Elle doit être unique parmi tous les champs du formulaire.
-
render : c’est une fonction qui renvoie votre élément de saisie. La fonction fournit les props field et fieldState.
-
field : contient les props onChange, onBlur et value. Elles doivent être reliées directement à votre composant contrôlé. Ici, onChange est connecté à onChangeText du TextInput, qui capture la saisie de l’utilisateur et la stocke dans le state du formulaire.
-
fieldState : inclut la prop error, qui donne des informations sur les erreurs de validation de ce champ.
Dans la prop render, le TextInput est personnalisé. onBlur et onChangeText sont reliés aux méthodes correspondantes de field, et la prop value est liée à la valeur actuelle de ce champ dans le formulaire. La prop errorMessage est reliée au message d’erreur en cas d’échec de la validation.
Ainsi, lors de la soumission du formulaire ou d’une validation en temps réel, si le champ ‘name’ ne respecte pas les règles de validation définies dans le schéma Zod, le message d’erreur s’affichera dans ce TextInput.
Déclencher une validation personnalisée avec React Hook Form
Un cas particulier se présente avec le champ birthDate, qui utilise un composant de sélection de date (ici RNDateTimePicker). Dans cette situation, la validation demande un traitement spécial, car l’interaction de l’utilisateur avec un sélecteur de date diffère de celle avec un champ de texte classique.
<Controller
control={methods.control}
name="birthDate"
render={({ field: { onChange, onBlur, value }, fieldState: { error } }) => {
return (
<View>
<Text>Birth date</Text>
<RNDateTimePicker
value={value}
mode="date"
onChange={(e) => {
if (e.type === "set" && e.nativeEvent.timestamp) {
onChange(new Date(e.nativeEvent.timestamp));
methods.trigger("birthDate");
}
}}
/>
{!!error?.message && <Text>{error.message}</Text>}
</View>
);
}}
/>
Quand l’utilisateur sélectionne une date, l’événement onChange est déclenché. Dans ce gestionnaire d’événement, nous vérifions d’abord si le type d’événement est 'set', ce qui indique que l’utilisateur a choisi une date. Nous vérifions ensuite qu’un timestamp est présent, pour nous assurer qu’une date a bien été sélectionnée.
Une fois ces conditions confirmées, nous convertissons le timestamp en objet Date JavaScript avec new Date(e.nativeEvent.timestamp). Cette nouvelle valeur est ensuite passée à onChange, qui met à jour la valeur du champ birthDate dans le formulaire.
Cependant, contrairement aux champs de texte classiques qui déclenchent automatiquement la validation à chaque changement, les sélecteurs de date ne la déclenchent pas de la même manière. Nous devons donc déclencher la validation manuellement une fois la valeur mise à jour. Pour cela, nous appelons methods.trigger('birthDate').
Cette méthode trigger, fournie par react-hook-form, lance la validation d’un champ précis. Ici, elle déclenche la validation du champ birthDate dès que la date est choisie, pour que nos règles de validation s’appliquent immédiatement.
Enfin, s’il y a des erreurs de validation, elles s’affichent via {!!error?.message &&
Soumission du formulaire avec React Hook Form
Le package React-hook-form fournit des méthodes efficaces pour gérer la soumission des formulaires et les erreurs.
const onSubmit: SubmitHandler<SignUpFormSchema> = (data) => {
console.log(JSON.stringify(data));
};
const onError: SubmitErrorHandler<SignUpFormSchema> = (errors, e) => {
console.log(JSON.stringify(errors));
};
<Button
onPress={methods.handleSubmit(onSubmit, onError)}
title="Submit Form"
color={"#007BFF"}
/>;
Décomposons le processus :
Le gestionnaire onSubmit reçoit les données du formulaire en argument. Ici, nous nous contentons de les afficher dans la console, mais dans une vraie application, elles pourraient être envoyées à un serveur ou transformées selon les besoins de l’application.
La fonction onError, elle, est appelée quand il y a des erreurs de validation lors de la soumission du formulaire. L’objet errors contient des informations détaillées sur tous les champs dont la validation a échoué. Dans cet exemple, nous affichons simplement ces erreurs dans la console.
Si tous les champs sont en erreur, l’objet d’erreur ressemblera à ceci :
{
"name": {
"message": "This field is required",
"type": "invalid_type",
"ref": {
"name": "name"
}
},
"surname": {
"message": "This field is required",
"type": "invalid_type",
"ref": {
"name": "surname"
}
},
"phoneNumber": {
"message": "This field is required",
"type": "invalid_type",
"ref": {
"name": "phoneNumber"
}
},
"email": {
"message": "This field is required",
"type": "invalid_type",
"ref": {
"name": "email"
}
},
"gender": {
"message": "This field is required",
"type": "invalid_type",
"ref": {
"name": "gender"
}
},
"birthDate": {
"message": "Invalid date time, too young",
"type": "too_big",
"ref": {
"name": "birthDate"
}
}
}
Pré-validation avec Zod
Le bloc de code ci-dessous présente une façon de pré-valider manuellement les données du formulaire avec la méthode safeParse de Zod, avant l’événement de soumission. Même si la validation du formulaire est déjà assurée par la méthode handleSubmit de React Hook Form, la pré-validation peut donner aux développeurs plus de contrôle sur le processus de validation.
<Button
title="Submit Form"
onPress={() => {
// get current form values
const currFormValues = methods.getValues();
// Prevalidate using zod's safeParse
const result = signUpFormSchema.safeParse(currFormValues);
// If prevalidation is failed, display the error
if (!result.success) {
Alert.alert(JSON.stringify(result.error));
} else {
// If prevalidation is successful, notify the user
Alert.alert("Validation is successful with zod");
}
}}
/>
Analysons le code ci-dessus :
-
L’événement onPress du Button sert à exécuter une fonction qui effectue une pré-validation avant la soumission du formulaire.
-
La méthode getValues de methods (fournie par React Hook Form) sert à récupérer les valeurs actuelles du formulaire.
-
Ces valeurs sont ensuite passées à la méthode safeParse de signUpFormSchema (le schéma zod créé au début). C’est à cette étape qu’a lieu la pré-validation zod. Contrairement à la méthode parse de zod, safeParse ne lève pas d’erreur quand la validation échoue. Elle renvoie à la place un objet contenant le booléen success et, si la validation a échoué, un objet error.
-
Une condition vérifie si result.success vaut false (ce qui signifie que la validation a échoué). Si c’est le cas, une alerte affiche l’erreur de validation.
-
Si result.success vaut true (validation réussie), une alerte indique que la validation avec zod a réussi.
Même si cette approche peut sembler redondante, puisque handleSubmit de React Hook Form valide déjà le formulaire avec le schéma fourni via zod, elle peut être utile dans certains scénarios. Par exemple, vous pourriez vouloir effectuer certaines actions seulement après une validation manuelle, ou valider les champs en temps réel pendant que l’utilisateur remplit le formulaire. Dans ces cas-là, la pré-validation avec la méthode safeParse de zod peut s’avérer très utile.
Et voici à quoi ressemblerait l’objet d’erreur de zod :
{
"issues": [
{
"code": "invalid_type",
"expected": "string",
"received": "undefined",
"path": [
"name"
],
"message": "This field is required"
},
{
"code": "invalid_type",
"expected": "string",
"received": "undefined",
"path": [
"surname"
],
"message": "This field is required"
},
{
"code": "invalid_type",
"expected": "string",
"received": "undefined",
"path": [
"phoneNumber"
],
"message": "This field is required"
},
{
"code": "invalid_type",
"expected": "string",
"received": "undefined",
"path": [
"email"
],
"message": "This field is required"
},
{
"expected": "'Male' | 'Female' | 'Other'",
"received": "undefined",
"code": "invalid_type",
"path": [
"gender"
],
"message": "This field is required"
},
{
"code": "too_big",
"message": "Invalid date time, too young",
"inclusive": true,
"exact": false,
"maximum": 1672531200000,
"type": "date",
"path": [
"birthDate"
]
}
],
"name": "ZodError"
}
C’est en effet un gros objet, et il peut même contenir des champs inutiles dans notre cas. Heureusement, zod fournit une méthode pour formater les erreurs.
Il suffit d’utiliser result.error.format(), et zod s’occupe du reste en interne.
if (!result.success) {
// Format errors using result.error.format()
const formattedError = result.error.format();
Alert.alert(JSON.stringify(formattedError));
} else {
Alert.alert("Validation is successful with zod");
}
L’objet d’erreur formaté ressemblerait à ceci :
{
"name": {
"_errors": [
"This field is required"
]
},
"surname": {
"_errors": [
"This field is required"
]
},
"phoneNumber": {
"_errors": [
"This field is required"
]
},
"email": {
"_errors": [
"This field is required"
]
},
"gender": {
"_errors": [
"This field is required"
]
},
"birthDate": {
"_errors": [
"Invalid date time, too young"
]
}
}
Le code final
Voici le code le plus récent (sans les imports ni les styles). Si vous voulez voir le code source complet, rendez-vous à la fin de l’article.
// imports...
export const SignupForm: React.FC = () => {
const [shouldValidateWithZod, setShouldValidateWithZod] =
React.useState<boolean>(false);
const [isCalendarOpenForAndroid, setIsCalendarOpenForAndroid] =
React.useState<boolean>(false);
const methods = useForm<SignUpFormSchema>({
resolver: zodResolver(signUpFormSchema),
defaultValues: {
birthDate: new Date(),
},
mode: "onBlur",
});
const onSubmit: SubmitHandler<SignUpFormSchema> = (data) => {
console.log(JSON.stringify(data));
};
const onError: SubmitErrorHandler<SignUpFormSchema> = (errors, e) => {
console.log(JSON.stringify(errors));
Alert.alert("Warning", getReadableValidationErrorMessage(errors));
};
return (
<SafeAreaView edges={["top", "bottom"]} style={styles.safeArea}>
<ScrollView>
<Text style={styles.title}>Sign Up Form</Text>
<View style={styles.root}>
<FormProvider {...methods}>
<Controller
control={methods.control}
name="name"
render={({
field: { onChange, onBlur, value },
fieldState: { error },
}) => {
return (
<TextInput
label="Name"
onBlur={onBlur}
value={value}
onChangeText={onChange}
errorMessage={error?.message}
/>
);
}}
/>
<View style={styles.spacing} />
<Controller
control={methods.control}
name="surname"
render={({
field: { onChange, onBlur, value },
fieldState: { error },
}) => {
return (
<TextInput
label="Surname"
onBlur={onBlur}
value={value}
onChangeText={onChange}
errorMessage={error?.message}
/>
);
}}
/>
<View style={styles.spacing} />
<Controller
control={methods.control}
name="email"
render={({
field: { onChange, onBlur, value },
fieldState: { error },
}) => {
return (
<TextInput
label="Email"
onBlur={onBlur}
value={value}
onChangeText={onChange}
errorMessage={error?.message}
/>
);
}}
/>
<View style={styles.spacing} />
<Controller
control={methods.control}
name="phoneNumber"
render={({
field: { onChange, onBlur, value },
fieldState: { error },
}) => {
return (
<TextInput
label="Phone number"
onBlur={onBlur}
keyboardType="decimal-pad"
value={value}
onChangeText={(val) => onChange(val.toString())}
errorMessage={error?.message}
/>
);
}}
/>
<View style={styles.spacing} />
<Controller
control={methods.control}
name="birthDate"
render={({
field: { onChange, value },
fieldState: { error },
}) => {
return (
<View style={styles.dateWrapper}>
<Text style={styles.label}>Birth date</Text>
{Platform.OS === "android" && (
<Button
onPress={() => {
setIsCalendarOpenForAndroid(true);
}}
title={value.toString()}
/>
)}
{(isCalendarOpenForAndroid ||
Platform.OS !== "android") && (
<RNDateTimePicker
value={value}
style={styles.dateTimePicker}
mode={"date"}
onChange={(e) => {
if (Platform.OS === "android") {
setIsCalendarOpenForAndroid(false);
}
if (e.type === "set" && e.nativeEvent.timestamp) {
onChange(new Date(e.nativeEvent.timestamp));
methods.trigger("birthDate");
}
}}
/>
)}
{!!error?.message && (
<Text style={styles.errorMessageText}>
{error.message}
</Text>
)}
</View>
);
}}
/>
<View style={styles.spacing} />
<Controller
control={methods.control}
name="gender"
render={({
field: { onChange, onBlur, value, ref },
fieldState: { error },
}) => {
return (
<View style={styles.genderWrapper}>
<Text style={styles.label}>Gender</Text>
<View style={styles.genderOptionsWrapper}>
{GENDER_OPTIONS.map((genderOption) => (
<Pressable
key={genderOption}
style={[
styles.genderOptionPressable,
{
backgroundColor:
value === genderOption ? "#007BFF" : "#F2F2F2",
},
]}
onPress={() => onChange(genderOption)}
>
<Text
style={[
styles.genderOptionText,
{
color: value === genderOption ? "#fff" : "#000",
},
]}
>
{genderOption}
</Text>
</Pressable>
))}
</View>
{!!error?.message && (
<Text style={styles.errorMessageText}>
{error.message}
</Text>
)}
</View>
);
}}
/>
<View style={styles.spacing} />
<Text style={styles.label}>Should validate with zod</Text>
<Switch
value={shouldValidateWithZod}
onChange={(e) => setShouldValidateWithZod(e.nativeEvent.value)}
/>
<View style={styles.spacing} />
<Button
onPress={
shouldValidateWithZod
? () => {
/** we could also prevalidate using zod like below */
// get current form values
const currFormValues = methods.getValues();
// https://zod.dev/?id=safeparse
const result = signUpFormSchema.safeParse(currFormValues);
if (!result.success) {
const formattedError = result.error.format();
Alert.alert(JSON.stringify(formattedError));
} else {
Alert.alert("Validation is successful with zod");
}
}
: methods.handleSubmit(onSubmit, onError)
}
title="Submit Form"
color={"#007BFF"}
/>
</FormProvider>
</View>
</ScrollView>
</SafeAreaView>
);
};
// styles...
Cette application d’exemple est écrite avec expo go. Vous pouvez donc la tester facilement avec le QR code ci-dessous ! (si le QR code ne fonctionne pas, utilisez le lien vers le code source à la fin de l’article.)

Conclusion
Tout au long de cet article, nous avons vu comment tirer efficacement parti de la combinaison de React Hook Form, Zod et TypeScript pour mettre en place une validation de formulaires robuste dans notre application React Native. Nous avons vu comment la flexibilité et la puissance de ces bibliothèques nous permettent d’écrire un code propre et type-safe, capable de gérer des exigences de validation complexes.
La synergie entre React Hook Form et Zod permet de profiter des avantages des deux. React Hook Form simplifie la gestion des formulaires, optimise les re-renders et inclut des fonctionnalités comme la gestion du state du formulaire et la gestion des erreurs. De son côté, Zod apporte une couche de sécurité supplémentaire, en nous permettant de préciser quel type de données est accepté pour chaque champ et de faire respecter ces règles.
N’oubliez pas : même si les techniques présentées ici sont utilisées dans le cadre d’un simple formulaire d’inscription, elles s’appliquent à toute saisie utilisateur basée sur des formulaires dans vos applications React Native. En appliquant ces stratégies, vous vous assurez que vos formulaires sont agréables à utiliser, robustes et maintenables, ce qui se traduit par une meilleure expérience utilisateur et des applications plus solides.