Дата обновления перевода 2021-06-12

Валидация

Валидация - это очень распространенная задача для web-приложения. Данные, вводимые в формы, должны быть валидированы (проверены). В то же время, данные должны быть валидированы до того, как они будут записаны в базу данных или же будут переданы веб-сервису.

Symfony содержит компонент Validator, который упрощает эту задачу. Этот компонент основан на документе `спецификация валидации JSR303 Bean`_.

Установка

В приложениях, использующих Symfony Flex, выполните эту команду, чтобы установить валидатор перед его использованием:

1
$ composer require symfony/validator doctrine/annotations

Основы валидации

Самый лучший способ понять валидацию - это увидеть её в действии. Для начала, предположим, что вы создали обычный PHP-объект, который вам нужно использовать в вашем приложении:

// src/Entity/Author.php
namespace App\Entity;

class Author
{
    private $name;
}

Пока это обычный класс, который служит какой-то цели внутри вашего приложения. Задача валидации заключается в том, чтобы сообщить вам - являются ли данные объекта корректными (валидными). Для этого, вам нужно настроить перечень правил (называемых ограничениями (constraints)), которым объект должен соответствовать, чтобы быть валидным. Эти правила обычно определяются с использованием PHP-кода, но также могут быть определены, как файлы .yaml или .xml внутри каталога config/validator/:

Например, для того, чтобы гарантировать, что свойство $name не пустое, добавьте следующий код:

  • Annotations
     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\NotBlank
         */
        private $name;
    }
    
  • Attributes
     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;
    }
    
  • YAML
    1
    2
    3
    4
    5
    # config/validator/validation.yaml
    App\Entity\Author:
        properties:
            name:
                - NotBlank: ~
    
  • XML
     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    <!-- config/validator/validation.xml -->
    <?xml version="1.0" encoding="UTF-8" ?>
    <constraint-mapping xmlns="http://symfony.com/schema/dic/constraint-mapping"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping
            https://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">
    
        <class name="App\Entity\Author">
            <property name="name">
                <constraint name="NotBlank"/>
            </property>
        </class>
    </constraint-mapping>
    
  • PHP
     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    // src/Entity/Author.php
    namespace App\Entity;
    // ...
    use Symfony\Component\Validator\Constraints\NotBlank;
    use Symfony\Component\Validator\Mapping\ClassMetadata;
    
    class Author
    {
        private $name;
    
        public static function loadValidatorMetadata(ClassMetadata $metadata)
        {
            $metadata->addPropertyConstraint('name', new NotBlank());
        }
    }
    

Добавление этой конфигурации самой по себе еще не гарантирует, что значение не будет пустым; вы все еще можете установить его как пустое значение, если вы этого хотите. Чтобы действительно гарантировать, что значение примкнет к ограничнению, объект должен быть переда сервису влаидатора на проверку.

Tip

Валидатор Symfony использует рефлексию PHP, а также методы “геттера”, чтобы получить значение любого свойства; они могут быть публичными, частными или защищенными (см. Constraint Targets).

Использование сервиса валидатор

Далее, чтобы проверить объект Author, используйте метод validate() сервиса validator (который реализует ValidatorInterface). Обязанности у validator простые: прочитать ограничения (т.е. правила) для класса, и определить, соответствуют ли данные из объекта этим ограничениям. Если валидация проходит с ошибкой, возвращается список ошибок (класс ConstraintViolationList). Давайте рассмотрим этот простой пример изнутри контроллера:

// ...
use App\Entity\Author;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Validator\Validator\ValidatorInterface;

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

    // ... сделать что-то с объектом $author

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

    if (count($errors) > 0) {
        /*
         * Использует метод __toString в переменной $errors, которая является объектом
         * ConstraintViolationList. Это дает хорошую строку для отладки.
         */
        $errorsString = (string) $errors;

        return new Response($errorsString);
    }

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

Если свойство $name пустое, вы увидите следующее сообщение об ошибке:

