Validation

Validation is a very common task in web applications. Data entered in forms needs to be validated. Data also needs to be validated before it is written into a database or passed to a web service.

検証は、Web アプリケーションでは非常に一般的なタスクです。フォームに入力されたデータは検証する必要があります。データは、データベースに書き込まれたり Web サービスに渡されたりする前にも検証する必要があります。

Symfony provides a Validator component to handle this for you. This component is based on the JSR303 Bean Validation specification.

Symfony は、これを処理する Validator コンポーネントを提供します。このコンポーネントは、JSR303 Bean Validation 仕様に基づいています。

Installation

In applications using Symfony Flex, run this command to install the validator before using it:

Symfony Flex を使用するアプリケーションでは、次のコマンドを実行して、バリデーターを使用する前にインストールします。
1
 
$ composer require symfony/validator

Note

ノート

If your application doesn't use Symfony Flex, you might need to do some manual configuration to enable validation. Check out the Validation configuration reference.

アプリケーションが Symfony Flex を使用していない場合は、検証を有効にするために手動で構成する必要がある場合があります。検証構成リファレンスを確認してください。

The Basics of Validation

The best way to understand validation is to see it in action. To start, suppose you've created a plain-old-PHP object that you need to use somewhere in your application:

検証を理解する最善の方法は、実際に検証することです。まず、アプリケーションのどこかで使用する必要のある、昔ながらの PHP オブジェクトを作成したとします。
1
2
3
4
5
6
7
 
// src/Entity/Author.php
namespace App\Entity;

class Author
{
    private $name;
}

So far, this is an ordinary class that serves some purpose inside your application. The goal of validation is to tell you if the data of an object is valid. For this to work, you'll configure a list of rules (called constraints) that the object must follow in order to be valid. These rules are usually defined using PHP code or attributes but they can also be defined as .yaml or .xml files inside the config/validator/ directory:

これまでのところ、これはアプリケーション内で何らかの目的を果たす通常のクラスです。検証の目的は、オブジェクトのデータが有効かどうかを伝えることです。これを機能させるには、オブジェクトが有効になるために従わなければならない規則 (制約と呼ばれる) のリストを構成します。これらのルールは通常、PHP コードまたは属性を使用して定義されますが、config/validator/ ディレクトリ内の .yaml または .xml ファイルとして定義することもできます。

For example, to indicate that the $name property must not be empty, add the following:

たとえば、$name プロパティが空であってはならないことを示すには、次を追加します。
  • Attributes
    属性
  • YAML
    YAML
  • XML
    XML
  • PHP
    PHP
1
2
3
4
5
6
7
8
9
10
11
 
// src/Entity/Author.php
namespace App\Entity;

// ...
use Symfony\Component\Validator\Constraints as Assert;

class Author
{
    #[Assert\NotBlank]
    private $name;
}

Adding this configuration by itself does not yet guarantee that the value will not be blank; you can still set it to a blank value if you want. To actually guarantee that the value adheres to the constraint, the object must be passed to the validator service to be checked.

この構成を追加しても、値が空白にならないという保証はまだありません。必要に応じて空白の値を設定することもできます。実際に値が制約に従っていることを保証するには、オブジェクトをバリデータ サービスに渡してチェックする必要があります。

Tip

ヒント

Symfony's validator uses PHP reflection, as well as "getter" methods, to get the value of any property, so they can be public, private or protected (see Validation).

Symfony のバリデーターは、PHP リフレクションと「getter」メソッドを使用して、任意のプロパティの値を取得するため、パブリック、プライベート、または保護することができます (検証を参照)。

Using the Validator Service

Next, to actually validate an Author object, use the validate() method on the validator service (which implements ValidatorInterface). The job of the validator is to read the constraints (i.e. rules) of a class and verify if the data on the object satisfies those constraints. If validation fails, a non-empty list of errors (ConstraintViolationList class) is returned. Take this simple example from inside a controller:

次に、Author オブジェクトを実際に検証するには、(ValidatorInterface を実装する) バリデータ サービスで validate() メソッドを使用します。それらの制約。検証が失敗した場合、エラーの空でないリスト (ConstraintViolationList クラス) が返されます。コントローラー内からこの簡単な例を取り上げます。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
// ...
use App\Entity\Author;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Validator\Validator\ValidatorInterface;

// ...
public function author(ValidatorInterface $validator)
{
    $author = new Author();

    // ... do something to the $author object

    $errors = $validator->validate($author);

    if (count($errors) > 0) {
        /*
         * Uses a __toString method on the $errors variable which is a
         * ConstraintViolationList object. This gives us a nice string
         * for debugging.
         */
        $errorsString = (string) $errors;

        return new Response($errorsString);
    }

    return new Response('The author is valid! Yes!');
}

