# Formulärhantering på nästa nivå i React Native

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

## Formulärhantering på nästa nivå i React Native

Förbättra formulärhanteringen i React Native med Zod och React Hook Form

Formulärhantering är en grundläggande del av alla appar som behöver input från användaren, och med rätt verktyg och bibliotek kan det vara en enkel och smidig process. Den här artikeln visar hur du hanterar formulär i en react-native-app med [react-hook-form](https://react-hook-form.com/) och [zod](https://zod.dev/). Genom att kombinera de två får vi en effektiv mekanism för formulärhantering. Låt oss bygga ett enkelt registreringsformulär för att visa det.

**Hela källkoden finns med i slutet av artikeln.**

### Deklarera schemat med Zod

Till att börja med deklarerar vi vårt schema med zod. Schemat beskriver vilken form vi förväntar oss att formulärdatan har och sätter upp valideringar för varje fält. Zod har en mängd kraftfulla valideringsfunktioner för att definiera de här reglerna.

Här är hela zod-schemat:

Den här artikeln förutsätter att du kan grunderna i 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>;
```

I det här schemat använder vi zod för att ange vad varje fält ska innehålla. Fälten name och surname ska till exempel vara strängar på mellan 3 och 20 tecken, medan fältet phoneNumber ska vara ett nummer.

Vi har också mer komplexa regler för vissa fält. Fältet email ska till exempel vara en sträng och bara giltiga e-postadresser. Fältet gender ska vara ett av de fördefinierade alternativen för kön ('Male', 'Female' eller 'Other').

Till sist är fältet birthDate av typen date och ska vara ett giltigt datum mellan 1900-01-01 och 2023-01-01. Som standard används dagens datum om inget anges.

Med zod kan vi enkelt skapa komplexa valideringsregler. På så sätt är det garanterat att datan vi får från formuläret matchar det vi förväntar oss.

Nästa steg är att härleda schemats typ. Zod har en infer-metod som tar fram TypeScript-typen för ett givet zod-schema.

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

Den härledda typen används senare i useForm för att säkerställa att formulärdatan stämmer med schemat.

### Konfigurera formuläret med React Hook Form

Sedan konfigurerar vi formuläret med hooken useForm från 'react-hook-form'. Hooken tar vårt zod-schema (via zodResolver) som argument för att hantera valideringen av formuläret.

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

I resolver skickar vi in vårt schema. Egenskapen defaultValues låter oss ange standardvärden för formulärfälten. Här sätter vi standardvärdet för birthDate till dagens datum. Egenskapen mode avgör när valideringen ska ske. I det här fallet sker valideringen onBlur, alltså när användaren lämnar ett fält.

### Rendera och validera fält

Vi använder komponenten Controller från react-hook-form för att hantera varje formulärfält. Den ger oss props field och fieldState, som vi använder för att hantera fältets värde, felläge och validering.

Så här konfigurerar vi till exempel fältet 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}
      />
    );
  }}
/>
```

Så här gör varje prop:

- control: Här skickar du in control-propen från hooken useForm. Den behövs för att Controller ska kunna arbeta med formulärets state.

- name: Det här är nyckeln för att komma åt inputens värde i formuläret. När du hämtar eller sätter formulärvärden är det den här nyckeln som används. Den måste vara unik bland alla formulärfält.

- render: Det här är en funktion som returnerar ditt input-element. Funktionen ger dig props field och fieldState.

- field: Innehåller props onChange, onBlur och value. De ska kopplas direkt till din kontrollerade komponent. I det här fallet är onChange kopplad till onChangeText på TextInput, som fångar användarens input och sparar den i formulärets state.

- fieldState: Innehåller propen error, som ger information om valideringsfel för fältet.

Inuti render-propen anpassas TextInput. onBlur och onChangeText kopplas till motsvarande metoder från field, och propen value kopplas till formulärets aktuella värde för den här inputen. Propen errorMessage kopplas till felmeddelandet om valideringen misslyckas.

Så om fältet 'name' inte uppfyller valideringskraven i Zod-schemat, antingen när formuläret skickas eller vid validering i realtid, visas felmeddelandet i det här TextInput-fältet.

### Egen utlösning av validering med React Hook Form

Ett särskilt fall uppstår med fältet birthDate, som använder en datumväljare (i det här fallet RNDateTimePicker). Här kräver valideringen specialhantering, eftersom användaren interagerar med en datumväljare på ett annat sätt än med vanliga textfält.

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

När användaren väljer ett datum utlöses händelsen onChange. I händelsehanteraren kontrollerar vi först om händelsens typ är 'set', vilket betyder att användaren har valt ett datum. Sedan kontrollerar vi att det finns en timestamp, för att säkerställa att ett datum har valts.

När villkoren är uppfyllda konverterar vi timestampen till ett JavaScript Date-objekt med new Date(e.nativeEvent.timestamp). Sedan skickas det nya värdet till onChange, som uppdaterar värdet för fältet birthDate i formuläret.

Men till skillnad från vanliga textfält, som automatiskt utlöser validering vid ändringar, utlöser datumväljare inte validering på samma sätt. Därför behöver vi utlösa valideringen manuellt efter att värdet har uppdaterats. Det gör vi genom att anropa methods.trigger('birthDate').

Metoden trigger från react-hook-form startar validering för ett specifikt fält. Här utlöser den validering för fältet birthDate så fort datumet har satts, så att våra valideringsregler tillämpas direkt.

Till sist visas eventuella valideringsfel via {!!error?.message && <Text>{error.message}</Text>}, där error?.message innehåller valideringsfelets meddelande enligt vårt zod-schema.

### Skicka formuläret med React Hook Form

Paketet react-hook-form har effektiva metoder för att hantera när formulär skickas och för felhantering.

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

Låt oss bryta ner processen:

Hanteraren onSubmit får formulärdatan som argument. I det här fallet loggar vi bara datan, men i riktiga appar kan den skickas till en server eller bearbetas vidare beroende på appens behov.

Funktionen onError anropas däremot när det finns valideringsfel när formuläret skickas. Objektet errors innehåller detaljerad information om alla fält som inte klarade valideringen. I det här exemplet loggar vi bara felen.

Om varje fält har ett fel ser error-objektet ut så här:

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

### Förvalidering med Zod

Kodblocket nedan visar ett sätt att manuellt förvalidera formulärdatan med Zods metod safeParse innan formuläret skickas. Även om valideringen redan sköts av metoden handleSubmit i React Hook Form kan förvalidering ge utvecklare mer kontroll över valideringsprocessen.

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

Låt oss analysera koden ovan:

- Händelsen onPress på Button används för att köra en funktion som förvaliderar innan formuläret skickas.

- Metoden getValues från methods (som kommer från React Hook Form) används för att hämta formulärets aktuella värden.

- Värdena skickas sedan till metoden safeParse på signUpFormSchema (zod-schemat vi skapade i början). Det är i det här steget som förvalideringen med zod sker. Till skillnad från zods parse-metod kastar safeParse inget fel när valideringen misslyckas. I stället returnerar den ett objekt med det booleska värdet success och, om valideringen misslyckades, ett error-objekt.

- En villkorssats kontrollerar om result.success är false (vilket betyder att valideringen misslyckades). Om det är false visas en alert med valideringsfelet.

- Om result.success är true (vilket betyder att valideringen lyckades) visas en alert som säger att valideringen med zod lyckades.

Även om det här sättet kan verka överflödigt, eftersom handleSubmit i React Hook Form redan validerar formuläret med schemat från zod, kan det ändå vara användbart i vissa fall. Du kanske till exempel vill utföra vissa handlingar först efter en manuell validering, eller validera formulärets fält i realtid medan användaren fyller i formuläret. I sådana fall kan förvalidering med zods metod safeParse vara riktigt användbar.

Och så här ser zods error-objekt ut:

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

Det är verkligen ett stort objekt, och det kan till och med innehålla fält som vi inte behöver i vårt fall. Som tur är har zod en metod för att [formatera fel](https://zod.dev/?id=error-formatting).

Vi kan helt enkelt använda result.error.format(), så sköter zod resten internt.

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

Det formaterade error-objektet ser ut så här:

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

### Den senaste koden

Här är den senaste koden (utan imports och styles). Om du vill se hela källkoden hittar du den i slutet av artikeln.

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

Den här exempelappen är skriven med [expo go](https://expo.dev/client). Det betyder att du enkelt kan testa den med QR-koden nedan! _(om QR-koden inte fungerar, se länken till källkoden i slutet av artikeln.)_

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

### Slutsats

I den här artikeln har vi sett hur vi effektivt kan kombinera React Hook Form, Zod och TypeScript för att skapa robust formulärvalidering i vår React Native-app. Vi har sett hur flexibiliteten och kraften i de här biblioteken gör att vi kan skriva ren, typsäker kod som klarar komplexa valideringskrav.

Samspelet mellan React Hook Form och Zod gör att vi får fördelarna med båda. React Hook Form förenklar formulärhanteringen, optimerar omrenderingar och har funktioner som hantering av formulärets state och felhantering. Zod ger å andra sidan ett extra säkerhetslager, där vi kan ange vilken sorts data som är tillåten i varje formulärfält och se till att reglerna följs.

Kom ihåg att även om teknikerna här används i ett enkelt registreringsformulär går de att använda för all formulärbaserad input från användare i dina React Native-appar. Med de här strategierna kan du se till att dina formulär är användarvänliga, robusta och lätta att underhålla, vilket leder till bättre användarupplevelser och stabilare appar.

[**Länk till hela källkoden**](https://github.com/tarikfp/rn-zod-react-hook-form)

