The Expression Syntax

Accessing Public Properties

Public properties on objects can be accessed by using the . syntax, similar to JavaScript:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class Apple
{
    public string $variety;
}

$apple = new Apple();
$apple->variety = 'Honeycrisp';

var_dump($expressionLanguage->evaluate(
    'fruit.variety',
    [
        'fruit' => $apple,
    ]
));

This will print out Honeycrisp.

Calling Methods

The . syntax can also be used to call methods on an object, similar to JavaScript:

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

class Robot
{
    public function sayHi(int $times): string
    {
        $greetings = [];
        for ($i = 0; $i < $times; $i++) {
            $greetings[] = 'Hi';
        }

        return implode(' ', $greetings).'!';
    }
}

$robot = new Robot();

var_dump($expressionLanguage->evaluate(
    'robot.sayHi(3)',
    [
        'robot' => $robot,
    ]
));

This will print out Hi Hi Hi!.

1
2
3
4
5
6
7

// these will throw an exception when `fruit` is `null`
$expressionLanguage->evaluate('fruit.color', ['fruit' => '...'])
$expressionLanguage->evaluate('fruit.getStock()', ['fruit' => '...'])

// these will return `null` if `fruit` is `null`
$expressionLanguage->evaluate('fruit?.color', ['fruit' => '...'])
$expressionLanguage->evaluate('fruit?.getStock()', ['fruit' => '...'])

constant() function

This function will return the value of a PHP constant:

1
2
3
4
5

define('DB_USER', 'root');

var_dump($expressionLanguage->evaluate(
    'constant("DB_USER")'
));

This will print out root.

This also works with class constants:

1
2
3
4
5
6
7
8
9
10

namespace App\SomeNamespace;

class Foo
{
    public const API_ENDPOINT = '/api';
}

var_dump($expressionLanguage->evaluate(
    'constant("App\\\SomeNamespace\\\Foo::API_ENDPOINT")'
));

This will print out /api.

enum() function

This function will return the case of an enumeration:

1
2
3
4
5
6
7
8
9
10

namespace App\SomeNamespace;

enum Foo
{
    case Bar;
}

var_dump(App\Enum\Foo::Bar === $expressionLanguage->evaluate(
    'enum("App\\\SomeNamespace\\\Foo::Bar")'
));

This will print out true.

min() function

This function will return the lowest value of the given parameters. You can pass different types of parameters (e.g. dates, strings, numeric values) and even mix them (e.g. pass numeric values and strings). Internally it uses the min PHP function to find the lowest value:

1
2
3

var_dump($expressionLanguage->evaluate(
    'min(1, 2, 3)'
));

This will print out 1.

max() function

This function will return the highest value of the given parameters. You can pass different types of parameters (e.g. dates, strings, numeric values) and even mix them (e.g. pass numeric values and strings). Internally it uses the max PHP function to find the highest value:

1
2
3

var_dump($expressionLanguage->evaluate(
    'max(1, 2, 3)'
));

This will print out 3.

Arithmetic Operators

• + (addition)
• - (subtraction)
• * (multiplication)
• / (division)
• % (modulus)
• ** (pow)

For example:

1
2
3
4
5
6
7
8

var_dump($expressionLanguage->evaluate(
    'life + universe + everything',
    [
        'life' => 10,
        'universe' => 10,
        'everything' => 22,
    ]
));

This will print out 42.

Bitwise Operators

• & (and)
• | (or)
• ^ (xor)

Comparison Operators

• == (equal)
• === (identical)
• != (not equal)
• !== (not identical)
• < (less than)
• > (greater than)
• <= (less than or equal to)
• >= (greater than or equal to)
• matches (regex match)
• contains
• starts with
• ends with

1

$expressionLanguage->evaluate('not ("foo" matches "/bar/")'); // returns true

Examples:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

$ret1 = $expressionLanguage->evaluate(
    'life == everything',
    [
        'life' => 10,
        'everything' => 22,
    ]
);

$ret2 = $expressionLanguage->evaluate(
    'life > everything',
    [
        'life' => 10,
        'everything' => 22,
    ]
);

Both variables would be set to false.

Logical Operators

• not or !
• and or &&
• or or ||

For example:

1
2
3
4
5
6
7
8

$ret = $expressionLanguage->evaluate(
    'life < universe or life < everything',
    [
        'life' => 10,
        'universe' => 10,
        'everything' => 22,
    ]
);

This $ret variable will be set to true.

String Operators

• ~ (concatenation)

For example:

1
2
3
4
5
6
7

var_dump($expressionLanguage->evaluate(
    'firstName~" "~lastName',
    [
        'firstName' => 'Arthur',
        'lastName' => 'Dent',
    ]
));

This would print out Arthur Dent.

Array Operators

• in (contain)
• not in (does not contain)

These operators are using strict comparison. For example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class User
{
    public string $group;
}

$user = new User();
$user->group = 'human_resources';

$inGroup = $expressionLanguage->evaluate(
    'user.group in ["human_resources", "marketing"]',
    [
        'user' => $user,
    ]
);

The $inGroup would evaluate to true.

Numeric Operators

• .. (range)

For example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class User
{
    public int $age;
}

$user = new User();
$user->age = 34;

$expressionLanguage->evaluate(
    'user.age in 18..45',
    [
        'user' => $user,
    ]
);

This will evaluate to true, because user.age is in the range from 18 to 45.

Ternary Operators

• foo ? 'yes' : 'no'
• foo ?: 'no' (equal to foo ? foo : 'no')
• foo ? 'yes' (equal to foo ? 'yes' : '')

Other Operators

• ?. (null-safe operator)
• ?? (null-coalescing operator)

Operators Precedence

Operator precedence determines the order in which operations are processed in an expression. For example, the result of the expression 1 + 2 * 4 is 9 and not 12 because the multiplication operator (*) takes precedence over the addition operator (+).

To avoid ambiguities (or to alter the default order of operations) add parentheses in your expressions (e.g. (1 + 2) * 4 or 1 + (2 * 4).

The following table summarizes the operators and their associativity from the highest to the lowest precedence: