我的输入很简单:

$input = '( ( "M" AND ( "(" OR "AND" ) ) OR "T" )';

其中 ( 在树上开始一个新节点并且 ) 结束它。 AND 和 OR 词保留用于 bool 运算，因此除非它们不在 ""标记内，否则它们具有特殊含义。在我的 DSL 中，AND 和 OR 子句按节点级别更改，以便在级别上只能有 AND 或 OR 子句。如果 AND 出现在 OR 之后，它将启动一个新的子节点。 ""内的所有字符都应按原样处理。最后 "可以像往常一样用\"转义。

在 PHP 中制作如下所示的翻译语句的好方法是什么:

$output = array(array(array("M" , array("(", "AND")) , "T"), FALSE);

请注意，FALSE 是一个指示符，表示根级别具有 OR 关键字。如果输入是:

( ( "M" AND ( "(" OR "AND" ) ) AND "T" )

那么输出将是:

$output = array(array(array("M", array("(", "AND")), "T"), TRUE);

使用 replace('(', 'array('); 和 eval 代码很诱人，但是转义字符和包装文字将成为一个问题。

目前我没有在 DSL 上实现 NOT bool 运算符。

感谢您的帮助。 JavaSript 代码也可以。

Python 示例:

在使用 PHP 和 Javascript 之前，我用 Python 做了一些测试。我所做的是:

1. 使用正则表达式查找字符串文字
2. 用生成的键替换文字
3. 将文字存储到关联列表
4. 通过括号将输入拆分为单级列表
5. 找到根级 bool 运算符
6. 摆脱 bool 运算符和空格
7. 用存储的值替换文字键

它可能会起作用，但我相信一定有更复杂的方法来做到这一点。

http://codepad.org/PdgQLviI

最佳答案

这是我的副项目的库修改。它应该处理这些类型的字符串 - 执行一些压力测试，如果它在某处中断，请告诉我。

Tokenizer type class 需要提取和标记变量，因此它们不会干扰语法解析和标记化括号，因此可以直接匹配它们(lazy-evaluated内容不会捕获嵌套级别，greedy 将覆盖同一级别的所有上下文)。它还具有一些关键字语法(比需要的多一点，因为它将仅针对根级别进行解析)。当尝试使用错误的键访问变量注册表时抛出 InvalidArgumentException，当括号不匹配时抛出 RuntimeException。

class TokenizedInput
{
    const VAR_REGEXP         = '\"(?P<string>.*?)\"';
    const BLOCK_OPEN_REGEXP  = '\(';
    const BLOCK_CLOSE_REGEXP = '\)';
    const KEYWORD_REGEXP     = '(?<keyword>OR|AND)';

    // Token: <TOKEN_DELIM_LEFT><TYPE_TOKEN><ID_DELIM>$id<TOKEN_DELIM_RIGHT>
    const TOKEN_DELIM_LEFT  = '<';
    const TOKEN_DELIM_RIGHT = '>';

    const VAR_TOKEN         = 'VAR';
    const KEYWORD_TOKEN     = 'KEYWORD';
    const BLOCK_OPEN_TOKEN  = 'BLOCK';
    const BLOCK_CLOSE_TOKEN = 'ENDBLOCK';

    const ID_DELIM  = ':';
    const ID_REGEXP = '[0-9]+';

    private $original;
    private $tokenized;
    private $data = [];

    private $blockLevel = 0;
    private $varTokenId = 0;

    protected $procedure = [
        'varTokens'    => self::VAR_REGEXP,
        'keywordToken' => self::KEYWORD_REGEXP,
        'blockTokens'  => '(?P<open>' . self::BLOCK_OPEN_REGEXP . ')|(?P<close>' . self::BLOCK_CLOSE_REGEXP . ')'
    ];

    private $tokenMatch;

    public function __construct($input) {
        $this->original = (string) $input;
    }

    public function string() {
        isset($this->tokenized) or $this->tokenize();
        return $this->tokenized;
    }

    public function variable($key) {
        isset($this->tokenized) or $this->tokenize();
        if (!isset($this->data[$key])) {
            throw new InvalidArgumentException("Variable id:($key) does not exist.");
        }
        return $this->data[$key];
    }

    public function tokenSearchRegexp() {
        if (!isset($this->tokenMatch)) {
            $strings  = $this->stringSearchRegexp();
            $blocks   = $this->blockSearchRegexp();
            $this->tokenMatch = '#(?:' . $strings . '|' . $blocks . ')#';
        }
        return $this->tokenMatch;
    }

