用javascript编写的搜索表达式解析器

class SearchExpressionParser {
    constructor(expression) {
        this.expression = expression;
        this.index = 0;
    }

    parse() {
        this.tokens = this.tokenize(this.expression);
        return this.parseExpression();
    }

    tokenize(expression) {
        const regex = /\s*(=>|&&|\|\||!|\(|\)|\w+)\s*/g;
        return expression.match(regex).map(token => token.trim());
    }

    parseExpression() {
        let left = this.parseTerm();

        while (this.peek() === 'OR') {
            this.consume('OR');
            const right = this.parseTerm();
            left = { type: 'OR', left, right };
        }

        return left;
    }

    parseTerm() {
        let left = this.parseFactor();

        while (this.peek() === 'AND') {
            this.consume('AND');
            const right = this.parseFactor();
            left = { type: 'AND', left, right };
        }

        return left;
    }

    parseFactor() {
        if (this.peek() === 'NOT') {
            this.consume('NOT');
            const operand = this.parseFactor();
            return { type: 'NOT', operand };
        } else if (this.peek() === '(') {
            this.consume('(');
            const expression = this.parseExpression();
            this.consume(')');
            return expression;
        } else {
            return this.parseLiteral();
        }
    }

    parseLiteral() {
        const token = this.consume();
        return { type: 'LITERAL', value: token };
    }

    peek() {
        return this.tokens[this.index];
    }

    consume(expected) {
        const token = this.tokens[this.index];
        if (expected && token !== expected) {
            throw new Error(`Expected ${expected} but found ${token}`);
        }
        this.index++;
        return token;
    }
}

// 示例用法
const expression = "NOT (apple AND orange) OR banana";
const parser = new SearchExpressionParser(expression);
const ast = parser.parse();
console.log(JSON.stringify(ast, null, 2));

{
  "type": "OR",
  "left": {
    "type": "NOT",
    "operand": {
      "type": "AND",
      "left": {
        "type": "LITERAL",
        "value": "apple"
      },
      "right": {
        "type": "LITERAL",
        "value": "orange"
      }
    }
  },
  "right": {
    "type": "LITERAL",
    "value": "banana"
  }
}