Blog

React Native'de Bir Üst Seviye Form Yönetimi

28 Haziran 2023 10 dk okuma

React Native'de ileri seviye form yönetimi teknikleri. Doğrulama, performans optimizasyonu ve yeniden kullanılabilir form component'leri oluşturmayı öğrenin.

React Native'de Bir Üst Seviye Form Yönetimi
React NativeFormlarDoğrulamaPerformansReact Hook FormZod

React Native'de Bir Üst Seviye Form Yönetimi

Zod ve React Hook Form ile React Native'de form yönetimini geliştirin

Form yönetimi, kullanıcıdan girdi alan her uygulamanın temel bir parçası ve doğru araçlar ve kütüphanelerle basit ve sorunsuz bir süreç olabilir. Bu yazı, react-hook-form ve zod kullanarak bir react-native uygulamasında formları nasıl yöneteceğinizi anlatacak. Bu ikisini birleştirerek verimli bir form yönetimi mekanizması elde edeceğiz. Bunu göstermek için basit bir kayıt formu oluşturalım.

Kaynak kodun tamamı yazının sonunda yer alacak.

Zod ile Şema Tanımlama

Başlangıç olarak şemamızı zod ile tanımlıyoruz. Bu şema, form verimizin beklenen yapısını ortaya koyacak ve her alan için doğrulamaları kuracak. Zod, bu kuralları tanımlamak için bir dizi güçlü doğrulama fonksiyonu sunuyor.

zod şemasının tamamı şöyle:

Bu yazı zod'un temellerini bildiğinizi varsayıyor.

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

Bu şemada her alanın ne içermesi gerektiğini belirtmek için zod kullanıyoruz. Örneğin name ve surname alanları 3 ile 20 karakter arasında string'ler olmalı, phoneNumber alanı ise bir sayı olmalı.

Bazı alanlar için daha karmaşık kurallarımız da var. Örneğin email alanı bir string olmalı ve sadece geçerli e-posta adreslerini kabul etmeli. gender alanı önceden tanımlanmış cinsiyet seçeneklerinden biri ('Male', 'Female' ya da 'Other') olmalı.

Son olarak birthDate alanı date tipinde ve 1900-01-01 ile 2023-01-01 arasında geçerli bir tarih olmalı. Değer verilmezse varsayılan olarak mevcut tarihi alıyor.

zod ile karmaşık doğrulama kurallarını kolayca oluşturabiliyoruz. Bu sayede formumuzdan aldığımız verinin beklediğimizle eşleşeceği garanti altında oluyor.

Bir sonraki adım şemanın tipini çıkarmak (infer). Zod, verilen bir zod şemasının TypeScript tipini türeten bir infer metodu sunuyor.

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

Çıkarılan bu tip daha sonra form verimizin şemamızla uyumlu olmasını sağlamak için useForm içinde kullanılıyor.

React Hook Form ile Form Kurulumu

Ardından formumuzu 'react-hook-form'daki useForm hook'unu kullanarak kuruyoruz. Bu hook, form doğrulamasını çözmek için zod şemamızı (zodResolver aracılığıyla) argüman olarak alıyor.

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

resolver, şemamızı geçtiğimiz yer. defaultValues property'si form alanları için varsayılan değerler vermemizi sağlıyor. Burada varsayılan birthDate'i mevcut tarih olarak ayarlıyoruz. mode property'si doğrulamanın ne zaman yapılacağını belirliyor. Bu örnekte doğrulama onBlur'da, yani kullanıcı bir alandan ayrıldığında gerçekleşecek.

Alanları Render Etmek ve Doğrulamak

Her form alanını yönetmek için react-hook-form'daki Controller component'ini kullanıyoruz. Bize alanın değerini, hata durumunu ve doğrulamasını yönetmek için kullandığımız field ve fieldState props'larını sağlıyor.

Örneğin name alanını şöyle kuruyoruz:

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

