Blog

Penanganan Form React Native Tingkat Lanjut

28 Juni 2023 10 menit baca

Teknik penanganan form tingkat lanjut di React Native. Pelajari validasi, optimasi performa, dan cara membuat komponen form yang reusable.

Penanganan Form React Native Tingkat Lanjut
React NativeFormValidasiPerformaReact Hook FormZod

Penanganan Form React Native Tingkat Lanjut

Meningkatkan Penanganan Form di React Native dengan Zod dan React Hook Form

Penanganan form adalah bagian dasar dari setiap aplikasi yang membutuhkan input pengguna, dan dengan tool serta library yang tepat, prosesnya bisa sederhana dan mulus. Artikel ini akan memandu kamu menangani form di aplikasi react-native menggunakan react-hook-form dan zod. Dengan menggabungkan keduanya, kita akan mendapatkan mekanisme penanganan form yang efisien. Mari kita buat form pendaftaran sederhana sebagai contoh.

Source code lengkap akan disertakan di akhir artikel.

Deklarasi Schema dengan Zod

Sebagai awal, kita mendeklarasikan schema menggunakan zod. Schema ini akan menjabarkan bentuk data form yang kita harapkan dan menyiapkan validasi untuk setiap field. Zod menyediakan banyak fungsi validasi yang ampuh untuk mendefinisikan aturan-aturan ini.

Berikut schema zod lengkapnya:

Artikel ini mengasumsikan kamu sudah memahami dasar-dasar 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>;

Dalam schema ini, kita memakai zod untuk menentukan isi setiap field. Misalnya, field name dan surname harus berupa string dengan panjang 3 sampai 20 karakter, sedangkan field phoneNumber harus berupa angka.

Kita juga punya aturan yang lebih kompleks untuk beberapa field. Contohnya, field email harus berupa string dan hanya menerima alamat email yang valid. Field gender harus salah satu dari pilihan gender yang sudah ditentukan ('Male', 'Female', atau 'Other').

Terakhir, field birthDate bertipe date dan harus berupa tanggal valid antara 1900-01-01 dan 2023-01-01. Secara default, field ini memakai tanggal saat ini jika tidak ada nilai yang diberikan.

Dengan zod, kita bisa membuat aturan validasi yang kompleks dengan mudah. Dengan begitu, data yang kita terima dari form dijamin sesuai dengan yang kita harapkan.

Langkah berikutnya adalah menyimpulkan tipe schema. Zod menyediakan method infer, yang menurunkan tipe TypeScript dari sebuah schema zod.

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

Tipe hasil inferensi ini nantinya dipakai di useForm untuk memastikan data form kita selaras dengan schema.

Setup Form dengan React Hook Form

Selanjutnya, kita menyiapkan form menggunakan hook useForm dari 'react-hook-form'. Hook ini menerima schema zod kita (melalui zodResolver) sebagai argumen untuk menangani validasi form.

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

Resolver adalah tempat kita memasukkan schema. Properti defaultValues memungkinkan kita memberikan nilai default untuk field form. Dalam kasus ini, kita mengatur nilai default birthDate menjadi tanggal saat ini. Properti mode menentukan kapan validasi harus terjadi. Dalam kasus ini, validasi terjadi saat onBlur, yaitu ketika pengguna meninggalkan sebuah field.

Render Field dan Validasi

Kita memakai komponen Controller dari react-hook-form untuk mengelola setiap field form. Komponen ini memberi kita props field dan fieldState yang kita pakai untuk mengelola nilai field, status error, dan validasinya.

Misalnya, begini cara kita menyiapkan field 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}
      />
    );
  }}
/>

Berikut fungsi setiap prop:

  • control: Di sinilah kamu memasukkan prop control dari hook useForm. Prop ini diperlukan agar Controller bisa berinteraksi dengan state form.

  • name: Ini adalah key untuk mengakses nilai input di dalam form. Saat kamu mengambil atau mengatur nilai form, key inilah yang dipakai. Key ini harus unik di antara semua field form.

  • render: Ini adalah fungsi yang mengembalikan elemen input kamu. Fungsi ini menyediakan props field dan fieldState.

  • field: Berisi props onChange, onBlur, dan value. Props ini harus dihubungkan langsung ke controlled component kamu. Dalam kasus ini, onChange dihubungkan ke onChangeText milik TextInput, yang akan menangkap input pengguna dan menyimpannya di state form.

  • fieldState: Berisi prop error yang memberi informasi tentang error validasi untuk field ini.

Di dalam prop render, TextInput dikustomisasi. onBlur dan onChangeText dihubungkan ke method yang sesuai dari field, dan prop value dihubungkan ke nilai form saat ini untuk input tersebut. Prop errorMessage dihubungkan ke pesan error jika validasi gagal.

Jadi, saat form di-submit atau saat validasi real-time, jika field ‘name’ tidak memenuhi syarat validasi yang didefinisikan di schema Zod, pesan error akan ditampilkan di field TextInput ini.

Memicu Validasi Kustom dengan React Hook Form

Skenario khusus muncul saat menangani field birthDate, yang memakai komponen date picker (dalam kasus ini RNDateTimePicker). Dalam situasi ini, proses validasi butuh penanganan khusus karena interaksi pengguna dengan date picker berbeda dari input teks biasa.

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

Saat pengguna memilih tanggal, event onChange dipicu. Di dalam event handler ini, pertama kita memeriksa apakah tipe event adalah 'set', yang menandakan pengguna sudah memilih tanggal. Selanjutnya, kita memeriksa apakah timestamp ada, untuk memastikan tanggal sudah dipilih.