If the $name property is empty, you will see the following error message:

$name プロパティが空の場合、次のエラー メッセージが表示されます。
1
2
 
Object(App\Entity\Author).name:
    This value should not be blank.

If you insert a value into the name property, the happy success message will appear.

name プロパティに値を挿入すると、成功のメッセージが表示されます。

Tip

ヒント

Most of the time, you won't interact directly with the validator service or need to worry about printing out the errors. Most of the time, you'll use validation indirectly when handling submitted form data. For more information, see how to validate Symfony forms.

ほとんどの場合、validator サービスと直接対話することはなく、エラーの出力について心配する必要もありません。ほとんどの場合、送信されたフォーム データを処理するときに検証を間接的に使用します。詳細については、Symfony フォームを検証する方法を参照してください。

You could also pass the collection of errors into a template:

エラーのコレクションをテンプレートに渡すこともできます。
1
2
3
4
5
 
if (count($errors) > 0) {
    return $this->render('author/validation.html.twig', [
        'errors' => $errors,
    ]);
}

Inside the template, you can output the list of errors exactly as needed:

テンプレート内で、必要に応じてエラーのリストを正確に出力できます。
1
2
3
4
5
6
7
 
{# templates/author/validation.html.twig #}
<h3>The author has the following errors</h3>
<ul>
{% for error in errors %}
    <li>{{ error.message }}</li>
{% endfor %}
</ul>

Note

ノート

Each validation error (called a "constraint violation"), is represented by a ConstraintViolation object.

各検証エラー (「制約違反」と呼ばれる) は、ConstraintViolation オブジェクトによって表されます。

Validation Callables

The Validation also allows you to create a closure to validate values against a set of constraints (useful for example when validating Console command answers or when validating OptionsResolver values):

検証では、一連の制約に対して値を検証するためのクロージャーを作成することもできます (たとえば、コンソール コマンドの応答を検証する場合や、OptionsResolver の値を検証する場合に役立ちます)。
createCallable()
This returns a closure that throws ValidationFailedException when the constraints aren't matched.
これは、制約が一致しない場合に ValidationFailedException をスローするクロージャーを返します。
createIsValidCallable()
This returns a closure that returns false when the constraints aren't matched.
これは、制約が一致しない場合に false を返すクロージャーを返します。
.. index::
single: Validation; Constraints
シングル: 検証;制約

Constraints

The validator is designed to validate objects against constraints (i.e. rules). In order to validate an object, simply map one or more constraints to its class and then pass it to the validator service.

バリデーターは、制約 (ルールなど) に対してオブジェクトを検証するように設計されています。オブジェクトを検証するには、1 つまたは複数の制約をそのクラスにマップし、それを検証サービスに渡します。

Behind the scenes, a constraint is simply a PHP object that makes an assertive statement. In real life, a constraint could be: 'The cake must not be burned'. In Symfony, constraints are similar: they are assertions that a condition is true. Given a value, a constraint will tell you if that value adheres to the rules of the constraint.

舞台裏では、制約は単に assertivestatement を作成する PHP オブジェクトです。実生活では、「ケーキを焼いてはならない」という制約が考えられます。Symfony では、制約は似ています。条件が真であるというアサーションです。値が与えられると、その値が制約のルールに準拠しているかどうかが制約によって通知されます。

Supported Constraints

Symfony packages many of the most commonly-needed constraints:

symfony は、最も一般的に必要とされる制約の多くをパッケージ化しています:

Basic Constraints

These are the basic constraints: use them to assert very basic things about the value of properties or the return value of methods on your object.

これらは基本的な制約です。これらを使用して、オブジェクトのプロパティの値またはメソッドの戻り値に関する非常に基本的なことをアサートします。

String Constraints

Comparison Constraints

Number Constraints

Date Constraints

Choice Constraints

File Constraints

Financial and other Number Constraints

Other Constraints

You can also create your own custom constraints. This topic is covered in the How to Create a Custom Validation Constraint article.

独自のカスタム制約を作成することもできます。このトピックは、カスタム検証制約の作成方法の記事で説明されています。

Constraint Configuration

Some constraints, like NotBlank, are simple whereas others, like the Choice constraint, have several configuration options available. Suppose that the Author class has another property called genre that defines the literature genre mostly associated with the author, which can be set to either "fiction" or "non-fiction":

NotBlank などのいくつかの制約は単純ですが、Choiceconstraint などの他の制約では、いくつかの構成オプションを使用できます。 Author クラスに、「フィクション」または「ノンフィクション」のいずれかに設定できる、主に著者に関連する文学ジャンルを定義する、ジャンルと呼ばれる別のプロパティがあるとします。
  • Attributes
    属性
  • YAML
    YAML
  • XML
    XML
  • PHP
    PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
// src/Entity/Author.php
namespace App\Entity;

// ...
use Symfony\Component\Validator\Constraints as Assert;

class Author
{
    #[Assert\Choice(
        choices: ['fiction', 'non-fiction'],
        message: 'Choose a valid genre.',
    )]
    private $genre;

    // ...
}

