When ¶

expression ¶

type: string

The condition written with the expression language syntax that will be evaluated. If the expression evaluates to a falsey value (i.e. using ==, not ===), validation of constraints won't be triggered.

To learn more about the expression language syntax, see The Expression Syntax.

Depending on how you use the constraint, you have access to 1 or 2 variables in your expression:

this

The object being validated (e.g. an instance of Discount).

検証されるオブジェクト (たとえば、Discount のインスタンス)。

value

The value of the property being validated (only available when the constraint is applied to a property).

検証中のプロパティの値 (制約がプロパティに適用されている場合にのみ使用可能)。

The value variable can be used when you want to execute more complex validation based on its value:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// src/Model/Discount.php
namespace App\Model;

use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Validator\Context\ExecutionContextInterface;

class Discount
{
    #[Assert\When(
        expression: 'value == "percent"',
        constraints: [new Assert\Callback('doComplexValidation')],
    )]
    private ?string $type;
    // ...

    public function doComplexValidation(ExecutionContextInterface $context, $payload)
    {
        // ...
    }
}

1
2
3
4
5
6
7
8

# config/validator/validation.yaml
App\Model\Discount:
    properties:
        type:
            - When:
                expression: "value == 'percent'"
                constraints:
                    - Callback: doComplexValidation

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

<!-- 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\Model\Discount">
        <property name="type">
            <constraint name="When">
                <option name="expression">
                    value == 'percent'
                </option>
                <option name="constraints">
                    <constraint name="Callback">
                        <option name="callback">doComplexValidation</option>
                    </constraint>
                </option>
            </constraint>
        </property>
    </class>
</constraint-mapping>

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

// src/Model/Discount.php
namespace App\Model;

use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Validator\Mapping\ClassMetadata;

class Discount
{
    // ...

    public static function loadValidatorMetadata(ClassMetadata $metadata)
    {
        $metadata->addPropertyConstraint('type', new Assert\When([
            'expression' => 'value == "percent"',
            'constraints' => [
                new Assert\Callback('doComplexValidation'),
            ],
        ]));
    }

    public function doComplexValidation(ExecutionContextInterface $context, $payload)
    {
        // ...
    }
}

You can also pass custom variables using the values option.

constraints ¶

type: array

The constraints that are applied if the expression returns true.

groups ¶

type: array | string

It defines the validation group or groups of this constraint. Read more about validation groups.

payload ¶

type: mixed default: null

This option can be used to attach arbitrary domain-specific data to a constraint. The configured payload is not used by the Validator component, but its processing is completely up to you.

For example, you may want to use several error levels to present failed constraints differently in the front-end depending on the severity of the error.

values ¶

type: array default: []

The values of the custom variables used in the expression. Values can be of any type (numeric, boolean, strings, null, etc.)