1
2
Object(App\Entity\Author).name:
    Это значение не должно быть пустым

Если же вы укажете значение для свойства name, появится сообщение об успешной валидации.

Tip

В большинстве случаев, вы не будете напрямую взаимодействовать с сервисом validator и вам не нужно будет беспокоиться об отображении ошибок. Зачастую вы будете использовать валидацию косвенно при обработке данных из отправленных приложению форм. Подробнее об этом смотрите тут: как валидировать формы Symfony.

Вы также можете передать коллекцию ошибок в шаблон:

if (count($errors) > 0) {
    return $this->render('author/validation.html.twig', [
        'errors' => $errors,
    ]);
}

Внутри шаблона вы можете вывести список ошибок так, как вам нужно:

1
2
3
4
5
6
7
{# templates/author/validation.html.twig #}
<h3>Автор имеет следующие ошибки</h3>
<ul>
{% for error in errors %}
    <li>{{ error.message }}</li>
{% endfor %}
</ul>

Note

Каждая ошибка валидации (называемая «нарушение ограничения» “constraint violation”), представлена объектом ConstraintViolation.

Конфигурация

Перед тем, как использовать валидатор Symfony, убедитесь в том, что он активирован в глафном файле конфигурации:

  • YAML
    1
    2
    3
    # config/packages/framework.yaml
    framework:
        validation: { enabled: true }
    
  • XML
     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    <!-- config/packages/framework.xml -->
    <?xml version="1.0" encoding="UTF-8" ?>
    <container xmlns="http://symfony.com/schema/dic/services"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:framework="http://symfony.com/schema/dic/symfony"
        xsi:schemaLocation="http://symfony.com/schema/dic/services
            https://symfony.com/schema/dic/services/services-1.0.xsd
            http://symfony.com/schema/dic/symfony https://symfony.com/schema/dic/symfony/symfony-1.0.xsd">
    
        <framework:config>
            <framework:validation enabled="true"/>
        </framework:config>
    </container>
    
  • PHP
    1
    2
    3
    4
    5
    6
    7
    8
    // config/packages/framework.php
    use Symfony\Config\FrameworkConfig;
    
    return static function (FrameworkConfig $framework) {
        $framework->validation()
            ->enabled(true)
        ;
    };
    

Кроме того, если вы планируете использовать аннотации для конфигруации валидации, замените предыдущую конфигурацию следующим:

  • YAML
    1
    2
    3
    # config/packages/framework.yaml
    framework:
        validation: { enable_annotations: true }
    
  • XML
     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    <!-- config/packages/framework.xml -->
    <?xml version="1.0" encoding="UTF-8" ?>
    <container xmlns="http://symfony.com/schema/dic/services"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:framework="http://symfony.com/schema/dic/symfony"
        xsi:schemaLocation="http://symfony.com/schema/dic/services
            https://symfony.com/schema/dic/services/services-1.0.xsd
            http://symfony.com/schema/dic/symfony https://symfony.com/schema/dic/symfony/symfony-1.0.xsd">
    
        <framework:config>
            <framework:validation enable-annotations="true"/>
        </framework:config>
    </container>
    
  • PHP
    1
    2
    3
    4
    5
    6
    7
    8
    // config/packages/framework.php
    use Symfony\Config\FrameworkConfig;
    
    return static function (FrameworkConfig $framework) {
        $framework->validation()
            ->enableAnnotations(true)
        ;
    };
    

Tip

При использовании файлов PHP, YAML, и XML вместо аннотаций, Symfony по умолчанию ищет в каталоге config/validator/, но вы можете сконфигурировать другие каталоги с помощью опции validation.mapping.paths.

Ограничения

Validator создан для того, чтобы проверять объекты на соответствие ограничениям (т.е. правилам). Для того чтобы валидировать объект, просто укажите для его класса одно или несколько ограничений, и передайте его сервису валидации (validator).

За кулисами, ограничение - это просто PHP-объект, который выполняет утвердительное выражение. В настоящей жизни, ограничение может выглядеть так: "пирог не должен подгореть". В Symfony ограничения выглядят похожим образом: это утверждения, что некоторое условие истинно. Учитывая значение, ограничение скажет вам, соответствует ли это значение правилам ограничения.

Поддерживаемые ограничения

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.

Date Constraints

Choice Constraints

File Constraints

Financial and other Number Constraints

Other Constraints

Вы также можете создавать свои собственные ограничения. Эта тема раскрыта в статье How to Create a Custom Validation Constraint.

Конфигурация ограничений

Некоторые ограничения, как например NotBlank просты, в то время как другие, например Choice - имеют несколько опций конфигурации. Предположим, что класс Author имеет свойство genre (жанр), которое определяет жанр литературы, который в основном ассоциируется с автором, и которое можно установить в значение “беллетристика” или “не беллетристика” (“fiction” или “non-fiction”):

  • Annotations
     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    // 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;
    
        // ...
    }
    
  • Attributes
     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;
    
        // ...
    }
    
  • YAML
    1
    2
    3
    4
    5
    6
    # config/validator/validation.yaml
    App\Entity\Author:
        properties:
            genre:
                - Choice: { choices: [fiction, non-fiction], message: Choose a valid genre. }
            # ...
    
  • XML
     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    <!-- config/validator/validation.xml -->
    <?xml version="1.0" encoding="UTF-8" ?>
    <constraint-mapping xmlns="http://symfony.com/schema/dic/constraint-mapping"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping
            https://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">
    
        <class name="App\Entity\Author">
            <property name="genre">
                <constraint name="Choice">
                    <option name="choices">
                        <value>fiction</value>
                        <value>non-fiction</value>
                    </option>
                    <option name="message">Choose a valid genre.</option>
                </constraint>
            </property>
    
            <!-- ... -->
        </class>
    </constraint-mapping>
    
  • PHP
     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    // src/Entity/Author.php
    namespace App\Entity;
    
    // ...
    use Symfony\Component\Validator\Constraints as Assert;
    use Symfony\Component\Validator\Mapping\ClassMetadata;
    
    class Author
    {
        private $genre;
    
        // ...
    
        public static function loadValidatorMetadata(ClassMetadata $metadata)
        {
            // ...
    
            $metadata->addPropertyConstraint('genre', new Assert\Choice([
                'choices' => ['fiction', 'non-fiction'],
                'message' => 'Choose a valid genre.',
            ]));
        }
    }
    

