# React Nativeのフォーム処理を次のレベルへ

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

## React Nativeのフォーム処理を次のレベルへ

ZodとReact Hook FormでReact Nativeのフォーム処理を強化する

フォーム処理は、ユーザーの入力を必要とするあらゆるアプリケーションの基本的な部分です。適切なツールとライブラリがあれば、シンプルでスムーズな作業にできます。この記事では、[react-hook-form](https://react-hook-form.com/)と[zod](https://zod.dev/)を使って、react-nativeアプリでフォームを扱う方法を紹介します。この2つを組み合わせることで、効率的なフォーム処理の仕組みを実現できます。説明のために、基本的なサインアップフォームを作ってみましょう。

**完全なソースコードは記事の最後に掲載しています。**

### Zodによるスキーマの宣言

まずはzodを使ってスキーマを宣言します。このスキーマは、フォームのデータがどんな形であるべきかを示し、各フィールドのバリデーションを設定します。Zodには、こうしたルールを定義するための強力なバリデーション関数がたくさん用意されています。

zodのスキーマ全体はこちらです。

この記事は、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>;
```

このスキーマでは、zodを使って各フィールドが何を含むべきかを指定しています。たとえば、nameとsurnameのフィールドは3文字から20文字の文字列、phoneNumberのフィールドは数値である必要があります。

一部のフィールドには、より複雑なルールもあります。たとえば、emailのフィールドは文字列で、有効なメールアドレスだけを受け付けます。genderのフィールドは、あらかじめ定義された性別の選択肢('Male'、'Female'、'Other')のいずれかである必要があります。

最後に、birthDateのフィールドは日付型で、1900-01-01から2023-01-01までの有効な日付である必要があります。値が渡されなければ、デフォルトで現在の日付になります。

zodを使えば、複雑なバリデーションのルールを簡単に作れます。こうすることで、フォームから受け取るデータが期待どおりであることが保証されます。

次のステップは、スキーマの型を推論することです。Zodにはinferメソッドがあり、zodのスキーマからTypeScriptの型を導き出してくれます。

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

この推論された型は、あとでuseFormの中で使い、フォームのデータがスキーマと一致するようにします。

### React Hook Formによるフォームのセットアップ

次に、'react-hook-form'のuseForm hookを使ってフォームをセットアップします。このhookは、フォームのバリデーションを解決するために、zodのスキーマを(zodResolverを通して)引数として受け取ります。

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

resolverにはスキーマを渡します。defaultValuesプロパティでは、フォームのフィールドのデフォルト値を指定できます。ここでは、birthDateのデフォルトを現在の日付にしています。modeプロパティは、いつバリデーションを行うかを決めます。ここでは、バリデーションはonBlur、つまりユーザーがフィールドから離れたときに行われます。

### フィールドの描画とバリデーション

各フォームのフィールドを管理するには、react-hook-formのControllerコンポーネントを使います。ControllerはfieldとfieldStateというpropsを渡してくれるので、それを使ってフィールドの値、エラーの状態、バリデーションを管理します。

たとえば、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}
      />
    );
  }}
/>
```

各propの役割は次のとおりです。

- control: useForm hookから受け取ったcontrol propをここに渡します。Controllerがフォームのstateとやり取りするために必要です。

- name: フォームの中でこの入力の値にアクセスするためのキーです。フォームの値を取得したり設定したりするときに、このキーが使われます。すべてのフォームのフィールドの中で一意である必要があります。

- render: 入力要素を返す関数です。この関数はfieldとfieldStateのpropsを受け取ります。

- field: onChange、onBlur、valueのpropsを含みます。これらは制御されたコンポーネントに直接つなぐ必要があります。ここでは、onChangeをTextInputのonChangeTextにつないでいるので、ユーザーの入力を受け取ってフォームのstateに保存します。

- fieldState: このフィールドのバリデーションエラーについての情報を持つerror propを含みます。

render propの中で、TextInputをカスタマイズしています。onBlurとonChangeTextはfieldのそれぞれのメソッドにつなぎ、value propはこの入力の現在のフォームの値にひもづけています。errorMessage propは、バリデーションに失敗したときのエラーメッセージにつないでいます。

つまり、フォームの送信時やリアルタイムのバリデーションで、「name」のフィールドがZodのスキーマで定義されたバリデーションの要件を満たさない場合、このTextInputのフィールドにエラーメッセージが表示されます。

### React Hook Formで独自にバリデーションを発火する

日付ピッカーのコンポーネント(ここではRNDateTimePicker)を使うbirthDateのフィールドでは、少し特殊な状況が生まれます。日付ピッカーに対するユーザーの操作は通常のテキスト入力とは異なるため、バリデーションの処理に特別な対応が必要になります。

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

ユーザーが日付を選ぶと、onChangeイベントが発火します。このイベントハンドラーの中では、まずイベントの種類が'set'かどうかを確認します。これはユーザーが日付を設定したことを示します。次に、日付が選ばれたことを確かめるため、timestampがあるかを確認します。

これらの条件を確認できたら、new Date(e.nativeEvent.timestamp)を使ってtimestampをJavaScriptのDateオブジェクトに変換します。そしてこの新しい値をonChangeに渡し、フォームのbirthDateのフィールドの値を更新します。

ただし、変更があると自動でバリデーションを発火する通常のテキスト入力とは違い、日付ピッカーは同じようにはバリデーションを発火しません。そのため、値を更新したあとに手動でバリデーションを発火する必要があります。そのためにmethods.trigger('birthDate')を呼びます。

react-hook-formが提供するこのtriggerメソッドは、特定のフィールドのバリデーションを開始します。ここでは、日付が設定されるとすぐにbirthDateのフィールドのバリデーションを発火し、バリデーションのルールがただちに適用されるようにしています。

最後に、バリデーションエラーがあれば{!!error?.message && <Text>{error.message}</Text>}で表示されます。error?.messageには、zodのスキーマで定義したバリデーションのエラーメッセージが入っています。

### フォームの送信: React Hook Form

react-hook-formパッケージには、フォームの送信とエラー処理を効率よく扱うためのメソッドが用意されています。

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

処理を分解してみましょう。

onSubmitハンドラーは、フォームのデータを引数として受け取ります。ここではデータをログに出しているだけですが、実際のアプリケーションでは、サーバーに送ったり、アプリケーションの必要に応じてさらに加工したりできます。

一方、onError関数は、フォームの送信時にバリデーションエラーがあると呼び出されます。errorsオブジェクトには、バリデーションに失敗したすべてのフィールドについての詳しい情報が入っています。この例では、それらのエラーをログに出しているだけです。

すべてのフィールドにエラーがある場合、errorオブジェクトは次のようになります。

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

### Zodによる事前バリデーション

以下のコードブロックは、フォームの送信イベントの前に、ZodのsafeParseメソッドを使ってフォームのデータを手動で事前バリデーションする方法を示しています。フォームのバリデーションはすでにReact Hook FormのhandleSubmitメソッドが担ってくれていますが、事前バリデーションを使うと、開発者はフォームのバリデーションの流れをより細かくコントロールできます。

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

上のコードを分析してみましょう。

- ButtonのonPressイベントで、フォームの送信前に事前バリデーションを行う関数を実行しています。

- methods(React Hook Formが提供するもの)のgetValuesメソッドを使って、現在のフォームの値を取得しています。

- 次に、これらの値をsignUpFormSchema(最初に作ったzodのスキーマ)のsafeParseメソッドに渡します。ここでzodによる事前バリデーションが行われます。zodのparseメソッドとは違い、safeParseはバリデーションに失敗してもエラーを投げません。代わりに、successというbooleanと、バリデーションに失敗した場合はerrorオブジェクトを含むオブジェクトを返します。

- 条件文でresult.successがfalse(バリデーションの失敗を示す)かどうかを確認します。falseなら、バリデーションエラーを表示するアラートを出します。

- result.successがtrue(バリデーションの成功を示す)なら、zodでのバリデーションに成功したことを伝えるアラートを出します。

React Hook FormのhandleSubmitがすでにzodで渡したスキーマを使ってフォームのバリデーションを行っているので、この方法は冗長に見えるかもしれません。それでも、特定の場面では役に立ちます。たとえば、手動でバリデーションしたあとにだけ特定の処理を行いたい場合や、ユーザーがフォームに入力している最中にリアルタイムで入力をバリデーションしたい場合です。そうしたケースでは、zodのsafeParseメソッドを使った事前バリデーションがとても便利です。

zodのエラーオブジェクトは次のようになります。

```tsx
    {
      "issues": [
        {
          "code": "invalid_type",
          "expected": "string",
          "received": "undefined",
          "path": [
            "name"
          ],
          "message": "This field is required"
        },
        {
          "code": "invalid_type",
          "expected": "string",
          "received": "undefined",
          "path": [
            "surname"
          ],
          "message": "This field is required"
        },
        {
          "code": "invalid_type",
          "expected": "string",
          "received": "undefined",
          "path": [
            "phoneNumber"
          ],
          "message": "This field is required"
        },
        {
          "code": "invalid_type",
          "expected": "string",
          "received": "undefined",
          "path": [
            "email"
          ],
          "message": "This field is required"
        },
        {
          "expected": "'Male' | 'Female' | 'Other'",
          "received": "undefined",
          "code": "invalid_type",
          "path": [
            "gender"
          ],
          "message": "This field is required"
        },
        {
          "code": "too_big",
          "message": "Invalid date time, too young",
          "inclusive": true,
          "exact": false,
          "maximum": 1672531200000,
          "type": "date",
          "path": [
            "birthDate"
          ]
        }
      ],
      "name": "ZodError"
    }
```

確かに大きなオブジェクトで、今回のケースには不要なフィールドも含まれているかもしれません。幸い、zodには[エラーを整形する](https://zod.dev/?id=error-formatting)ためのメソッドが用意されています。

result.error.format()を使うだけで、あとはzodが内部で処理してくれます。

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

整形されたエラーオブジェクトは次のようになります。

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

### 最新のコード

以下が最新のコードです(importとstyleは除いています)。完全なソースコードを見たい場合は、記事の最後を参照してください。

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

このサンプルアプリは[expo go](https://expo.dev/client)を使って書かれています。つまり、下のQRコードを使って簡単に試せます! _(QRコードがうまく動かない場合は、記事の最後にあるソースコードのリンクを参照してください。)_

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

### まとめ

この記事では、React Hook Form、Zod、TypeScriptの組み合わせをうまく活用して、React Nativeアプリケーションで堅牢なフォームのバリデーションを作る方法を見てきました。これらのライブラリの柔軟性と力によって、複雑なバリデーションの要件に対応できる、きれいで型安全なコードを書けることがわかりました。

React Hook FormとZodの相乗効果で、両方の利点を享受できます。React Hook Formはフォーム処理をシンプルにし、再レンダリングを最適化し、フォームのstate管理やエラー処理などの機能を備えています。一方、Zodは安全性をさらに一段階高めてくれます。各フォームのフィールドにどんなデータを許可するかを指定し、そのルールを強制できます。

ここで紹介したテクニックはシンプルなサインアップフォームの文脈で使いましたが、React Nativeアプリケーションのあらゆるフォームベースのユーザー入力に応用できることを覚えておいてください。これらの戦略を取り入れることで、フォームを使いやすく、堅牢で、保守しやすいものにでき、より良いユーザー体験とより堅牢なアプリケーションにつながります。

[**完全なソースコードのリンク**](https://github.com/tarikfp/rn-zod-react-hook-form)