The options of a constraint can always be passed in as an array. Some constraints, however, also allow you to pass the value of one, "default", option in place of the array. In the case of the Choice constraint, the choices options can be specified in this way.

制約のオプションは、常に配列として渡すことができます。ただし、一部の制約では、配列の代わりに 1 つの「デフォルト」オプションの値を渡すこともできます。 Choice 制約の場合、choicesoptions はこの方法で指定できます。
  • Attributes
    属性
  • YAML
    YAML
  • XML
    XML
  • PHP
    PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
 
// src/Entity/Author.php
namespace App\Entity;

// ...
use Symfony\Component\Validator\Constraints as Assert;

class Author
{
    #[Assert\Choice(['fiction', 'non-fiction'])]
    private $genre;

    // ...
}

This is purely meant to make the configuration of the most common option of a constraint shorter and quicker.

これは、制約の最も一般的なオプションの構成をより短く、より速くすることを純粋に意図しています。

If you're ever unsure of how to specify an option, either check the namespace Symfony\Component\Validator\Constraints for the constraint or play it safe by always passing in an array of options (the first method shown above).

オプションの指定方法がわからない場合は、名前空間 Symfony\Component\Validator\Constraints で制約を確認するか、常にオプションの配列を渡して安全にプレイしてください (上記の最初の方法)。

Constraints in Form Classes

Constraints can be defined while building the form via the constraints option of the form fields:

制約は、フォーム フィールドの制約オプションを介してフォームを構築する際に定義できます。
1
2
3
4
5
6
7
8
9
 
public function buildForm(FormBuilderInterface $builder, array $options)
{
    $builder
        ->add('myField', TextType::class, [
            'required' => true,
            'constraints' => [new Length(['min' => 3])],
        ])
    ;
}

Constraint Targets

Constraints can be applied to a class property (e.g. name), a getter method (e.g. getFullName()) or an entire class. Property constraints are the most common and easy to use. Getter constraints allow you to specify more complex validation rules. Finally, class constraints are intended for scenarios where you want to validate a class as a whole.

制約は、クラス プロパティ (name など)、getter メソッド (getFullName() など)、またはクラス全体に適用できます。プロパティ制約は、最も一般的で使いやすいものです。 Getter 制約を使用すると、より複雑な検証規則を指定できます。最後に、クラス制約は、クラス全体を検証するシナリオを対象としています。

Properties

Validating class properties is the most basic validation technique. Symfony allows you to validate private, protected or public properties. The next listing shows you how to configure the $firstName property of an Author class to have at least 3 characters.

クラス プロパティの検証は、最も基本的な検証手法です。 symfony では、プライベート、プロテクト、またはパブリック プロパティを検証できます。次のリストは、Authorclass の $firstName プロパティを 3 文字以上に設定する方法を示しています。
  • Attributes
    属性
  • YAML
    YAML
  • XML
    XML
  • PHP
    PHP
1
2
3
4
5
6
7
8
9
10
11
 
// src/Entity/Author.php

// ...
use Symfony\Component\Validator\Constraints as Assert;

class Author
{
    #[Assert\NotBlank]
    #[Assert\Length(min: 3)]
    private $firstName;
}

Caution

注意

The validator will use a value null if a typed property is uninitialized. This can cause unexpected behavior if the property holds a value when initialized. In order to avoid this, make sure all properties are initialized before validating them.

型指定されたプロパティが初期化されていない場合、バリデータは値 null を使用します。これにより、プロパティが初期化時に値を保持している場合、予期しない動作が発生する可能性があります。これを回避するには、プロパティを検証する前にすべてのプロパティが初期化されていることを確認してください。

Getters

Constraints can also be applied to the return value of a method. Symfony allows you to add a constraint to any private, protected or public method whose name starts with "get", "is" or "has". In this guide, these types of methods are referred to as "getters".

メソッドの戻り値に制約を適用することもできます。 symfony では、名前が「get」、「is」、または「has」で始まるプライベート、プロテクト、またはパブリック メソッドに制約を追加できます。このガイドでは、これらのタイプのメソッドを「ゲッター」と呼びます。