Setelah kondisi ini terpenuhi, kita mengubah timestamp menjadi objek Date JavaScript dengan new Date(e.nativeEvent.timestamp). Lalu nilai baru ini diteruskan ke onChange, yang memperbarui nilai field birthDate di form.

Namun, tidak seperti input teks biasa yang otomatis memicu validasi saat ada perubahan, date picker tidak memicu validasi dengan cara yang sama. Karena itu, kita perlu memicu validasi secara manual setelah nilainya diperbarui. Kita melakukannya dengan memanggil methods.trigger('birthDate').

Method trigger yang disediakan react-hook-form ini memulai validasi untuk field tertentu. Di sini, method tersebut memicu validasi field birthDate segera setelah tanggal dipilih, sehingga aturan validasi kita langsung diterapkan.

Terakhir, jika ada error validasi, error tersebut akan ditampilkan melalui {!!error?.message && {error.message}}, di mana error?.message berisi pesan error validasi seperti yang didefinisikan di schema zod kita.

Submit Form: React Hook Form

Package react-hook-form menyediakan method yang efisien untuk menangani submit form dan penanganan error.

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

Mari kita uraikan prosesnya:

Handler onSubmit menerima data form sebagai argumennya. Dalam skenario ini, kita hanya mencatat data tersebut ke log, tetapi di aplikasi nyata, data itu bisa dikirim ke server atau diolah lebih lanjut sesuai kebutuhan aplikasi.

Sementara itu, fungsi onError dipanggil saat ada error validasi ketika form di-submit. Objek errors berisi informasi detail tentang semua field yang gagal validasi. Dalam contoh ini, kita hanya mencatat error tersebut ke log.

Jika setiap field punya error, objek error-nya akan seperti berikut:

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

Pra-validasi dengan Zod

Blok kode di bawah menunjukkan pendekatan pra-validasi data form secara manual memakai method safeParse dari Zod sebelum event submit form. Walaupun validasi form sudah ditangani oleh method handleSubmit dari React Hook Form, pra-validasi bisa memberi developer kontrol lebih atas proses validasi 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");
    }
  }}
/>

Mari kita analisis kode di atas:

  • Event onPress pada Button dipakai untuk menjalankan fungsi yang melakukan pra-validasi sebelum form di-submit.

  • Method getValues dari methods (yang disediakan React Hook Form) dipakai untuk mengambil nilai form saat ini.

  • Nilai-nilai ini lalu diteruskan ke method safeParse dari signUpFormSchema (schema zod yang kita buat di awal). Di langkah inilah pra-validasi zod terjadi. Berbeda dengan method parse dari zod, safeParse tidak melempar error saat validasi gagal. Sebagai gantinya, method ini mengembalikan objek berisi boolean success dan, jika validasi gagal, sebuah objek error.

  • Sebuah statement kondisional memeriksa apakah result.success bernilai false (artinya validasi gagal). Jika false, sebuah alert ditampilkan dengan error validasinya.

  • Jika result.success bernilai true (artinya validasi berhasil), sebuah alert ditampilkan yang menyatakan bahwa validasi dengan zod berhasil.

Walaupun pendekatan ini mungkin terlihat berlebihan karena handleSubmit dari React Hook Form sudah melakukan validasi form dengan schema dari zod, pendekatan ini tetap bisa bermanfaat di skenario tertentu. Misalnya, kamu mungkin ingin menjalankan aksi tertentu hanya setelah validasi manual, atau kamu ingin memvalidasi input form secara real-time saat pengguna mengisi form. Dalam kasus seperti itu, pra-validasi dengan method safeParse dari zod bisa sangat berguna.

Dan beginilah bentuk objek error dari 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"
    }

Objeknya memang besar, dan mungkin ada field yang tidak diperlukan untuk kasus kita. Untungnya, zod menyediakan method untuk memformat error.

Kita cukup memakai result.error.format() dan sisanya akan ditangani secara internal oleh 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");
}

Objek error yang sudah diformat akan terlihat seperti berikut:

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

Kode terbaru

Berikut kode terbaru (tanpa import dan style). Jika kamu ingin melihat source code lengkapnya, silakan lihat bagian akhir artikel.

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

Aplikasi contoh ini ditulis menggunakan expo go. Artinya kamu bisa mencobanya dengan mudah memakai kode QR di bawah! (jika kode QR tidak berfungsi, silakan lihat tautan source code di akhir artikel.)

Kesimpulan

Di sepanjang artikel ini, kita sudah melihat bagaimana kombinasi React Hook Form, Zod, dan TypeScript bisa dimanfaatkan secara efektif untuk membuat validasi form yang tangguh di aplikasi React Native. Kita sudah melihat bagaimana fleksibilitas dan kekuatan library ini memungkinkan kita menghasilkan kode yang bersih dan type-safe yang mampu menangani kebutuhan validasi yang kompleks.

Sinergi React Hook Form dan Zod memungkinkan kita mendapatkan manfaat dari keduanya. React Hook Form menyederhanakan penanganan form, mengoptimalkan re-render, dan menyertakan fitur seperti pengelolaan state form dan penanganan error. Di sisi lain, Zod memberikan lapisan keamanan tambahan, memungkinkan kita menentukan jenis data yang diizinkan untuk setiap field form dan menegakkan aturan tersebut.

Ingat, walaupun teknik yang ditunjukkan di sini dipakai dalam konteks form SignUp yang sederhana, teknik ini bisa diterapkan pada input pengguna berbasis form apa pun di aplikasi React Native kamu. Dengan menerapkan strategi ini, kamu bisa memastikan form kamu ramah pengguna, tangguh, dan mudah dipelihara, sehingga menghasilkan pengalaman pengguna yang lebih baik dan aplikasi yang lebih andal.

Tautan source code lengkap