2

我有一个支持这个的语法：
AND，OR，NOT，（和），“，”

我需要能够解析的几个样本：

  • a1 或 a2
  • a1 a2（同上）
  • a1 和 a2
  • “a1”和“a2”
  • a1 或 a2 不是 a3
  • a1 a2 OR "a3" NOT(a1 AND a2 'a6')

考虑到 a1、a2 等是真实的用户输入，几乎可以包括以下任何内容：

  • 123
  • 特斯拉-S
  • 折纸

我遇到的问题是，其中一个词没有引号，并且以一些保留关键字开头，例如：

  • 折纸
  • 仙女座

在这种情况下，此解析器考虑：

  • 或关键字 + igami 文字
  • 和关键字 + romede 文本

这就是我遇到的问题。

我已经尝试了两天的各种解决方案，在stackoverflow（和官方文档）上找到：

（和许多其他）试图找到具有这些约束的解决方案：

  • 不能保证关键字前后有空格，例如“a1 AND(a2 OR a3)”有效（“AND”和“(”）之间没有空格，“(a1 AND a2)OR a3”= > 关键字之前/之后可以有空格和/或“（”/“）”（但是当我尝试这样做时，我打破了括号规则）
  • 一个词只有在它是保留部分的一部分时才不是一个词："AND"i / "OR"i / "NOT"i / "(" / ")" / "'" / '"' / " " =>其中任何一个都不是一个词，其他任何一个都是，就像 ando 是一个词，而不是一个关键字。

这是我想出的代码：

content = andOperator

andOperator
    = head:orOperator tail:(_ "AND"i _ orOperator)* {
        return tail.reduce(function(result, element) {
            return {
                type: "and",
                value: {
                    left: result,
                    right: element[3]
                }
            };
        }, head);
    }

orOperator
    = head:notOperator tail:(_ ("OR"i / _) _ notOperator)* {
        return tail.reduce(function(result, element) {
            return {
                type: "or",
                value: {
                    left: result,
                    right: element[3]
                }
            };
        }, head);
    }

notOperator
    = head:parenthesis tail:(_ ("AND"i / "OR" / _) _ "NOT"i _ parenthesis)* {
        return tail.reduce(function(result, element) {
            var type = (element[1] && element[1].toLowerCase() === "or") ? "or" : "and";
            return {
                type: type,
                value: {
                    left: result,
                    right: {
                        type: "not",
                        value: element[5]
                    }
                }
            };
        }, head);
    }

parenthesis "Parenthesis"
    = _ "(" _ inside:content+ _ ")" _ {
        return {
            type: "parenthesis",
            value: (Array.isArray(inside) && inside.length === 1) ? inside[0] : inside
        };
    } / text

/*
-----------------------------
  TEXT
-----------------------------
*/

text "Text"
    = _ inside:(singleQuoteText / doubleQuoteText / noQuoteText)+ _ {
        return (Array.isArray(inside) && inside.length === 1) ? inside[0] : inside;
    }

singleQuoteText "Single Quote Text"
    = "'" text:$([^\']+) "'" {
        return {
            type: "text",
            value: text ? text.trim(): text
        };
    }

doubleQuoteText "Double Quote Text"
    = '"' text:$([^\"]+) '"' {
        return {
            type: "text",
            value: text ? text.trim(): text
        };
    }

noQuoteText "No Quote Text"
    = text:$(!reserved .)+ {
        return {
            type: "text",
            value: text ? text.trim(): text
        };
    }

reserved "List of keyword this grammar allow"
    = ("AND"i / "OR"i / "NOT"i / "(" / ")" / "'" / '"' / " ")

/*
-----------------------------
  WHITESPACE PARSING
-----------------------------
*/
__ "Mandatory Whitespace"
    = $(whitespace+)

_ "Optional Whitespace"
    = __?

whitespace
    = [\u0009\u000B\u000C\u0020\u00A0\uFEFF\u1680\u180E\u2000-\u200A\u202F\u205F\u3000] / $('\r\n' / '\n')

问题示例：你好折纸

给出当前语法：

{
   "type": "or",
   "value": {
      "left": {
         "type": "text",
         "value": "hello"
      },
      "right": {
         "type": "text",
         "value": "igami"
      }
   }
}

应该给出（它认为折纸是一个完整的世界，而不是 or + igami）：

{
   "type": "or",
   "value": {
      "left": {
         "type": "text",
         "value": "hello"
      },
      "right": {
         "type": "text",
         "value": "origami"
      }
   }
}

当前解析器中的 Origami 被拆分为 OR + igami，而它应该考虑整个单词 origami...

4

1 回答 1

1

使用谓词，您可以包含一个匹配除关键字之外的所有单词的规则，如下所示：

{

   var keywords = ["and", "or"];

}

Expression =
    word:$(Word) { return { word: word } } /
    keyword:$(Keyword) { return { keyword: keyword } }

// Word will match everything except "and" and "or",
// including words like "origami" and "andromede"
Word = word:$([a-zA-Z]+) &{ return !keywords.includes(word) }

Keyword = [a-zA-Z]+

在上面的语法中，Word将匹配除“or”和“and”之外的所有单词。如果单词（然后是整个单词）是这些关键字之一，则Keyword规则将改为匹配。

因此，给定输入and，您将获得以下输出：

{
    keyword: "and"
}

但是给定输入andromede，您将得到以下输出：

{
    word: "andromede"
}
于 2019-07-23T14:38:49.840 回答