Configurer react-hook-form avec Controller
Installez react-hook-form, utilisez useForm pour créer une instance de formulaire, puis encapsulez chaque TextInput dans un Controller afin de l'enregistrer et de recevoir onChange/onBlur.
Configurer react-hook-form avec Controller est une leçon React Native Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage React Native Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours React Native Academy comprend 4 leçons au total.
Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.
Why react-hook-form?
react-hook-form is a performant, flexible library for building forms in React and React Native. Unlike manually wiring every input to useState, react-hook-form uses uncontrolled inputs to minimize re-renders. It integrates validation, error handling, and form submission into a single coherent API, and it works seamlessly with any UI component library through the Controller wrapper.
Installing react-hook-form
Install react-hook-form from npm. It has no dependencies and works with any React version 16.8+. No special configuration is needed — import its hooks and components directly into your React Native components after installation.
npm install react-hook-formCreating a Form Instance with useForm
Call useForm() at the top of your component to create a form instance. It returns several utilities: control (for wiring inputs via Controller), handleSubmit (for form submission), formState.errors (for displaying validation errors), and reset (to clear all fields). Pass default values to useForm to pre-populate the form.
import { useForm } from 'react-hook-form';
interface LoginForm {
email: string;
password: string;
}
export default function LoginScreen() {
const {
control,
handleSubmit,
formState: { errors },
reset,
} = useForm<LoginForm>({
defaultValues: { email: '', password: '' },
});
}Wrapping TextInput with Controller
In React Native, inputs are controlled components that need to be wrapped in Controller so react-hook-form can manage their values. Pass the control object, the field name, and a render prop. The render prop receives field which contains value, onChange, and onBlur to wire to the TextInput.
import { Controller } from 'react-hook-form';
<Controller
control={control}
name='email'
render={({ field: { onChange, onBlur, value } }) => (
<TextInput
value={value}
onChangeText={onChange}
onBlur={onBlur}
placeholder='Email'
keyboardType='email-address'
autoCapitalize='none'
/>
)}
/>Adding Validation Rules
Pass a rules prop to Controller to define validation constraints. The required rule marks a field as mandatory, minLength enforces a minimum character count, maxLength caps input length, and pattern validates against a regex. Each rule takes an object with a value and a message string shown when the rule fails.
<Controller
control={control}
name='email'
rules={{
required: { value: true, message: 'Email is required' },
pattern: {
value: /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
message: 'Enter a valid email address',
},
}}
render={({ field: { onChange, onBlur, value } }) => (
<TextInput value={value} onChangeText={onChange} onBlur={onBlur} />
)}
/>Displaying Field Errors
After Controller validates a field, any error is available in formState.errors[fieldName]. Access its message property and render it below the input in a red Text component. Errors only appear after the field has been touched (onBlur) or after the first submit attempt, preventing premature error messages.
<Controller
control={control}
name='email'
rules={{ required: 'Email is required' }}
render={({ field: { onChange, onBlur, value } }) => (
<View>
<TextInput
value={value}
onChangeText={onChange}
onBlur={onBlur}
style={[styles.input, errors.email && styles.inputError]}
/>
{errors.email && (
<Text style={styles.errorText}>{errors.email.message}</Text>
)}
</View>
)}
/>Handling Form Submission with handleSubmit
Wrap your submit handler with handleSubmit. react-hook-form will run all validation rules first; if any field is invalid, it populates formState.errors and does not call your handler. If all fields are valid, your handler receives a typed object containing all field values — ready to send to an API.
async function onSubmit(data: LoginForm) {
console.log('Submitting:', data.email, data.password);
try {
await authApi.login(data.email, data.password);
navigation.replace('Home');
} catch (err) {
Alert.alert('Login Failed', 'Invalid email or password.');
}
}
<Button title='Log In' onPress={handleSubmit(onSubmit)} />Password Field Configuration
For password fields, set secureTextEntry to hide the typed characters and configure an appropriate keyboard type. Wire the field to Controller exactly like the email field. Many apps also add a 'show/hide' icon button that toggles secureTextEntry via local state — this improves accessibility for users with typos.
<Controller
control={control}
name='password'
rules={{
required: 'Password is required',
minLength: { value: 8, message: 'Password must be at least 8 characters' },
}}
render={({ field: { onChange, onBlur, value } }) => (
<TextInput
value={value}
onChangeText={onChange}
onBlur={onBlur}
secureTextEntry
placeholder='Password'
/>
)}
/>Using watch to Observe Field Values
The watch function returned by useForm lets you subscribe to a field's current value and react to changes in real time. A common use case is a 'confirm password' field that validates its value matches the password field. Pass a field name to watch and use the returned value in the confirm field's validate rule.
const { control, handleSubmit, watch, formState: { errors } } = useForm<RegisterForm>();
const password = watch('password');
<Controller
control={control}
name='confirmPassword'
rules={{
validate: (value) =>
value === password || 'Passwords do not match',
}}
render={({ field }) => <TextInput {...field} secureTextEntry />}
/>Resetting the Form
Call reset() to clear all field values and errors, returning the form to its default values. You can also pass a new set of values to reset({ email: 'prefilled@example.com' }) to re-initialize the form with different defaults, which is useful for edit-profile forms that pre-populate with existing user data.
// Clear after successful submit:
async function onSubmit(data: LoginForm) {
await api.login(data);
reset(); // clears all inputs
}
// Pre-fill with existing profile data:
useEffect(() => {
if (userProfile) {
reset({
name: userProfile.name,
email: userProfile.email,
});
}
}, [userProfile]);Form Validation Modes
react-hook-form offers several mode settings that control when validation runs: 'onSubmit' (default, validates only on submit), 'onBlur' (validates when a field loses focus), 'onChange' (validates on every keystroke), and 'all' (combines onBlur and onChange). For mobile forms, 'onBlur' offers the best balance between immediate feedback and avoiding distracting errors while typing.
const { control, handleSubmit } = useForm<LoginForm>({
mode: 'onBlur', // validate when user leaves a field
defaultValues: { email: '', password: '' },
});Quick Check
Test your understanding of React Native Mobile Development concepts from this lesson.
Lesson Recap
In this lesson you learned: useForm creates the form instance with control, handleSubmit, and formState.errors, Controller wires native TextInput components to the form with onChange, onBlur, and value props, and rules define built-in validation constraints that populate errors automatically. Next up we explore validation rules and error message handling in depth.
Questions Fréquemment Posées
La leçon « Configurer react-hook-form avec Controller » est-elle gratuite ?
Oui — le texte complet de « Configurer react-hook-form avec Controller » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours React Native Academy, passe à CoddyKit PRO. Le cours React Native Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Configurer react-hook-form avec Controller » ?
Installez react-hook-form, utilisez useForm pour créer une instance de formulaire, puis encapsulez chaque TextInput dans un Controller afin de l'enregistrer et de recevoir onChange/onBlur. Tu pratiques React Native Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer React Native Academy ?
Aucune expérience préalable n'est requise. React Native Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Configurer react-hook-form avec Controller » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon React Native Academy ?
Oui. Chaque leçon React Native Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Configurer react-hook-form avec Controller
- Règles de validation et messages d'erreur
- Formulaires en plusieurs étapes avec l'état du formulaire
- Soumettre et réinitialiser des formulaires