# Gestione dei form in React Native a un altro livello

By Tarik Pinarci (https://tarikpinarci.com). Published 2023-06-28. Canonical: https://tarikpinarci.com/it/blog/react-native-next-level-form-handling

## Gestione dei form in React Native a un altro livello

Migliorare la gestione dei form in React Native con Zod e React Hook Form

La gestione dei form è una parte fondamentale di qualsiasi applicazione che chiede dati all'utente, e con gli strumenti e le librerie giusti può essere un processo semplice e fluido. Questo articolo ti guida nella gestione dei form in un'app react-native usando [react-hook-form](https://react-hook-form.com/) e [zod](https://zod.dev/). Combinandoli otterremo un meccanismo di gestione dei form efficiente. Per mostrarlo, creiamo un semplice form di registrazione.

**Il codice sorgente completo è alla fine dell'articolo.**

### Dichiarare lo schema con Zod

Per cominciare, dichiariamo il nostro schema con zod. Lo schema descrive la forma attesa dei dati del form e imposta le validazioni per ogni campo. Zod offre un gran numero di funzioni di validazione potenti per definire queste regole.

Ecco lo schema zod completo:

Questo articolo dà per scontato che tu conosca le basi di zod.

```tsx
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>;
```

In questo schema usiamo zod per specificare cosa deve contenere ogni campo. Per esempio, i campi name e surname devono essere stringhe lunghe tra 3 e 20 caratteri, mentre il campo phoneNumber deve essere un numero.

Per alcuni campi abbiamo anche regole più complesse. Per esempio, il campo email deve essere una stringa e accettare solo indirizzi email validi. Il campo gender deve essere una delle opzioni predefinite ('Male', 'Female' o 'Other').

Infine, il campo birthDate è di tipo data e deve essere una data valida compresa tra il 1900-01-01 e il 2023-01-01. Se non viene fornita, di default prende la data corrente.

Con zod possiamo creare regole di validazione complesse con facilità. Così i dati che riceviamo dal form corrisponderanno di sicuro a quello che ci aspettiamo.

Il passo successivo è inferire il tipo dello schema. Zod offre un metodo infer, che ricava il tipo TypeScript di un dato schema zod.

    export type SignUpFormSchema = z.infer<typeof signUpFormSchema>;

Questo tipo inferito viene poi usato in useForm per assicurarci che i dati del form siano allineati allo schema.

### Configurare il form con React Hook Form

Poi configuriamo il form con l'hook useForm di 'react-hook-form'. Questo hook riceve come argomento il nostro schema zod (tramite zodResolver) per risolvere la validazione del form.

```tsx
const methods = useForm<SignUpFormSchema>({
  resolver: zodResolver(signUpFormSchema),
  defaultValues: {
    birthDate: new Date(),
  },
  mode: "onBlur",
});
```

Nel resolver passiamo lo schema. La proprietà defaultValues ci permette di fornire valori predefiniti per i campi del form. In questo caso impostiamo come birthDate predefinita la data corrente. La proprietà mode stabilisce quando deve avvenire la validazione. Qui la validazione avviene onBlur, cioè quando l'utente lascia un campo.

### Rendering e validazione dei campi

Usiamo il componente Controller di react-hook-form per gestire ogni campo del form. Ci fornisce le props field e fieldState, che usiamo per gestire il valore del campo, lo stato di errore e la validazione.

Per esempio, ecco come configuriamo il campo name:

```tsx
<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}
      />
    );
  }}
/>
```

Ecco cosa fa ogni prop:

- control: qui passi la prop control dell'hook useForm. Serve al Controller per interagire con lo state del form.

- name: è la chiave per accedere al valore dell'input all'interno del form. Quando leggi o imposti i valori del form, si usa questa chiave. Deve essere unica tra tutti i campi del form.

- render: è una funzione che restituisce il tuo elemento di input. La funzione fornisce le props field e fieldState.

- field: contiene le props onChange, onBlur e value. Vanno collegate direttamente al tuo componente controllato. In questo caso onChange è collegato a onChangeText del TextInput, che cattura l'input dell'utente e lo salva nello state del form.

- fieldState: include la prop error, che dà informazioni sugli errori di validazione di questo campo.

Dentro la prop render, il TextInput è personalizzato. onBlur e onChangeText sono collegati ai rispettivi metodi di field, e la prop value è legata al valore corrente del form per questo input. La prop errorMessage è collegata al messaggio di errore in caso di validazione fallita.

Quindi, all'invio del form o durante la validazione in tempo reale, se il campo 'name' non rispetta i requisiti di validazione definiti nello schema Zod, il messaggio di errore verrà mostrato in questo TextInput.

### Attivare la validazione a mano con React Hook Form

Un caso particolare si presenta con il campo birthDate, che usa un componente date picker (in questo caso RNDateTimePicker). Qui la validazione richiede una gestione speciale, perché l'interazione dell'utente con un date picker è diversa da quella con i normali input di testo.

```tsx
<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>
    );
  }}
/>
```

Quando l'utente seleziona una data, scatta l'evento onChange. Dentro questo handler controlliamo prima se il tipo di evento è 'set', che indica che l'utente ha impostato una data. Poi controlliamo che sia presente un timestamp, per essere sicuri che sia stata selezionata una data.

Verificate queste condizioni, convertiamo il timestamp in un oggetto Date di JavaScript con new Date(e.nativeEvent.timestamp). Poi passiamo questo nuovo valore a onChange, che aggiorna il valore del campo birthDate nel form.

Però, a differenza dei normali input di testo che attivano la validazione automaticamente a ogni modifica, i date picker non la attivano allo stesso modo. Dobbiamo quindi attivare la validazione a mano dopo l'aggiornamento del valore. Lo facciamo chiamando methods.trigger('birthDate').

Il metodo trigger fornito da react-hook-form avvia la validazione per un campo specifico. Qui attiva la validazione del campo birthDate appena la data viene impostata, così le nostre regole di validazione vengono applicate subito.

Infine, se ci sono errori di validazione, vengono mostrati tramite {!!error?.message && <Text>{error.message}</Text>}, dove error?.message contiene il messaggio di errore di validazione definito nel nostro schema zod.

### Invio del form con React Hook Form

Il pacchetto react-hook-form offre metodi efficienti per gestire l'invio dei form e gli errori.

```tsx
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"}
/>;
```

Analizziamo il processo:

L'handler onSubmit riceve come argomento i dati del form. In questo esempio ci limitiamo a stamparli nel log, ma in un'applicazione reale potrebbero essere inviati a un server o elaborati ulteriormente secondo le esigenze dell'applicazione.

La funzione onError, invece, viene chiamata quando all'invio del form ci sono errori di validazione. L'oggetto errors contiene informazioni dettagliate su tutti i campi che non hanno superato la validazione. In questo esempio ci limitiamo a stampare questi errori nel log.

Se ogni campo ha un errore, l'oggetto error sarà il seguente:

```tsx
    {
      "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"
        }
      }
    }
```

### Pre-validazione con Zod

Il blocco di codice qui sotto mostra un modo per pre-validare a mano i dati del form con il metodo safeParse di Zod prima dell'evento di invio. Anche se della validazione del form si occupa già il metodo handleSubmit di React Hook Form, la pre-validazione può dare agli sviluppatori più controllo sul processo.

```tsx
<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");
    }
  }}
/>
```

Analizziamo il codice qui sopra:

- L'evento onPress del Button esegue una funzione che fa la pre-validazione prima dell'invio del form.

- Il metodo getValues di methods (fornito da React Hook Form) serve a leggere i valori correnti del form.

- Questi valori vengono poi passati al metodo safeParse di signUpFormSchema (lo schema zod che abbiamo creato all'inizio). È in questo passo che avviene la pre-validazione con zod. A differenza del metodo parse di zod, safeParse non lancia un errore quando la validazione fallisce. Restituisce invece un oggetto con il booleano success e, se la validazione è fallita, un oggetto error.

- Un'istruzione condizionale controlla se result.success è false (cioè se la validazione è fallita). Se è false, mostra un alert con l'errore di validazione.

- Se result.success è true (cioè se la validazione è riuscita), mostra un alert che dice che la validazione con zod è andata a buon fine.

Anche se questo approccio può sembrare ridondante, visto che handleSubmit di React Hook Form esegue già la validazione con lo schema fornito tramite zod, in certi scenari può comunque essere utile. Per esempio, potresti voler eseguire certe azioni solo dopo una validazione manuale, o validare gli input in tempo reale mentre l'utente compila il form. In questi casi la pre-validazione con il metodo safeParse di zod può essere molto utile.

Ed ecco come sarebbe l'oggetto di errore di zod:

```tsx
    {
      "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"
    }
```

È un oggetto davvero grande, e potrebbe contenere campi inutili per il nostro caso. Per fortuna zod offre un metodo per [formattare gli errori](https://zod.dev/?id=error-formatting).

Basta usare result.error.format() e al resto pensa zod internamente.

```tsx
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'oggetto di errore formattato sarebbe così:

```tsx
    {
      "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"
        ]
      }
    }
```

### Il codice finale

Ecco il codice più recente (senza import e stili). Se vuoi vedere il codice sorgente completo, lo trovi alla fine dell'articolo.

```tsx
// 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...
```

Questa app di esempio è scritta con [expo go](https://expo.dev/client). Significa che puoi provarla facilmente con il codice QR qui sotto! _(se il QR non funziona, usa il link al codice sorgente alla fine dell'articolo.)_

![](https://cdn-images-1.medium.com/max/2000/1*64aqLz3tRQIFDm3ZXbvIdw.png)

### Conclusione

In questo articolo abbiamo visto come sfruttare in modo efficace la combinazione di React Hook Form, Zod e TypeScript per creare una validazione dei form solida nella nostra applicazione React Native. Abbiamo visto come la flessibilità e la potenza di queste librerie ci permettano di scrivere codice pulito e type safe, in grado di gestire requisiti di validazione complessi.

L'unione di React Hook Form e Zod ci fa godere dei vantaggi di entrambi. React Hook Form semplifica la gestione dei form, ottimizza i re-render e include funzioni come la gestione dello state del form e degli errori. Zod, dal canto suo, aggiunge un livello di sicurezza in più, permettendoci di specificare quali dati sono ammessi per ogni campo del form e di far rispettare queste regole.

Ricorda: anche se le tecniche mostrate qui sono usate in un semplice form di registrazione, si applicano a qualsiasi input dell'utente basato su form nelle tue applicazioni React Native. Usando queste strategie puoi avere form facili da usare, solidi e manutenibili, con esperienze utente migliori e applicazioni più robuste.

[**Link al codice sorgente completo**](https://github.com/tarikfp/rn-zod-react-hook-form)

