我需要在PHP中将正则表达式解析为它们的组件。我创建正则表达式或执行它们没有问题，但我想显示有关正则表达式的信息（例如列出捕获组，将重复字符附加到它们的目标，......）。整个项目是WordPress的插件，它提供了有关重写规则的信息，这些规则是具有替换模式的正则表达式，并且可能很难理解。
我自己编写了a simple implementation，它似乎处理了我抛出的简单正则表达式并将它们转换为语法树。在我扩展这个例子以支持更多op的正则表达式语法之前，我想知道是否还有其他好的实现我可以看一下。实现语言并不重要。我假设大多数解析器都是为优化匹配速度而编写的，但这对我来说并不重要，甚至可能会妨碍清晰度。
答案 0 :(得分：17)
我是Debuggex的创建者，其要求与您的要求非常相似：针对可显示的信息量进行优化。
以下是Debuggex使用的解析器的大量修改（for readablity）片段。它不能按原样运行，而是用于演示代码的组织。大多数错误处理已被删除。所以很多逻辑都是直截了当但又冗长。
请注意，使用了recursive descent。这是你在解析器中所做的，除了你的平面化为单个函数。我大概使用了这个语法：
Regex -> Alt
Alt -> Cat ('|' Cat)*
Cat -> Empty | (Repeat)+
Repeat -> Base (('*' | '+' | '?' | CustomRepeatAmount) '?'?)
Base -> '(' Alt ')' | Charset | Literal
Charset -> '[' (Char | Range | EscapeSeq)* ']'
Literal -> Char | EscapeSeq
CustomRepeatAmount -> '{' Number (',' Number)? '}'
你会注意到我的很多代码只是处理正则表达式的javascript风格的特殊性。您可以在this reference找到有关它们的更多信息。对于PHP，this包含您需要的所有信息。我认为你在使用解析器时非常顺利;剩下的就是实现其余的操作符并使边缘情况正确。
:)享受：
var Parser = function(s) {
this.s = s; // This is the regex string.
this.k = 0; // This is the index of the character being parsed.
this.group = 1; // This is a counter for assigning to capturing groups.
};
// These are convenience methods to make reading and maintaining the code
// easier.
// Returns true if there is more string left, false otherwise.
Parser.prototype.more = function() {
return this.k < this.s.length;
};
// Returns the char at the current index.
Parser.prototype.peek = function() { // exercise
};
// Returns the char at the current index, then advances the index.
Parser.prototype.next = function() { // exercise
};
// Ensures c is the char at the current index, then advances the index.
Parser.prototype.eat = function(c) { // exercise
};
// We use a recursive descent parser.
// This returns the root node of our tree.
Parser.prototype.parseRe = function() {
// It has exactly one child.
return new ReTree(this.parseAlt());
// We expect that to be at the end of the string when we finish parsing.
// If not, something went wrong.
if (this.more()) {
throw new Error();
}
};
// This parses several subexpressions divided by |s, and returns a tree
// with the corresponding trees as children.
Parser.prototype.parseAlt = function() {
var alts = [this.parseCat()];
// Keep parsing as long as a we have more pipes.
while (this.more() && this.peek() === '|') {
this.next();
// Recursive descent happens here.
alts.push(this.parseCat());
}
// Here, we allow an AltTree with single children.
// Alternatively, we can return the child if there is only one.
return new AltTree(alts);
};
// This parses several concatenated repeat-subexpressions, and returns
// a tree with the corresponding trees as children.
Parser.prototype.parseCat = function() {
var cats = [];
// If we reach a pipe or close paren, we stop. This is because that
// means we are in a subexpression, and the subexpression is over.
while (this.more() && ')|'.indexOf(this.peek()) === -1) {
// Recursive descent happens here.
cats.push(this.parseRepeat());
}
// This is where we choose to handle the empty string case.
// It's easiest to handle it here because of the implicit concatenation
// operator in our grammar.
return (cats.length >= 1) ? new CatTree(cats) : new EmptyTree();
};
// This parses a single repeat-subexpression, and returns a tree
// with the child that is being repeated.
Parser.prototype.parseRepeat = function() {
// Recursive descent happens here.
var repeat = this.parseBase();
// If we reached the end after parsing the base expression, we just return
// it. Likewise if we don't have a repeat operator that follows.
if (!this.more() || '*?+{'.indexOf(this.peek()) === -1) {
return repeat;
}
// These are properties that vary with the different repeat operators.
// They aren't necessary for parsing, but are used to give meaning to
// what was parsed.
var min = 0; var max = Infinity; var greedy = true;
if (this.peek() === '*') { // exercise
} else if (this.peek() === '?') { // exercise
} else if (this.peek() === '+') {
// For +, we advance the index, and set the minimum to 1, because
// a + means we repeat the previous subexpression between 1 and infinity
// times.
this.next(); min = 1;
} else if (this.peek() === '{') { /* challenging exercise */ }
if (this.more() && this.peek() === '?') {
// By default (in Javascript at least), repetition is greedy. Appending
// a ? to a repeat operator makes it reluctant.
this.next(); greedy = false;
}
return new RepeatTree(repeat, {min:min, max:max, greedy:greedy});
};
// This parses a "base" subexpression. We defined this as being a
// literal, a character set, or a parnthesized subexpression.
Parser.prototype.parseBase = function() {
var c = this.peek();
// If any of these characters are spotted, something went wrong.
// The ) should have been eaten by a previous call to parseBase().
// The *, ?, or + should have been eaten by a previous call to parseRepeat().
if (c === ')' || '*?+'.indexOf(c) !== -1) {
throw new Error();
}
if (c === '(') {
// Parse a parenthesized subexpression. This is either a lookahead,
// a capturing group, or a non-capturing group.
this.next(); // Eat the (.
var ret = null;
if (this.peek() === '?') { // excercise
// Parse lookaheads and non-capturing groups.
} else {
// This is why the group counter exists. We use it to enumerate the
// group appropriately.
var group = this.group++;
// Recursive descent happens here. Note that this calls parseAlt(),
// which is what was initially called by parseRe(), creating
// a mutual recursion. This is where the name recursive descent
// comes from.
ret = new MatchTree(this.parseAlt(), group);
}
// This MUST be a ) or something went wrong.
this.eat(')');
return ret;
} else if (c === '[') {
this.next(); // Eat the [.
// Parse a charset. A CharsetTree has no children, but it does contain
// (pseudo)chars and ranges, and possibly a negation flag. These are
// collectively returned by parseCharset().
// This piece can be structured differently depending on your
// implementation of parseCharset()
var opts = this.parseCharset();
// This MUST be a ] or something went wrong.
this.eat(']');
return new CharsetTree(opts);
} else {
// Parse a literal. Like a CharsetTree, a LiteralTree doesn't have
// children. Instead, it contains a single (pseudo)char.
var literal = this.parseLiteral();
return new LiteralTree(literal);
}
};
// This parses the inside of a charset and returns all the information
// necessary to describe that charset. This includes the literals and
// ranges that are accepted, as well as whether the charset is negated.
Parser.prototype.parseCharset = function() {
// challenging exercise
};
// This parses a single (pseudo)char and returns it for use in a LiteralTree.
Parser.prototype.parseLiteral = function() {
var c = this.next();
if (c === '.' || c === '^' || c === '$') {
// These are special chars. Their meaning is different than their
// literal symbol, so we set the 'special' flag.
return new CharInfo(c, true);
} else if (c === '\\') {
// If we come across a \, we need to parse the escaped character.
// Since parsing escaped characters is similar between literals and
// charsets, we extracted it to a separate function. The reason we
// pass a flag is because \b has different meanings inside charsets
// vs outside them.
return this.parseEscaped({inCharset: false});
}
// If neither case above was hit, we just return the exact char.
return new CharInfo(c);
};
// This parses a single escaped (pseudo)char and returns it for use in
// either a LiteralTree or a CharsetTree.
Parser.prototype.parseEscaped = function(opts) {
// Here we instantiate some default options
opts = opts || {};
inCharset = opts.inCharset || false;
var c = peek();
// Here are a bunch of escape sequences that require reading further
// into the string. They are all fairly similar.
if (c === 'c') { // exercises
} else if (c === '0') {
} else if (isDigit(c)) {
} else if (c === 'x') {
} else if (c === 'u') {
// Use this as an example for implementing the ones above.
// A regex may be used for this portion, but I think this is clearer.
// We make sure that there are exactly four hexadecimal digits after
// the u. Modify this for the escape sequences that your regex flavor
// uses.
var r = '';
this.next();
for (var i = 0; i < 4; ++i) {
c = peek();
if (!isHexa(c)) {
throw new Error();
}
r += c;
this.next();
}
// Return a single CharInfo desite having read multiple characters.
// This is why I used "pseudo" previously.
return new CharInfo(String.fromCharCode(parseInt(r, 16)));
} else { // No special parsing required after the first escaped char.
this.next();
if (inCharset && c === 'b') {
// Within a charset, \b means backspace
return new CharInfo('\b');
} else if (!inCharset && (c === 'b' || c === 'B')) {
// Outside a charset, \b is a word boundary (and \B is the complement
// of that). We mark it one as special since the character is not
// to be taken literally.
return new CharInfo('\\' + c, true);
} else if (c === 'f') { // these are left as exercises
} else if (c === 'n') {
} else if (c === 'r') {
} else if (c === 't') {
} else if (c === 'v') {
} else if ('dDsSwW'.indexOf(c) !== -1) {
} else {
// If we got to here, the character after \ should be taken literally,
// so we don't mark it as special.
return new CharInfo(c);
}
}
};
// This represents the smallest meaningful character unit, or pseudochar.
// For example, an escaped sequence with multiple physical characters is
// exactly one character when used in CharInfo.
var CharInfo = function(c, special) {
this.c = c;
this.special = special || false;
};
// Calling this will return the parse tree for the regex string s.
var parse = function(s) { return (new Parser(s)).parseRe(); };
答案 1 :(得分：9)
perl模块YAPE::Regex::Explain模块可能很容易移植到PHP。以下是其输出的示例
C:\>perl -e "use YAPE::Regex::Explain;print YAPE::Regex::Explain->new(qr/['-])->explain;"
The regular expression:
(?-imsx:['-])
matches as follows:
NODE EXPLANATION
----------------------------------------------------------------------
(?-imsx: group, but do not capture (case-sensitive)
(with ^ and $ matching normally) (with . not
matching \n) (matching whitespace and #
normally):
----------------------------------------------------------------------
['-] any character of: ''', '-'
----------------------------------------------------------------------
) end of grouping
----------------------------------------------------------------------
C:\>perl -e "use YAPE::Regex::Explain; print YAPE::Regex::Explain->new(qr/(\w+), ?(.)/)->explain;"
The regular expression:
(?-imsx:(\w+), ?(.))
matches as follows:
NODE EXPLANATION
----------------------------------------------------------------------
(?-imsx: group, but do not capture (case-sensitive)
(with ^ and $ matching normally) (with . not
matching \n) (matching whitespace and #
normally):
----------------------------------------------------------------------
( group and capture to \1:
----------------------------------------------------------------------
\w+ word characters (a-z, A-Z, 0-9, _) (1 or
more times (matching the most amount
possible))
----------------------------------------------------------------------
) end of \1
----------------------------------------------------------------------
, ','
----------------------------------------------------------------------
? ' ' (optional (matching the most amount
possible))
----------------------------------------------------------------------
( group and capture to \2:
----------------------------------------------------------------------
. any character except \n
----------------------------------------------------------------------
) end of \2
----------------------------------------------------------------------
) end of grouping
----------------------------------------------------------------------
C:\>
您可以查看the source code并快速查看实施情况。
答案 2 :(得分：3)
您需要的是语法和为其生成解析器的方法。生成解析器的最简单方法是直接在目标语言中编写递归下降（例如，在PHP中），在其中构建一个形状与语法完全相同的干净解析器（这使得解析器也可以维护）。 / p>
我的SO description of how to build recursive descent parsers和additional theory details here
提供了很多关于如何使用语法的详细信息。对于正则表达式语法，一个简单的语法（可能不是你想到的那个）是：
REGEX = ALTERNATIVES ;
ALTERNATIVES = TERM ( '|' TERM )* ;
TERM = '(' ALTERNATIVES ')' | CHARACTER | SET | TERM ( '*' | '+' | '?' ) ;
SET = '~' ? '[' ( CHARACTER | CHARACTER '-' CHARACTER )* ']' ;
CHARACTER = 'A' | 'B' | ... | '0' ... '9' | ... ;
用PHP编写的递归下降解析器来处理这个语法应该是几百行，最多
鉴于此作为起点，您应该能够将PHP Regexes的功能添加到其中。
快乐解析！
答案 3 :(得分：2)
您可能对我去年夏天所做的项目感兴趣。它是一个Javascript程序，提供PCRE兼容正则表达式的动态语法高亮显示：
请参阅：Dynamic (?:Regex Highlighting)++ with Javascript!
和associated tester page
和GitHub project page
代码使用（Javascript）正则表达式将（PCRE）正则表达式分离到其各个部分并应用标记以允许用户将鼠标悬停在各种组件上并查看匹配括号并捕获组号。
（我用正则表达式写的，因为我不知道更好！8 ^）
答案 4 :(得分：1)
好吧，你可以看一下php中正则表达式函数的实现。由于php是一个开源项目，所有的源和文档都可供公众使用。
答案 5 :(得分：1)
我会尝试将ActionScript 1/2正则表达式库转换为PHP。早期版本的Flash没有本机正则表达式支持，因此有一些用AS编写的库。从一种动态语言翻译成另一种动态语言应该比尝试解密C语言容易得多。
以下是一个值得关注的链接：http://www.jurjans.lv/flash/RegExp.html