0Pricing
React Native Academy · Aula

Formulários em várias etapas com estado do formulário

Divida um formulário de cadastro longo em várias etapas usando um contador de etapas no estado e valide apenas os campos da etapa atual antes de avançar para a próxima.

Formulários em várias etapas com estado do formulário é uma aula grátis de React Native Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de React Native Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de React Native Academy inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

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.

Perguntas Frequentes

A aula “Formulários em várias etapas com estado do formulário” é grátis?

Sim — o texto completo de “Formulários em várias etapas com estado do formulário” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de React Native Academy, atualize para CoddyKit PRO. O curso de React Native Academy inclui 4 aulas no total.

O que vou aprender em “Formulários em várias etapas com estado do formulário”?

Divida um formulário de cadastro longo em várias etapas usando um contador de etapas no estado e valide apenas os campos da etapa atual antes de avançar para a próxima. Você pratica React Native Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar React Native Academy?

Nenhuma experiência prévia é necessária. React Native Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Formulários em várias etapas com estado do formulário”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de React Native Academy?

Sim. Cada aula de React Native Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Configurando react-hook-form com Controller
  2. Regras de validação e mensagens de erro
  3. Formulários em várias etapas com estado do formulário
  4. Enviando e redefinindo formulários
← Voltar para React Native Academy