Mehrstufige Formulare mit Formularstatus
Teilen Sie ein langes Registrierungsformular mithilfe eines Schrittzählers im State in mehrere Schritte auf und validieren Sie vor dem Wechsel zum nächsten Schritt nur die Felder des aktuellen Schritts.
Mehrstufige Formulare mit Formularstatus ist eine kostenlose React Native Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des React Native Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der React Native Academy-Kurs umfasst insgesamt 4 Lektionen.
Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.
What Is a Multi-Step Form?
A multi-step form breaks a long registration or checkout flow into discrete, manageable steps — typically 2 to 5 screens. Each step focuses on a related group of fields, reducing cognitive load and improving completion rates compared to a single long scroll. Common examples include onboarding wizards, address-plus-payment checkout flows, and multi-stage profile setup.
Sharing One Form Instance Across Steps
The key to a multi-step form with react-hook-form is to create one useForm instance for the entire form and pass control and errors down as props to each step component. This keeps all field values and validation state in one place. Values entered on step 1 remain available when the user reaches step 3, and submitting the final step accesses the complete form data.
interface RegisterForm {
name: string;
email: string;
password: string;
phone: string;
city: string;
}
export default function RegisterScreen() {
const [step, setStep] = React.useState(1);
const form = useForm<RegisterForm>({ defaultValues: { name: '', email: '', password: '', phone: '', city: '' } });
return (
<View style={styles.container}>
{step === 1 && <Step1AccountInfo form={form} />}
{step === 2 && <Step2ContactDetails form={form} />}
{step === 3 && <Step3Review form={form} onSubmit={handleFinalSubmit} />}
</View>
);
}Defining Step Component Props
Each step component receives the form instance as a prop. Define a TypeScript type for the prop using UseFormReturn from react-hook-form. This gives the step component access to control, formState.errors, trigger, and watch — all the tools needed to render and validate its own subset of fields.
import type { UseFormReturn } from 'react-hook-form';
interface StepProps {
form: UseFormReturn<RegisterForm>;
onNext?: () => void;
}
export function Step1AccountInfo({ form, onNext }: StepProps) {
const { control, formState: { errors } } = form;
// Render only name, email, and password fields
}Validating Only the Current Step
Before advancing to the next step, validate only the fields on the current step using form.trigger(['fieldA', 'fieldB']). This runs validation on the specified fields and returns a Promise that resolves to true if all are valid. If any fail, the errors appear and the user cannot advance until they are fixed. Fields on later steps are not validated yet.
async function handleNext() {
const step1Fields: (keyof RegisterForm)[] = ['name', 'email', 'password'];
const isValid = await form.trigger(step1Fields);
if (isValid) {
setStep(2);
}
// If invalid, formState.errors is populated for the listed fields
}Progress Indicator UI
Add a visual progress bar or step indicator at the top of the screen so users know how far along they are. Calculate progress as (currentStep / totalSteps) * 100. A simple progress bar using an animated View width gives clear feedback and sets expectations about how much more is required before they can complete the form.
const TOTAL_STEPS = 3;
function ProgressBar({ current }: { current: number }) {
const progress = (current / TOTAL_STEPS) * 100;
return (
<View style={styles.progressContainer}>
<View style={[styles.progressFill, { width: progress + '%' }]} />
</View>
);
}
// Usage:
<ProgressBar current={step} />Navigating Between Steps
Use a step counter in useState to track the current step. 'Next' buttons validate the current step's fields with trigger before incrementing the step. 'Back' buttons decrement the step without re-validating. Always disable the 'Next' button or show a loading spinner while async validation (like username availability checks) is in progress.
const { formState: { isValidating } } = form;
function NavigationButtons() {
return (
<View style={styles.navRow}>
{step > 1 && (
<Button title='Back' onPress={() => setStep((s) => s - 1)} />
)}
{step < TOTAL_STEPS ? (
<Button
title={isValidating ? 'Checking...' : 'Next'}
onPress={handleNext}
disabled={isValidating}
/>
) : (
<Button title='Submit' onPress={form.handleSubmit(onFinalSubmit)} />
)}
</View>
);
}Reviewing Entered Data on the Final Step
The final step is often a review screen where users confirm their entries before submitting. Use form.getValues() to read all field values and display them in a summary list. This gives users one last chance to catch typos before the data is sent to the server, reducing support requests and user errors.
function Step3Review({ form, onSubmit }: StepProps) {
const values = form.getValues();
return (
<ScrollView>
<Text>Review your information:</Text>
<Text>Name: {values.name}</Text>
<Text>Email: {values.email}</Text>
<Text>Phone: {values.phone}</Text>
<Text>City: {values.city}</Text>
<Button title='Confirm and Register' onPress={onSubmit} />
</ScrollView>
);
}Using formState.isSubmitting
formState.isSubmitting is true while handleSubmit's async callback is running. Use it to disable the submit button and show a loading spinner during the API call. This prevents double-submissions when the user taps quickly and gives clear feedback that the form is being processed.
const { formState: { isSubmitting } } = form;
<Button
title={isSubmitting ? 'Submitting...' : 'Confirm and Register'}
onPress={form.handleSubmit(onFinalSubmit)}
disabled={isSubmitting}
/>Persisting Step Data Across Navigation
If users navigate away from the multi-step form and return later, use Zustand or React Navigation's route params to preserve the current step and partially filled form data. Combine this with react-hook-form's reset(savedValues) to restore the form to where the user left off. This dramatically reduces form abandonment on mobile.
// On unmount or navigation away:
useEffect(() => {
return () => {
const currentValues = form.getValues();
useFormDraftStore.getState().saveDraft(currentValues, step);
};
}, []);
// On mount, restore if draft exists:
useEffect(() => {
const draft = useFormDraftStore.getState().draft;
if (draft) {
form.reset(draft.values);
setStep(draft.step);
}
}, []);Keyboard Navigation Between Fields
On mobile, tapping 'Next' on the keyboard should move focus to the next input within a step. Use useRef to hold refs for each TextInput and call ref.current.focus() in the onSubmitEditing callback of each input. Set returnKeyType='next' on intermediate fields and 'done' on the last field of each step.
const emailRef = React.useRef<TextInput>(null);
const passwordRef = React.useRef<TextInput>(null);
<TextInput
placeholder='Full Name'
returnKeyType='next'
onSubmitEditing={() => emailRef.current?.focus()}
/>
<TextInput
ref={emailRef}
placeholder='Email'
returnKeyType='next'
onSubmitEditing={() => passwordRef.current?.focus()}
/>
<TextInput
ref={passwordRef}
placeholder='Password'
returnKeyType='done'
onSubmitEditing={handleNext}
secureTextEntry
/>Handling Back Navigation Safely
When the user presses the hardware back button on Android or swipes back on iOS, handle it to decrement the step counter instead of leaving the screen entirely. Use useFocusEffect with a BackHandler to intercept the hardware back event. If the user is on step 1, allow normal navigation back to the previous screen.
import { BackHandler } from 'react-native';
import { useFocusEffect } from '@react-navigation/native';
useFocusEffect(
React.useCallback(() => {
const handler = BackHandler.addEventListener('hardwareBackPress', () => {
if (step > 1) {
setStep((s) => s - 1);
return true; // prevent default back navigation
}
return false; // allow default (exit screen)
});
return () => handler.remove();
}, [step])
);Quick Check
Test your understanding of React Native Mobile Development concepts from this lesson.
Lesson Recap
In this lesson you learned: one useForm instance shared across all steps keeps form data and validation state unified, trigger with specific field names validates only the current step before advancing, and formState.isSubmitting disables the submit button during the final API call to prevent duplicate submissions. Next up we explore submitting and resetting forms.
Häufig gestellte Fragen
Ist die Lektion „Mehrstufige Formulare mit Formularstatus“ kostenlos?
Ja — der vollständige Text von „Mehrstufige Formulare mit Formularstatus“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des React Native Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der React Native Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Mehrstufige Formulare mit Formularstatus“?
Teilen Sie ein langes Registrierungsformular mithilfe eines Schrittzählers im State in mehrere Schritte auf und validieren Sie vor dem Wechsel zum nächsten Schritt nur die Felder des aktuellen Schrit… Du übst React Native Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um React Native Academy zu starten?
Keine Vorkenntnisse erforderlich. React Native Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „Mehrstufige Formulare mit Formularstatus“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser React Native Academy-Lektion Code schreiben und ausführen?
Ja. Jede React Native Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- react-hook-form mit Controller einrichten
- Validierungsregeln und Fehlermeldungen
- Mehrstufige Formulare mit Formularstatus
- Formulare absenden und zurücksetzen