    public function stringSearchRegexp($id = null) {
        $id = $id ?: self::ID_REGEXP;
        return preg_quote(self::TOKEN_DELIM_LEFT . self::VAR_TOKEN . self::ID_DELIM)
            . '(?P<id>' . $id . ')'
            . preg_quote(self::TOKEN_DELIM_RIGHT);
    }

    public function blockSearchRegexp($level = null) {
        $level = $level ?: self::ID_REGEXP;
        $block_open = preg_quote(self::TOKEN_DELIM_LEFT . self::BLOCK_OPEN_TOKEN . self::ID_DELIM)
            . '(?P<level>' . $level . ')'
            . preg_quote(self::TOKEN_DELIM_RIGHT);
        $block_close = preg_quote(self::TOKEN_DELIM_LEFT . self::BLOCK_CLOSE_TOKEN . self::ID_DELIM)
            . '\k<level>'
            . preg_quote(self::TOKEN_DELIM_RIGHT);
        return $block_open . '(?P<contents>.*)' . $block_close;
    }

    public function keywordSearchRegexp($keyword = null) {
        $keyword = $keyword ? '(?P<keyword>' . $keyword . ')' : self::KEYWORD_REGEXP;
        return preg_quote(self::TOKEN_DELIM_LEFT . self::KEYWORD_TOKEN . self::ID_DELIM)
            . $keyword
            . preg_quote(self::TOKEN_DELIM_RIGHT);
    }

    private function tokenize() {
        $current = $this->original;
        foreach ($this->procedure as $method => $pattern) {
            $current = preg_replace_callback('#(?:' . $pattern . ')#', [$this, $method], $current);
        }

        if ($this->blockLevel) {
            throw new RuntimeException("Syntax error. Parenthesis mismatch." . $this->blockLevel);
        }

        $this->tokenized = $current;
    }

    protected function blockTokens($match) {
        if (isset($match['close'])) {
            $token = self::BLOCK_CLOSE_TOKEN . self::ID_DELIM . --$this->blockLevel;
        } else {
            $token = self::BLOCK_OPEN_TOKEN . self::ID_DELIM . $this->blockLevel++;

        }

        return $this->addDelimiters($token);
    }

    protected function varTokens($match) {
        $this->data[$this->varTokenId] = $match[1];
        return $this->addDelimiters(self::VAR_TOKEN . self::ID_DELIM . $this->varTokenId++);
    }

    protected function keywordToken($match) {
        return $this->addDelimiters(self::KEYWORD_TOKEN . self::ID_DELIM . $match[1]);
    }

    private function addDelimiters($token) {
        return self::TOKEN_DELIM_LEFT . $token . self::TOKEN_DELIM_RIGHT;
    }
}

解析器类型类 对标记化字符串执行匹配 - 提取注册变量并通过克隆本身递归进入嵌套上下文。 运算符类型处理是不寻常的，这使它更像是一个派生类，但无论如何在解析器的世界中很难实现令人满意的抽象。

class ParsedInput
{
    private $input;
    private $result;
    private $context;

    public function __construct(TokenizedInput $input) {
        $this->input = $input;
    }

    public function result() {
        if (isset($this->result)) { return $this->result; }

        $this->parse($this->input->string());
        $this->addOperator();

        return $this->result;
    }

    private function parse($string, $context = 'root') {
        $this->context = $context;
        preg_replace_callback(
            $this->input->tokenSearchRegexp(),
            [$this, 'buildStructure'],
            $string
        );

        return $this->result;
    }

    protected function buildStructure($match) {
        if (isset($match['contents'])) { $this->parseBlock($match['contents'], $match['level']); }
        elseif (isset($match['id'])) { $this->parseVar($match['id']); }
    }

    protected function parseVar($id) {
        $this->result[] = $this->input->variable((int) $id);
    }

    protected function parseBlock($contents, $level) {
        $nested = clone $this;
        $this->result[] = $nested->parse($contents, (int) $level);
    }

    protected function addOperator() {
        $subBlocks = '#' . $this->input->blockSearchRegexp(1) . '#';
        $rootLevel = preg_replace($subBlocks, '', $this->input->string());
        $rootKeyword = '#' . $this->input->keywordSearchRegexp('AND') . '#';
        return $this->result[] = (preg_match($rootKeyword, $rootLevel) === 1);
    }

    public function __clone() {
        $this->result = [];
    }
}

示例用法:

$input = '( ( "M" AND ( "(" OR "AND" ) ) AND "T" )';

$tokenized = new TokenizedInput($input);
$parsed = new ParsedInput($tokenized);

$result = $parsed->result();

我删除了 namespace /导入/接口(interface)，因此您可以根据需要调整它们。也不想挖掘(现在可能无效的)评论，所以也删除了它们。

关于php - 如何使用 PHP 从 bool 符号 (DSL) 创建数组树，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/41750445/