Опции ограничения всегда могут быть переданы в виде массива. Однако, некоторые ограничения также позволяют вам передать значение одной опции «по умолчанию» вместо массива. В случае с ограничением Choice, опции choices можно указать таким образом.

  • Annotations
     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    // src/Entity/Author.php
    namespace App\Entity;
    
    // ...
    use Symfony\Component\Validator\Constraints as Assert;
    
    class Author
    {
        /**
         * @Assert\Choice({"fiction", "non-fiction"})
         */
        private $genre;
    
        // ...
    }
    
  • Attributes
     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;
    
        // ...
    }
    
  • YAML
    1
    2
    3
    4
    5
    6
    # config/validator/validation.yaml
    App\Entity\Author:
        properties:
            genre:
                - Choice: [fiction, non-fiction]
            # ...
    
  • XML
     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    <!-- config/validator/validation.xml -->
    <?xml version="1.0" encoding="UTF-8" ?>
    <constraint-mapping xmlns="http://symfony.com/schema/dic/constraint-mapping"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping
            https://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">
    
        <class name="App\Entity\Author">
            <property name="genre">
                <constraint name="Choice">
                    <value>fiction</value>
                    <value>non-fiction</value>
                </constraint>
            </property>
    
            <!-- ... -->
        </class>
    </constraint-mapping>
    
  • PHP
     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    // src/Entity/Author.php
    namespace App\Entity;
    
    // ...
    use Symfony\Component\Validator\Constraints as Assert;
    use Symfony\Component\Validator\Mapping\ClassMetadata;
    
    class Author
    {
        private $genre;
    
        public static function loadValidatorMetadata(ClassMetadata $metadata)
        {
            // ...
    
            $metadata->addPropertyConstraint(
                'genre',
                new Assert\Choice(['fiction', 'non-fiction'])
            );
        }
    }
    