The benefit of this technique is that it allows you to validate your object dynamically. For example, suppose you want to make sure that a password field doesn't match the first name of the user (for security reasons). You can do this by creating an isPasswordSafe() method, and then asserting that this method must return true:

この手法の利点は、オブジェクトを動的に検証できることです。たとえば、(セキュリティ上の理由から) パスワード フィールドがユーザーの名と一致しないようにしたいとします。 isPasswordSafe() メソッドを作成し、このメソッドが true を返す必要があることをアサートすることで、これを行うことができます。
  • Attributes
    属性
  • YAML
    YAML
  • XML
    XML
  • PHP
    PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
// src/Entity/Author.php
namespace App\Entity;

// ...
use Symfony\Component\Validator\Constraints as Assert;

class Author
{
    #[Assert\IsTrue(message: 'The password cannot match your first name')]
    public function isPasswordSafe()
    {
        // ... return true or false
    }
}

Now, create the isPasswordSafe() method and include the logic you need:

次に、 isPasswordSafe() メソッドを作成し、必要なロジックを含めます。
1
2
3
4
 
public function isPasswordSafe()
{
    return $this->firstName !== $this->password;
}

Note

ノート

The keen-eyed among you will have noticed that the prefix of the getter ("get", "is" or "has") is omitted in the mappings for the YAML, XML and PHP formats. This allows you to move the constraint to a property with the same name later (or vice versa) without changing your validation logic.

YAML、XML、および PHP 形式のマッピングでは、getter の接頭辞 ("get"、"is"、または "has") が省略されていることに注意が必要です。これにより、検証ロジックを変更せずに、後で制約を同じ名前のプロパティに移動できます (またはその逆)。

Classes

Some constraints apply to the entire class being validated. For example, the Callback constraint is a generic constraint that's applied to the class itself. When that class is validated, methods specified by that constraint are simply executed so that each can provide more custom validation.

いくつかの制約は、検証されるクラス全体に適用されます。たとえば、Callback 制約は、クラス自体に適用される汎用制約です。そのクラスが検証されると、その制約によって指定されたメソッドが単純に実行されるため、それぞれがより多くのカスタム検証を提供できます。

Debugging the Constraints

Use the debug:validator command to list the validation constraints of a given class:

指定されたクラスの検証制約を一覧表示するには、debug:validator コマンドを使用します。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
$ php bin/console debug:validator 'App\Entity\SomeClass'

    App\Entity\SomeClass
    -----------------------------------------------------

    +---------------+--------------------------------------------------+---------+------------------------------------------------------------+
    | Property      | Name                                             | Groups  | Options                                                    |
    +---------------+--------------------------------------------------+---------+------------------------------------------------------------+
    | firstArgument | Symfony\Component\Validator\Constraints\NotBlank | Default | [                                                          |
    |               |                                                  |         |   "message" => "This value should not be blank.",          |
    |               |                                                  |         |   "allowNull" => false,                                    |
    |               |                                                  |         |   "normalizer" => null,                                    |
    |               |                                                  |         |   "payload" => null                                        |
    |               |                                                  |         | ]                                                          |
    | firstArgument | Symfony\Component\Validator\Constraints\Email    | Default | [                                                          |
    |               |                                                  |         |   "message" => "This value is not a valid email address.", |
    |               |                                                  |         |   "mode" => null,                                          |
    |               |                                                  |         |   "normalizer" => null,                                    |
    |               |                                                  |         |   "payload" => null                                        |
    |               |                                                  |         | ]                                                          |
    +---------------+--------------------------------------------------+---------+------------------------------------------------------------+

You can also validate all the classes stored in a given directory:

特定のディレクトリに保存されているすべてのクラスを検証することもできます。
1
 
$ php bin/console debug:validator src/Entity

Final Thoughts

The Symfony validator is a powerful tool that can be leveraged to guarantee that the data of any object is "valid". The power behind validation lies in "constraints", which are rules that you can apply to properties or getter methods of your object. And while you'll most commonly use the validation framework indirectly when using forms, remember that it can be used anywhere to validate any object.

Symfony バリデーターは、あらゆるオブジェクトのデータが「有効」であることを保証するために活用できる強力なツールです。検証の背後にある力は、オブジェクトのプロパティやメソッドに適用できるルールである「制約」にあります。また、フォームを使用するときに検証フレームワークを間接的に使用するのが最も一般的ですが、任意のオブジェクトを検証するためにどこでも使用できることを覚えておいてください。

Learn more