Her prop'un ne yaptığı şöyle:

  • control: useForm hook'undan gelen control prop'unu buraya geçiyorsunuz. Controller'ın form state'iyle etkileşime girebilmesi için gerekli.

  • name: Form içindeki input'un değerine erişmek için kullanılan key. Form değerlerini okurken ya da değer atarken kullanılacak key bu. Tüm form alanları arasında benzersiz olmalı.

  • render: Input elemanınızı döndüren bir fonksiyon. Fonksiyon field ve fieldState props'larını sağlıyor.

  • field: onChange, onBlur ve value props'larını içeriyor. Bunlar doğrudan controlled component'inize bağlanmalı. Bu örnekte onChange, TextInput'un onChangeText'ine bağlı; bu da kullanıcının girdisini yakalayıp form state'inde saklayacak.

  • fieldState: Bu alandaki doğrulama hataları hakkında bilgi veren error prop'unu içeriyor.

render prop'unun içinde TextInput özelleştiriliyor. onBlur ve onChangeText, field'daki ilgili metotlara bağlanıyor, value prop'u ise bu input'un mevcut form değerine bağlanıyor. errorMessage prop'u, doğrulama başarısız olursa hata mesajına bağlanıyor.

Yani form gönderiminde ya da anlık doğrulamada 'name' alanı Zod şemasında tanımlanan doğrulama gereksinimlerini karşılamazsa, hata mesajı bu TextInput alanında gösterilecek.

React Hook Form ile Doğrulamayı Elle Tetiklemek

Bir tarih seçici component'i (bu örnekte RNDateTimePicker) kullanan birthDate alanında farklı bir durum ortaya çıkıyor. Burada doğrulama süreci özel bir ele alış gerektiriyor, çünkü kullanıcının bir tarih seçiciyle etkileşimi tipik metin input'larından farklı.

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

Kullanıcı bir tarih seçtiğinde onChange event'i tetikleniyor. Bu event handler'ın içinde önce event tipinin 'set' olup olmadığını kontrol ediyoruz; bu, kullanıcının bir tarih belirlediğini gösteriyor. Ardından bir tarih seçildiğinden emin olmak için timestamp'in olup olmadığını kontrol ediyoruz.

Bu koşulları doğruladıktan sonra new Date(e.nativeEvent.timestamp) kullanarak timestamp'i bir JavaScript Date nesnesine dönüştürüyoruz. Sonra bu yeni değer onChange'e geçiliyor ve formdaki birthDate alanının değeri güncelleniyor.

Ancak değişikliklerde doğrulamayı otomatik olarak tetikleyen tipik metin input'larının aksine, tarih seçiciler doğrulamayı aynı şekilde tetiklemiyor. Bu yüzden değer güncellendikten sonra doğrulamayı elle tetiklememiz gerekiyor. Bunu methods.trigger('birthDate') çağırarak yapıyoruz.

react-hook-form'un sağladığı bu trigger metodu belirli bir alan için doğrulamayı başlatıyor. Burada tarih belirlenir belirlenmez birthDate alanı için doğrulamayı tetikliyor ve doğrulama kurallarımızın hemen uygulanmasını sağlıyor.

Son olarak herhangi bir doğrulama hatası varsa {!!error?.message && {error.message}} aracılığıyla gösterilecek; burada error?.message, zod şemamızda tanımlandığı şekliyle doğrulama hata mesajını içeriyor.

Form Gönderimi: React Hook Form

React-hook-form paketi, form gönderimini ve hata yönetimini ele almak için verimli metotlar sunuyor.

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

Süreci parçalara ayıralım:

onSubmit handler'ı form verisini argüman olarak alıyor. Bu senaryoda sadece bu veriyi logluyoruz, ama gerçek uygulamalarda bir sunucuya gönderilebilir ya da uygulamanın ihtiyaçlarına göre daha fazla işlenebilir.

onError fonksiyonu ise form gönderiminde doğrulama hataları olduğunda çağrılıyor. errors nesnesi, doğrulamadan geçemeyen tüm alanlar hakkında ayrıntılı bilgi içeriyor. Bu örnekte bu hataları sadece logluyoruz.