Такая возможность позволяет сделать настройку самых распространенных опций ограничения короче и быстрее.

Если вы не уверены, как нужно указывать опцию, сверьтесь с пространством имен Symfony\Component\Validator\Constraints касательно ограничения или же поступайте безопасно - всегда передавая массив опций (как показано в первом методе выше).

Ограничения в классах формы

Ограничения могут быть обозначены во время построения форм с помощью опции constraints полей формы:

public function buildForm(FormBuilderInterface $builder, array $options)
{
    $builder
        ->add('myField', TextType::class, [
            'required' => true,
            'constraints' => [new Length(['min' => 3])],
        ])
    ;
}

Цели ограничения

Ограничения могут быть применены к свойству класса (например, name), публичному геттер-методу (например, getFullName()) или целому классу. Первый вариант наиболее распространенный и легкий. Однако ограничения геттера позволяют вам указывать более сложные правила валидации. И, наконец, ограничения класса предназначены для случаев, когда вы хотите валидировать класс в качестве единого целого.

Свойства

Валидация свойств класса - самая простая техника валидации. Symfony позволяет вам проверять приватные, защищенные или публичные свойства. Ниже вы увидите, как сделать так, чтобы свойство $firstName класса Author имело как минимум 3 символа.

  • Annotations
     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    // src/Entity/Author.php
    
    // ...
    use Symfony\Component\Validator\Constraints as Assert;
    
    class Author
    {
        /**
         * @Assert\NotBlank
         * @Assert\Length(min=3)
         */
        private $firstName;
    }
    
  • Attributes
     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;
    }
    
  • YAML
    1
    2
    3
    4
    5
    6
    7
    # config/validator/validation.yaml
    App\Entity\Author:
        properties:
            firstName:
                - NotBlank: ~
                - Length:
                    min: 3
    
  • XML
     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    <!-- config/validator/validation.xml -->
    <?xml version="1.0" encoding="UTF-8" ?>
    <constraint-mapping xmlns="http://symfony.com/schema/dic/constraint-mapping"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping
            https://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">
    
        <class name="App\Entity\Author">
            <property name="firstName">
                <constraint name="NotBlank"/>
                <constraint name="Length">
                    <option name="min">3</option>
                </constraint>
            </property>
        </class>
    </constraint-mapping>
    
  • PHP
     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    // src/Entity/Author.php
    namespace App\Entity;
    
    // ...
    use Symfony\Component\Validator\Constraints as Assert;
    use Symfony\Component\Validator\Mapping\ClassMetadata;
    
    class Author
    {
        private $firstName;
    
        public static function loadValidatorMetadata(ClassMetadata $metadata)
        {
            $metadata->addPropertyConstraint('firstName', new Assert\NotBlank());
            $metadata->addPropertyConstraint(
                'firstName',
                new Assert\Length(['min' => 3])
            );
        }
    }
    

Caution

Валидатор будет использовать значение null если инициализация типизированного свойства была отменена. Это может вызвать неожиданое поведение, если свойство содержит значение при инициализации. Чтобы избежать этого, убедитесь, что все свойства инициалищированы до их валидации.

Геттеры

Ограничения также могут применяться для того, чтобы вернуть значение метода. Symfony позволяет вам добавлять ограничение к любому публичному методу, имя которого начинается с «get», «is» или «has». В этой книге, подобные методы называются общим словом «геттеры».

