Вы вроде бы пишете код на чистом PHP, но почему-то каждый день используете маленькие языки: DQL в Doctrine («u.age > 18»), Twig-выражения («user|length > 0»), Symfony ExpressionLanguage («user.is_active and order.total > 100`). Никогда не возникало мысли о том, что хорошо бы избавиться от всех этих дополнений и использовать язык собственной разработки для решения нужных задач? В этой статье мы рассмотрим DSL — язык, заточенный под узкую задачу.
Конвейер: Как работает любой язык
Для начала давайте разберемся с тем, как работают языки программирования. Любой язык (PHP, JavaScript или ваш DSL) проходит ровно 4 этапа:
Исходный текст → Токены → AST → Результат.
Например:
"2 + 3 * 4" → [T_NUM, T_PLUS, ...] → Plus(2, Mul(3,4)) → 14
Сначала лексер режет строку на осмысленные куски (токены): числа, операторы, скобки. Затем, парсер — строит дерево (AST). При этом, он учитывает приоритеты: * выше, чем +. Далее, интерпретатор (Evaluator) — обходит дерево и вычисляет результат.
Так вот, PHP внутри работает точно так же: ваш index.php → токены → Opcodes → выполнение.
Давайте повторим этот путь, но напишем только то, что нужно для бизнес-правил.
Проектируем наш язык правил
Теперь мы приступим к проектированию своего языка. Наш язык будет называться MyRuleLang и его целью будет проверять, выполнено ли бизнес-условие.
Давайте определимся с тем, что должен поддерживать наш язык:
Числа, строки в двойных кавычках.
Переменные вида user.age, order.status.
Операторы: ==, !=, >, <, >=, <=, and, or, not.
Скобки для группировки.
Например, мы должны иметь возможность обрабатывать конструкции следующего вида:
user.age >= 18 and (user.has_vip or user.orders_count > 5)
Этап 1: Лексер (токенизатор) на регулярках
Итак, сначала лексер должен нарезать строку на отдельные токены. Каждый токен — это тип + значение + позиция в строке.
Вот пример кода:
namespace MyRuleLang;
class Token
{
public const T_NUMBER = 'NUMBER';
public const T_STRING = 'STRING';
public const T_IDENTIFIER = 'IDENTIFIER';
public const T_OPERATOR = 'OPERATOR';
public const T_KEYWORD = 'KEYWORD';
public const T_LPAREN = 'LPAREN';
public const T_RPAREN = 'RPAREN';
public const T_EOF = 'EOF';
public function __construct(
public readonly string $type,
public readonly mixed $value,
public readonly int $position
) {}
}Лексер проходит по строке и выкусывает токены с помощью preg_match.
class Lexer
{
private string $input;
private int $position = 0;
private int $length;
// Определяем, как выглядит каждый токен
private const SPEC = [
Token::T_NUMBER => '/\d+(?:\.\d+)?/A', // A — привязка к позиции
Token::T_STRING => '/"([^"]*)"/A',
Token::T_IDENTIFIER => '/[a-zA-Z_][a-zA-Z0-9_\.]*/A',
Token::T_OPERATOR => '/(?:==|!=|>=|<=|>|<)/A',
Token::T_KEYWORD => '/(?:and|or|not)/A',
Token::T_LPAREN => '/\(/A',
Token::T_RPAREN => '/\)/A',
];
public function __construct(string $input)
{
$this->input = $input;
$this->length = strlen($input);
}
public function getTokens(): array
{
$tokens = [];
while ($this->position < $this->length) {
// Пропускаем пробелы
if ($this->input[$this->position] === ' ') {
$this->position++;
continue;
}
$match = null;
foreach (self::SPEC as $type => $pattern) {
if (preg_match($pattern, $this->input, $match, 0, $this->position)) {
$value = $match[1] ?? $match[0];
// Преобразуем типы
if ($type === Token::T_NUMBER) {
$value = (float) $value;
} elseif ($type === Token::T_STRING) {
$value = $value; // уже без кавычек
} elseif ($type === Token::T_KEYWORD) {
$type = Token::T_KEYWORD; // оставляем как есть
}
$tokens[] = new Token($type, $value, $this->position);
$this->position += strlen($match[0]);
continue 2;
}
}
throw new \Exception("Unexpected char at {$this->position}: {$this->input[$this->position]}");
}
$tokens[] = new Token(Token::T_EOF, null, $this->position);
return $tokens;
}
}
Проверим работу нашего лексера с помощью небольшой тестовой строки:
$lexer = new Lexer('user.age >= 18 and name == "John"');
$tokens = $lexer->getTokens();
foreach ($tokens as $t) {
echo $t->type . ': ' . json_encode($t->value) . PHP_EOL;
}Вывод:
IDENTIFIER: "user.age"
OPERATOR: ">="
NUMBER: 18
KEYWORD: "and"
IDENTIFIER: "name"
OPERATOR: "=="
STRING: "John"
EOF: nullКак видно, лексер готов к использованию.
Этап 2: Рекурсивный парсер → AST
Абстрактное синтаксическое дерево (AST) — это структура данных, которая представляет исходный код программы в виде дерева. Оно отражает логическую и синтаксическую структуру кода, а не его конкретный текст. То есть, по сути AST это дерево объектов, соответственно узлы это операции, а листья — значения.
Теперь давайте определим несколько классов узлов:
// Базовый класс
abstract class Node {}
class NumberNode extends Node {
public function __construct(public readonly float $value) {}
}
class StringNode extends Node {
public function __construct(public readonly string $value) {}
}
class VariableNode extends Node {
public function __construct(public readonly string $name) {}
}
// Бинарная операция: a + b, a > b и т.д.
class BinaryOpNode extends Node {
public function __construct(
public readonly string $operator,
public readonly Node $left,
public readonly Node $right
) {}
}
// Унарная операция: not x
class UnaryOpNode extends Node {
public function __construct(
public readonly string $operator,
public readonly Node $expr
) {}
}Парсер получает поток токенов и строит абстрактное синтаксическое дерево. Далее, для обработки этого дерева мы используем рекурсивный спуск — один метод на каждое правило грамматики.
class Parser
{
private array $tokens;
private int $pos = 0;
public function __construct(array $tokens)
{
$this->tokens = $tokens;
}
private function current(): Token
{
return $this->tokens[$this->pos];
}
private function consume(string $type): Token
{
if ($this->current()->type !== $type) {
throw new \Exception("Expected {$type}, got {$this->current()->type}");
}
return $this->tokens[$this->pos++];
}
// Главный вход: expression
public function parse(): Node
{
return $this->parseLogical();
}
// lowest priority: and / or
private function parseLogical(): Node
{
$node = $this->parseComparison();
while (in_array($this->current()->type, [Token::T_KEYWORD])) {
$op = $this->current()->value;
if (!in_array($op, ['and', 'or'])) break;
$this->consume(Token::T_KEYWORD);
$right = $this->parseComparison();
$node = new BinaryOpNode($op, $node, $right);
}
return $node;
}
// comparison: > < >= <= == !=
private function parseComparison(): Node
{
$node = $this->parseAdditive();
if ($this->current()->type === Token::T_OPERATOR) {
$op = $this->current()->value;
$this->consume(Token::T_OPERATOR);
$right = $this->parseAdditive();
$node = new BinaryOpNode($op, $node, $right);
}
return $node;
}
// Здесь могли бы быть + - * /, но нам хватит пока сравнений
private function parseAdditive(): Node
{
return $this->parsePrimary();
}
// Primary: numbers, strings, variables, (expr), not expr
private function parsePrimary(): Node
{
$token = $this->current();
if ($token->type === Token::T_NUMBER) {
$this->consume(Token::T_NUMBER);
return new NumberNode($token->value);
}
if ($token->type === Token::T_STRING) {
$this->consume(Token::T_STRING);
return new StringNode($token->value);
}
if ($token->type === Token::T_IDENTIFIER) {
$this->consume(Token::T_IDENTIFIER);
return new VariableNode($token->value);
}
if ($token->type === Token::T_KEYWORD && $token->value === 'not') {
$this->consume(Token::T_KEYWORD);
$expr = $this->parsePrimary();
return new UnaryOpNode('not', $expr);
}
if ($token->type === Token::T_LPAREN) {
$this->consume(Token::T_LPAREN);
$node = $this->parseLogical();
$this->consume(Token::T_RPAREN);
return $node;
}
throw new \Exception("Unexpected token: {$token->type}");
}
}
Проверяем AST:
$tokens = (new Lexer('user.age >= 18 and name == "John"'))->getTokens();
$ast = (new Parser($tokens))->parse();
var_dump($ast);Вы увидите что-то похожее:
BinaryOpNode(operator: "and",
left: BinaryOpNode(">=", VariableNode("user.age"), NumberNode(18)),
right: BinaryOpNode("==", VariableNode("name"), StringNode("John"))
)Вроде похоже на правду. Идем дальше.
Этап 3: Интерпретатор (обход AST)
На следующем шаге интерпретатор получает дерево + контекст (массив переменных) и вычисляет результат.
class Interpreter
{
public function __construct(private array $context) {}
public function evaluate(Node $node): mixed
{
if ($node instanceof NumberNode) {
return $node->value;
}
if ($node instanceof StringNode) {
return $node->value;
}
if ($node instanceof VariableNode) {
return $this->resolveVariable($node->name);
}
if ($node instanceof BinaryOpNode) {
$left = $this->evaluate($node->left);
$right = $this->evaluate($node->right);
return match ($node->operator) {
'>' => $left > $right,
'<' => $left < $right,
'>=' => $left >= $right,
'<=' => $left <= $right,
'==' => $left == $right,
'!=' => $left != $right,
'and' => $left && $right,
'or' => $left || $right,
default => throw new \Exception("Unknown operator {$node->operator}")
};
}
if ($node instanceof UnaryOpNode) {
$expr = $this->evaluate($node->expr);
return match ($node->operator) {
'not' => !$expr,
default => throw new \Exception("Unknown unary op {$node->operator}")
};
}
throw new \Exception("Unknown node type");
}
private function resolveVariable(string $name): mixed
{
$parts = explode('.', $name);
$current = $this->context;
foreach ($parts as $part) {
if (!is_array($current) || !array_key_exists($part, $current)) {
throw new \Exception("Undefined variable: {$name}");
}
$current = $current[$part];
}
return $current;
}
}Мы подготовили отдельные части нашего кода и теперь самое время собрать всё вместе.
class MyRuleEngine
{
public static function evaluate(string $expression, array $context): bool
{
$lexer = new Lexer($expression);
$tokens = $lexer->getTokens();
$parser = new Parser($tokens);
$ast = $parser->parse();
$interpreter = new Interpreter($context);
return (bool) $interpreter->evaluate($ast);
}
}Теперь давайте вернемся к нашему примеру из начала статьи:
$rule = 'user.age >= 18 and (user.has_vip or user.orders_count > 5)';
Для проверки используем следиющие данные:
$context = [
'user' => [
'age' => 25,
'has_vip' => false,
'orders_count' => 7
]
];
$result = MyRuleEngine::evaluate($rule, $context);
var_dump($result); В результате мы получим значение true, так как переданные значения соответствуют нашему правилу. Теперь давайте поменяем orders_count на 3:
$context['user']['orders_count'] = 3;
$result = MyRuleEngine::evaluate($rule, $context);
var_dump($result); Получим false, так как нам не хватает vip или заказов. Как видно, наш язык MyRuleEngine справляется со своими задачами.
Заключение
Давайте подведем небольшой итог того, что мы сейчас написали. Мы получили безопасный, расширяемый DSL, который во-первых, не использует eval, выдает понятные ошибки и без проблем работает в любом PHP-проекте. И при необходимости этот DSL может быть дополнен под любую бизнес-логику.
Так что, теперь, когда вы видите в коде $qb->where('u.age > :age') или {% if user.is_active %}, вы точно знаете, как это работает под капотом. А главное — вы сможете создать свой язык, который идеально ляжет на вашу предметную область. И неважно, будут это правила активации промокодов, скоринг клиентов или система бронирования.
Разбирать DSL удобнее не только по статье, но и вживую — когда можно увидеть, как лексер, парсер и интерпретатор собираются в рабочий пример, а заодно спросить, где такой подход уместен в реальном PHP-проекте. В OTUS пройдут два бесплатных открытых урока: можно познакомиться с экспертами, посмотреть формат обучения и закрыть вопросы, которые остаются после чтения.
29 апреля в 20:00 — «Свой язык на PHP за 60 минут»
Про DSL в PHP на примерах Doctrine, Twig и Symfony ExpressionLanguage + как собрать свой мини-язык под задачу. Записаться19 мая в 20:00 — «Работа с очередями в Laravel: от настройки до решения типичных проблем»
Про фоновые задачи, настройку очередей и типичные проблемы, которые появляются при росте приложения. Записаться
Немного практики в тему — пройдите вступительный тест** по PHP и узнаете, есть ли пробелы в знаниях.
** До 30 апреля за прохождение теста действует скидка 15% на курс