Блог

Робота з формами в React Native на новому рівні

28 червня 2023 р. 10 хв читання

Просунуті прийоми роботи з формами в React Native: валідація, оптимізація продуктивності та створення компонентів форм для повторного використання.

Робота з формами в React Native на новому рівні
React NativeФормиВалідаціяПродуктивністьReact Hook FormZod

Робота з формами в React Native на новому рівні

Покращуємо роботу з формами в React Native за допомогою Zod і React Hook Form

Робота з формами є базовою частиною будь-якого застосунку, де користувач щось вводить, і з правильними інструментами та бібліотеками вона може бути простою та зручною. У цій статті я покажу, як працювати з формами в застосунку на react-native за допомогою react-hook-form і zod. Поєднавши їх, ми отримаємо ефективний механізм роботи з формами. Для прикладу створимо просту форму реєстрації.

Повний вихідний код буде наприкінці статті.

Оголошення схеми за допомогою Zod

Спершу оголосимо схему за допомогою zod. Ця схема описує очікувану структуру даних форми та задає валідацію для кожного поля. Zod має багато потужних функцій валідації для опису таких правил.

Ось повна схема zod:

У статті я припускаю, що ви знаєте основи zod.

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

У цій схемі ми через zod вказуємо, що має містити кожне поле. Наприклад, поля name і surname мають бути рядками довжиною від 3 до 20 символів, а поле phoneNumber має бути числом.

Для деяких полів правила складніші. Наприклад, поле email має бути рядком і приймає лише коректні адреси електронної пошти. Поле gender має бути одним із заздалегідь визначених варіантів ('Male', 'Female' або 'Other').

Нарешті, поле birthDate має тип дати і повинно містити коректну дату між 1900-01-01 і 2023-01-01. Якщо дату не передано, за замовчуванням береться поточна.

З zod можна легко створювати складні правила валідації. Так дані, які ми отримуємо з форми, гарантовано відповідатимуть нашим очікуванням.

Наступний крок: вивести тип зі схеми. Zod має метод infer, який виводить тип TypeScript із заданої схеми zod.

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

Цей виведений тип далі використовується в useForm, щоб дані форми відповідали нашій схемі.

Налаштування форми з React Hook Form

Далі налаштуємо форму за допомогою хука useForm з 'react-hook-form'. Цей хук приймає нашу схему zod (через zodResolver) як аргумент для валідації форми.

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

У resolver ми передаємо нашу схему. Властивість defaultValues дає змогу задати значення полів за замовчуванням. Тут ми ставимо поточну дату як значення birthDate за замовчуванням. Властивість mode визначає, коли відбувається валідація. У нашому випадку валідація спрацьовує onBlur, тобто коли користувач залишає поле.

Відображення полів і валідація

Для кожного поля форми ми використовуємо компонент Controller з react-hook-form. Він дає нам пропси field і fieldState, через які ми керуємо значенням поля, станом помилки та валідацією.

Наприклад, ось як ми налаштовуємо поле name:

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

Ось що робить кожен проп:

  • control: сюди передаємо проп control з хука useForm. Він потрібен, щоб Controller міг взаємодіяти зі станом форми.

  • name: ключ, за яким доступне значення поля у формі. Коли ви читаєте або встановлюєте значення форми, використовується саме цей ключ. Він має бути унікальним серед усіх полів форми.

  • render: функція, яка повертає ваш елемент введення. Вона отримує пропси field і fieldState.

  • field: містить пропси onChange, onBlur і value. Їх слід напряму підʼєднати до вашого контрольованого компонента. Тут onChange підʼєднано до onChangeText у TextInput, тож він перехоплює те, що вводить користувач, і зберігає це в стані форми.

  • fieldState: містить проп error з інформацією про помилки валідації цього поля.

Усередині пропа render ми налаштовуємо TextInput. onBlur і onChangeText привʼязані до відповідних методів з field, а проп value привʼязаний до поточного значення цього поля у формі. Проп errorMessage отримує повідомлення про помилку, якщо валідація не пройшла.

Отже, під час надсилання форми або валідації в реальному часі, якщо поле ‘name’ не відповідає вимогам зі схеми Zod, повідомлення про помилку зʼявиться в цьому TextInput.

Ручний запуск валідації в React Hook Form

Особливий випадок виникає з полем birthDate, яке використовує компонент вибору дати (тут RNDateTimePicker). Валідація тут потребує окремої обробки, бо користувач взаємодіє з вибором дати інакше, ніж зі звичайним текстовим полем.

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

Коли користувач вибирає дату, спрацьовує подія onChange. В обробнику спершу перевіряємо, чи тип події 'set', що означає, що користувач встановив дату. Далі перевіряємо, чи є timestamp, щоб переконатися, що дату справді вибрано.

Якщо обидві умови виконано, перетворюємо timestamp на обʼєкт Date у JavaScript за допомогою new Date(e.nativeEvent.timestamp). Потім передаємо це нове значення в onChange, і воно оновлює значення поля birthDate у формі.

Проте, на відміну від звичайних текстових полів, які автоматично запускають валідацію при зміні, вибір дати так не робить. Тому після оновлення значення валідацію треба запустити вручну. Для цього викликаємо methods.trigger('birthDate').

Метод trigger з react-hook-form запускає валідацію конкретного поля. Тут він перевіряє поле birthDate одразу після встановлення дати, тож наші правила валідації застосовуються негайно.

Нарешті, якщо є помилки валідації, вони відображаються через {!!error?.message && {error.message}}, де error?.message містить повідомлення про помилку, задане в нашій схемі zod.

Надсилання форми з React Hook Form

Пакет react-hook-form має зручні методи для надсилання форми та обробки помилок.

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

Розберімо процес:

Обробник onSubmit отримує дані форми як аргумент. Тут ми просто виводимо ці дані в лог, але в реальному застосунку їх можна надіслати на сервер або обробити далі, залежно від потреб.

Функція onError натомість викликається, коли під час надсилання форми є помилки валідації. Обʼєкт errors містить детальну інформацію про всі поля, які не пройшли валідацію. У цьому прикладі ми просто виводимо ці помилки в лог.

Якщо помилка є в кожному полі, обʼєкт помилок виглядатиме так:

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

Попередня валідація з Zod

Блок коду нижче показує підхід, коли дані форми перевіряються вручну методом safeParse з Zod ще до події надсилання форми. Хоча валідацію форми вже виконує метод handleSubmit з React Hook Form, попередня валідація дає розробникам більше контролю над процесом.

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

Розберімо код вище:

  • Подія onPress кнопки Button запускає функцію, яка виконує попередню валідацію перед надсиланням форми.

  • Метод getValues з methods (його надає React Hook Form) повертає поточні значення форми.

  • Ці значення передаються в метод safeParse схеми signUpFormSchema (схеми zod, яку ми створили на початку). Саме тут відбувається попередня валідація через zod. На відміну від методу parse, safeParse не кидає помилку, якщо валідація не пройшла. Натомість він повертає обʼєкт з булевим success і, якщо валідація не пройшла, обʼєктом error.

  • Умова перевіряє, чи result.success дорівнює false (тобто валідація не пройшла). Якщо так, показується alert з помилкою валідації.

  • Якщо result.success дорівнює true (валідація успішна), показується alert, що валідація через zod пройшла успішно.

Хоча цей підхід може здатися зайвим, бо handleSubmit з React Hook Form уже перевіряє форму за схемою з zod, у певних випадках він корисний. Наприклад, ви можете хотіти виконати якісь дії лише після ручної валідації або перевіряти поля в реальному часі, поки користувач заповнює форму. У таких випадках попередня валідація методом safeParse з zod дуже стане в пригоді.

А ось так виглядатиме обʼєкт помилки zod:

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

Це справді великий обʼєкт, і в ньому можуть бути навіть непотрібні для нас поля. На щастя, zod має метод для форматування помилок.

Можна просто викликати result.error.format(), а решту zod зробить сам.

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

Відформатований обʼєкт помилки виглядатиме так:

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

Остаточний код

Нижче найсвіжіша версія коду (без імпортів і стилів). Якщо хочете переглянути повний вихідний код, дивіться посилання наприкінці статті.

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

Цей демонстраційний застосунок написано з використанням expo go. Тобто його легко протестувати через QR код нижче! (якщо QR код не працює, скористайтеся посиланням на вихідний код наприкінці статті.)

Висновок

У цій статті ми розглянули, як ефективно поєднати React Hook Form, Zod і TypeScript, щоб зробити надійну валідацію форм у застосунку на React Native. Ми побачили, як гнучкість і можливості цих бібліотек дають змогу писати чистий, типобезпечний код, що впорається зі складними вимогами до валідації.

Поєднання React Hook Form і Zod дає переваги обох. React Hook Form спрощує роботу з формами, оптимізує повторні рендери і має такі функції, як керування станом форми та обробка помилок. Zod, своєю чергою, додає ще один рівень безпеки: дає змогу вказати, які дані допустимі для кожного поля форми, і забезпечує дотримання цих правил.

Памʼятайте: хоча тут ці прийоми показано на прикладі простої форми реєстрації, вони підходять для будь-якого введення даних через форми у ваших застосунках на React Native. Застосовуючи ці підходи, ви зробите форми зручними, надійними й легкими в підтримці, а це означає кращий досвід для користувачів і надійніші застосунки.

Посилання на повний вихідний код