Преимуществом этой техники является то, что она позволяет вам валидировать ваш объект динамично. Например, представьте, что вам нужно убедиться, что поле пароля не совпадает с именем пользователя (из соображений безопасности). Вы можете сделать это создав метод isPasswordLegal() и указав, что этот метод должен вернуться как true:

  • Annotations
     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\IsTrue(message="The password cannot match your first name")
         */
        public function isPasswordSafe()
        {
            // ... вернуть true или false
        }
    }
    
  • Attributes
     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()
        {
            // ... ернуть true или false
        }
    }
    
  • YAML
    1
    2
    3
    4
    5
    # config/validator/validation.yaml
    App\Entity\Author:
        getters:
            passwordSafe:
                - 'IsTrue': { message: 'The password cannot match your first name' }
    
  • XML
     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    <!-- config/validator/validation.xml -->
    <?xml version="1.0" encoding="UTF-8" ?>
    <constraint-mapping xmlns="http://symfony.com/schema/dic/constraint-mapping"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping
            https://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">
    
        <class name="App\Entity\Author">
            <getter property="passwordSafe">
                <constraint name="IsTrue">
                    <option name="message">The password cannot match your first name</option>
                </constraint>
            </getter>
        </class>
    </constraint-mapping>
    
  • 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;
    use Symfony\Component\Validator\Mapping\ClassMetadata;
    
    class Author
    {
        public static function loadValidatorMetadata(ClassMetadata $metadata)
        {
            $metadata->addGetterConstraint('passwordSafe', new Assert\IsTrue([
                'message' => 'The password cannot match your first name',
            ]));
        }
    }
    

Теперь создайте метод isPasswordLegal() и добавьте его в нужную вам логику:

public function isPasswordLegal()
{
    return $this->firstName !== $this->password;
}

Note

Самые внимательные из вас заметили, что префикс геттера («get», «is» или «has») опущен при отображении. Это позволит вам применить ограничение к свойству с таким же именем позже ( или наоборот), не изменяя логики валидации.

Классы

Некоторые ограничения применяются к целому валидируемому классу. Например ограничение Callback (обратный вызов) - это универсальное ограничение, которое применяется к самому классу. Когда этот класс валидируется, методы, указанные ограничением, просто выполняются, что позволяет проводить более избирательную валидацию.

Отладка ограничений

New in version 5.2: Команда debug:validator была представлена в Symfony 5.2.

Используйте команду 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
    -----------------------------------------------------

    +---------------+--------------------------------------------------+-----------+------------------------------------------------------------+
    | Свойство      | Имя                                              | Группы    | Опции                                                      |
    +---------------+--------------------------------------------------+-----------+------------------------------------------------------------+
    | firstArgument | Symfony\Component\Validator\Constraints\NotBlank | по        | [                                                          |
    |               |                                                  | умолчанию |   "message" => "This value should not be blank.",          |
    |               |                                                  |           |   "allowNull" => false,                                    |
    |               |                                                  |           |   "normalizer" => null,                                    |
    |               |                                                  |           |   "payload" => null                                        |
    |               |                                                  |           | ]                                                          |
    | firstArgument | Symfony\Component\Validator\Constraints\Email    | по        | [                                                          |
    |               |                                                  | умолчанию |   "message" => "This value is not a valid email address.", |
    |               |                                                  |           |   "mode" => null,                                          |
    |               |                                                  |           |   "normalizer" => null,                                    |
    |               |                                                  |           |   "payload" => null                                        |
    |               |                                                  |           | ]                                                          |
    +---------------+--------------------------------------------------+---------+------------------------------------------------------------+

Вы также можете валидировать все классы, хранящиеся в данном каталоге:

1
$ php bin/console debug:validator src/Entity

Заключение

Валидатор Symfony - это мощный инструмент, который используется для получения гарантий, что данные некоторого объекта “валидные”. Сила валидации - в ограничениях, которые являются правилами, которые вы можете применить к свойствам или геттер-методам вашего объекта. И несмотря на то, что вы большей частью будете использовать фреймворк валидации косвенно при использовании форм, помните, что он может быть использован где угодно для валидации любого объекта.

Эта документация является переводом официальной документации Symfony и предоставляется по свободной лицензии CC BY-SA 3.0.