Her alanda hata olması durumunda error nesnesi şöyle olurdu:

    {
      "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 ile Ön Doğrulama

Aşağıdaki kod bloğu, form gönderim event'inden önce Zod'un safeParse metodunu kullanarak form verisini elle ön doğrulamadan geçirmeye yönelik bir yaklaşım sunuyor. Form doğrulaması zaten React Hook Form'un handleSubmit metodu tarafından ele alınıyor olsa da, ön doğrulama geliştiricilere form doğrulama süreci üzerinde daha fazla kontrol sağlayabilir.

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

Yukarıdaki kodu inceleyelim:

  • Button'un onPress event'i, form gönderiminden önce ön doğrulama yapan bir fonksiyonu çalıştırmak için kullanılıyor.

  • methods'taki (React Hook Form tarafından sağlanan) getValues metodu, mevcut form değerlerini almak için kullanılıyor.

  • Bu değerler daha sonra signUpFormSchema'nın (en başta oluşturduğumuz zod şeması) safeParse metoduna geçiliyor. zod ön doğrulaması bu adımda gerçekleşiyor. zod'un parse metodunun aksine safeParse, doğrulama başarısız olduğunda hata fırlatmıyor. Bunun yerine success boolean'ını ve doğrulama başarısız olduysa bir error nesnesini içeren bir nesne döndürüyor.

  • Bir koşul ifadesi result.success'in false olup olmadığını (yani doğrulamanın başarısız olduğunu) kontrol ediyor. false ise doğrulama hatasını gösteren bir alert tetikleniyor.

  • result.success true ise (yani doğrulama başarılıysa), zod ile doğrulamanın başarılı olduğunu söyleyen bir alert tetikleniyor.

React Hook Form'un handleSubmit'i zod aracılığıyla verilen şemayı kullanarak form doğrulamasını zaten yaptığı için bu yaklaşım gereksiz görünebilir, ama belirli senaryolarda yine de faydalı olabilir. Örneğin bazı işlemleri sadece elle yapılan doğrulamadan sonra gerçekleştirmek isteyebilirsiniz ya da kullanıcı formu doldururken form girdilerini anlık olarak doğrulamak isteyebilirsiniz. Bu gibi durumlarda zod safeParse metoduyla ön doğrulama oldukça faydalı olabilir.

zod error nesnesi de şöyle görünürdü:

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

Gerçekten büyük bir nesne ve bizim durumumuz için gereksiz alanlar bile olabilir. Neyse ki zod, hataları formatlamak için bir metot sunuyor.

Sadece result.error.format() kullanmamız yeterli, gerisini zod kendi içinde hallediyor.

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

Formatlanmış error nesnesi şöyle görünürdü:

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

Son kod

Aşağıda en güncel kod yer alıyor (import'lar ve stiller hariç). Kaynak kodun tamamını görmek isterseniz yazının sonuna bakın.

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

Bu örnek uygulama expo go kullanılarak yazıldı. Yani aşağıdaki QR kodu kullanarak kolayca test edebilirsiniz! (QR çalışmazsa lütfen yazının sonundaki kaynak kod bağlantısına bakın.)

Sonuç

Bu yazı boyunca React Native uygulamamızda sağlam bir form doğrulaması oluşturmak için React Hook Form, Zod ve TypeScript birleşiminden nasıl etkili şekilde yararlanabileceğimizi inceledik. Bu kütüphanelerin esnekliği ve gücünün, karmaşık doğrulama gereksinimlerini karşılayabilen temiz ve tip güvenli kod yazmamızı nasıl sağladığını gördük.

React Hook Form ve Zod'un uyumu, ikisinin de faydalarından yararlanmamızı sağlıyor. React Hook Form form yönetimini basitleştiriyor, yeniden render'ları optimize ediyor ve form state yönetimi ile hata yönetimi gibi özellikler içeriyor. Öte yandan Zod, her form alanı için ne tür verilere izin verildiğini belirtmemizi ve bu kuralları uygulamamızı sağlayarak ekstra bir güvenlik katmanı sunuyor.

Unutmayın, burada gösterilen teknikler basit bir kayıt formu bağlamında kullanılsa da React Native uygulamalarınızdaki form tabanlı her kullanıcı girdisine uygulanabilir. Bu stratejileri kullanarak formlarınızın kullanıcı dostu, sağlam ve sürdürülebilir olmasını sağlayabilir, daha iyi kullanıcı deneyimleri ve daha sağlam uygulamalar elde edebilirsiniz.

Kaynak kodun tamamı