Regex 是否存在用于检测有效正则表达式的正则表达式?
是否可以用另一个正则表达式检测有效的正则表达式?如果是,请在下面给出示例代码。不太可能 在Regex 是否存在用于检测有效正则表达式的正则表达式?,regex,Regex,是否可以用另一个正则表达式检测有效的正则表达式?如果是,请在下面给出示例代码。不太可能 在try..catch或您的语言提供的任何内容中对其进行评估 / ^ # start of string ( # first group start (?: (?:[^?+*{}()[\]\\|]+
try..catch
或您的语言提供的任何内容中对其进行评估
/
^ # start of string
( # first group start
(?:
(?:[^?+*{}()[\]\\|]+ # literals and ^, $
| \\. # escaped characters
| \[ (?: \^?\\. | \^[^\\] | [^\\^] ) # character classes
(?: [^\]\\]+ | \\. )* \]
| \( (?:\?[:=!]|\?<[=!]|\?>)? (?1)?? \) # parenthesis, with recursive content
| \(\? (?:R|[+-]?\d+) \) # recursive matching
)
(?: (?:[?+*]|\{\d+(?:,\d*)?\}) [?+]? )? # quantifiers
| \| # alternative
)* # repeat content
) # end first group
$ # end of string
/
压实:
^(?:(?:[^?+*{}()[\]\\|]+|\\.|\[(?:\^?\\.|\^[^\\]|[^\\^])(?:[^\]\\]+|\\.)*\]|\((?:\?[:=!]|\?<[=!]|\?>|\?<[^\W\d]\w*>|\?'[^\W\d]\w*')?(?<N>)|\)(?<-N>))(?:(?:[?+*]|\{\d+(?:,\d*)?\})[?+]?)?|\|)*$(?(N)(?!))
在以下几段代码中,以下以下几段代码::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::)以下以下以下以下以下以下::::::::::::::::::::::::::::::::除了除了除了除了除了除了除了除了::::::::::::::::::::::::::::::::::::::????????????????????????????????????????????????????????????????????(N)(?!)
从评论中:
/^((?:(?:[^?+*{}()[\]\\|]+|\\.|\[(?:\^?\\.|\^[^\\]|[^\\^])(?:[^\]\\]+|\\.)*\]|\((?:\?[:=!]|\?<[=!]|\?>)?(?1)??\)|\(\?(?:R|[+-]?\d+)\))(?:(?:[?+*]|\{\d+(?:,\d*)?\})[?+]?)?|\|)*)$/
这会验证替换和翻译吗
它将只验证替换和转换的正则表达式部分<代码>s//…/
理论上不可能将所有有效的正则表达式语法与正则表达式匹配
如果正则表达式引擎支持递归(如PCRE),那么这是可能的,但这不能再称为正则表达式了
实际上,“递归正则表达式”不是正则表达式。但这是一个经常被接受的对正则表达式引擎的扩展。。。讽刺的是,这个扩展正则表达式与扩展正则表达式不匹配
“在理论上,理论和实践是一样的。在实践中,它们不是。”几乎所有知道正则表达式的人都知道正则表达式不支持递归。但是PCRE和大多数其他实现所支持的远远不止是基本的正则表达式
在grep命令中与shell脚本一起使用,它显示了一些错误。。grep:{}的内容无效。我正在制作一个脚本,可以grep一个代码库来查找所有包含正则表达式的文件
此模式利用了一个名为递归正则表达式的扩展。这是不受POSIX风格的正则表达式支持的。您可以尝试使用-P开关来启用PCRE正则表达式
正则表达式本身“不是正则语言,因此无法由正则表达式解析…”
经典正则表达式也是如此。一些现代的实现允许递归,这使得它成为一种上下文无关的语言,尽管这项任务有点冗长
我知道您在哪里匹配了[]()/\
。和其他特殊的正则表达式字符。在哪里允许使用非特殊字符?似乎这将匹配^(?:[\.]+)$
,但不匹配^abcdefg$
。这是一个有效的正则表达式
[^?+*{}()[\]\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]
将匹配任何单个字符,而不是任何其他构造的一部分。这包括文字(a
-z
)和某些特殊字符(^
,$
,
)。问得好
真正的正则语言不能决定任意深度嵌套的格式良好的括号。如果您的字母表包含”(“
和”)”
则目标是确定其中的字符串是否具有格式良好的匹配括号。因为这是正则表达式的必要条件,所以答案是否定的
然而,如果您放松了需求并添加了递归,那么您很可能可以做到这一点。原因是递归可以充当堆栈,让您通过推到该堆栈上“计算”当前嵌套深度
Russ Cox写了一篇关于正则表达式引擎实现的精彩论文 不,如果您严格地说是正则表达式,而不包括一些实际上是上下文无关语法的正则表达式实现 正则表达式有一个局限性,这使得不可能编写一个只匹配所有正则表达式的正则表达式。不能匹配大括号等成对的实现。正则表达式使用许多这样的构造,让我们以
[]
为例。每当有一个[
时,就必须有一个匹配的]
,这对于正则表达式“\[.\]”
来说足够简单
使正则表达式不可能的是它们可以嵌套。如何编写匹配嵌套括号的正则表达式?答案是你不能没有一个无限长的正则表达式。您可以通过蛮力匹配任意数量的嵌套括号,但无法匹配任意长的嵌套括号集
此功能通常称为计数,因为您正在计算嵌套的深度。根据定义,正则表达式不具有计数功能
关于这一点,我最后写了“”。尽管使用MizardX所发布的递归正则表达式是完全可能的,但对于这类事情,解析器要有用得多。正则表达式最初用于正则语言,递归或具有平衡组只是一个补丁 定义有效正则表达式的语言实际上是一种上下文无关语法,您应该使用适当的解析器来处理它。下面是一个解析简单正则表达式(没有大多数构造)的大学项目的示例。它使用JavaCC。是的,注释是西班牙文的,尽管方法名称是不言自明的
SKIP :
{
" "
| "\r"
| "\t"
| "\n"
}
TOKEN :
{
< DIGITO: ["0" - "9"] >
| < MAYUSCULA: ["A" - "Z"] >
| < MINUSCULA: ["a" - "z"] >
| < LAMBDA: "LAMBDA" >
| < VACIO: "VACIO" >
}
IRegularExpression Expression() :
{
IRegularExpression r;
}
{
r=Alternation() { return r; }
}
// Matchea disyunciones: ER | ER
IRegularExpression Alternation() :
{
IRegularExpression r1 = null, r2 = null;
}
{
r1=Concatenation() ( "|" r2=Alternation() )?
{
if (r2 == null) {
return r1;
} else {
return createAlternation(r1,r2);
}
}
}
// Matchea concatenaciones: ER.ER
IRegularExpression Concatenation() :
{
IRegularExpression r1 = null, r2 = null;
}
{
r1=Repetition() ( "." r2=Repetition() { r1 = createConcatenation(r1,r2); } )*
{ return r1; }
}
// Matchea repeticiones: ER*
IRegularExpression Repetition() :
{
IRegularExpression r;
}
{
r=Atom() ( "*" { r = createRepetition(r); } )*
{ return r; }
}
// Matchea regex atomicas: (ER), Terminal, Vacio, Lambda
IRegularExpression Atom() :
{
String t;
IRegularExpression r;
}
{
( "(" r=Expression() ")" {return r;})
| t=Terminal() { return createTerminal(t); }
| <LAMBDA> { return createLambda(); }
| <VACIO> { return createEmpty(); }
}
// Matchea un terminal (digito o minuscula) y devuelve su valor
String Terminal() :
{
Token t;
}
{
( t=<DIGITO> | t=<MINUSCULA> ) { return t.image; }
}
跳过:
{
" "
|“\r”
|“\t”
|“\n”
}
代币:
{
|
|
|
|
}
IRegularExpression表达式():
{
IRegularExpression r;
}
{
r=Alternation(){return r;}
}
//红茶:呃|呃
IRegularExpression Alternation():
{
IRegularExpression r1=null,r2=null;
}
{
r1=连接()(“|”r2=交替())?
{
if(r2==null){
返回r1;
}否则{
返回createAlternation(r1,r2);
}
}
}
//火柴:呃
IRegularExpression连接():
{
IRegularExpression r1=null,r2=null;
}
{
r1=repeation()(““r2=repeation(){r1=createConcatenation(r1,r2);})*
{返回r1;}
}
//重复匹配:呃*
IRegularExpression repeation():
{
IRegularExpression r;
}
{
r=Atom()(“*”{r=createRepeation(r);})*
{返回r;}
}
//匹配
SKIP :
{
" "
| "\r"
| "\t"
| "\n"
}
TOKEN :
{
< DIGITO: ["0" - "9"] >
| < MAYUSCULA: ["A" - "Z"] >
| < MINUSCULA: ["a" - "z"] >
| < LAMBDA: "LAMBDA" >
| < VACIO: "VACIO" >
}
IRegularExpression Expression() :
{
IRegularExpression r;
}
{
r=Alternation() { return r; }
}
// Matchea disyunciones: ER | ER
IRegularExpression Alternation() :
{
IRegularExpression r1 = null, r2 = null;
}
{
r1=Concatenation() ( "|" r2=Alternation() )?
{
if (r2 == null) {
return r1;
} else {
return createAlternation(r1,r2);
}
}
}
// Matchea concatenaciones: ER.ER
IRegularExpression Concatenation() :
{
IRegularExpression r1 = null, r2 = null;
}
{
r1=Repetition() ( "." r2=Repetition() { r1 = createConcatenation(r1,r2); } )*
{ return r1; }
}
// Matchea repeticiones: ER*
IRegularExpression Repetition() :
{
IRegularExpression r;
}
{
r=Atom() ( "*" { r = createRepetition(r); } )*
{ return r; }
}
// Matchea regex atomicas: (ER), Terminal, Vacio, Lambda
IRegularExpression Atom() :
{
String t;
IRegularExpression r;
}
{
( "(" r=Expression() ")" {return r;})
| t=Terminal() { return createTerminal(t); }
| <LAMBDA> { return createLambda(); }
| <VACIO> { return createEmpty(); }
}
// Matchea un terminal (digito o minuscula) y devuelve su valor
String Terminal() :
{
Token t;
}
{
( t=<DIGITO> | t=<MINUSCULA> ) { return t.image; }
}
#
# invRegex.py
#
# Copyright 2008, Paul McGuire
#
# pyparsing script to expand a regular expression into all possible matching strings
# Supports:
# - {n} and {m,n} repetition, but not unbounded + or * repetition
# - ? optional elements
# - [] character ranges
# - () grouping
# - | alternation
#
__all__ = ["count","invert"]
from pyparsing import (Literal, oneOf, printables, ParserElement, Combine,
SkipTo, operatorPrecedence, ParseFatalException, Word, nums, opAssoc,
Suppress, ParseResults, srange)
class CharacterRangeEmitter(object):
def __init__(self,chars):
# remove duplicate chars in character range, but preserve original order
seen = set()
self.charset = "".join( seen.add(c) or c for c in chars if c not in seen )
def __str__(self):
return '['+self.charset+']'
def __repr__(self):
return '['+self.charset+']'
def makeGenerator(self):
def genChars():
for s in self.charset:
yield s
return genChars
class OptionalEmitter(object):
def __init__(self,expr):
self.expr = expr
def makeGenerator(self):
def optionalGen():
yield ""
for s in self.expr.makeGenerator()():
yield s
return optionalGen
class DotEmitter(object):
def makeGenerator(self):
def dotGen():
for c in printables:
yield c
return dotGen
class GroupEmitter(object):
def __init__(self,exprs):
self.exprs = ParseResults(exprs)
def makeGenerator(self):
def groupGen():
def recurseList(elist):
if len(elist)==1:
for s in elist[0].makeGenerator()():
yield s
else:
for s in elist[0].makeGenerator()():
for s2 in recurseList(elist[1:]):
yield s + s2
if self.exprs:
for s in recurseList(self.exprs):
yield s
return groupGen
class AlternativeEmitter(object):
def __init__(self,exprs):
self.exprs = exprs
def makeGenerator(self):
def altGen():
for e in self.exprs:
for s in e.makeGenerator()():
yield s
return altGen
class LiteralEmitter(object):
def __init__(self,lit):
self.lit = lit
def __str__(self):
return "Lit:"+self.lit
def __repr__(self):
return "Lit:"+self.lit
def makeGenerator(self):
def litGen():
yield self.lit
return litGen
def handleRange(toks):
return CharacterRangeEmitter(srange(toks[0]))
def handleRepetition(toks):
toks=toks[0]
if toks[1] in "*+":
raise ParseFatalException("",0,"unbounded repetition operators not supported")
if toks[1] == "?":
return OptionalEmitter(toks[0])
if "count" in toks:
return GroupEmitter([toks[0]] * int(toks.count))
if "minCount" in toks:
mincount = int(toks.minCount)
maxcount = int(toks.maxCount)
optcount = maxcount - mincount
if optcount:
opt = OptionalEmitter(toks[0])
for i in range(1,optcount):
opt = OptionalEmitter(GroupEmitter([toks[0],opt]))
return GroupEmitter([toks[0]] * mincount + [opt])
else:
return [toks[0]] * mincount
def handleLiteral(toks):
lit = ""
for t in toks:
if t[0] == "\\":
if t[1] == "t":
lit += '\t'
else:
lit += t[1]
else:
lit += t
return LiteralEmitter(lit)
def handleMacro(toks):
macroChar = toks[0][1]
if macroChar == "d":
return CharacterRangeEmitter("0123456789")
elif macroChar == "w":
return CharacterRangeEmitter(srange("[A-Za-z0-9_]"))
elif macroChar == "s":
return LiteralEmitter(" ")
else:
raise ParseFatalException("",0,"unsupported macro character (" + macroChar + ")")
def handleSequence(toks):
return GroupEmitter(toks[0])
def handleDot():
return CharacterRangeEmitter(printables)
def handleAlternative(toks):
return AlternativeEmitter(toks[0])
_parser = None
def parser():
global _parser
if _parser is None:
ParserElement.setDefaultWhitespaceChars("")
lbrack,rbrack,lbrace,rbrace,lparen,rparen = map(Literal,"[]{}()")
reMacro = Combine("\\" + oneOf(list("dws")))
escapedChar = ~reMacro + Combine("\\" + oneOf(list(printables)))
reLiteralChar = "".join(c for c in printables if c not in r"\[]{}().*?+|") + " \t"
reRange = Combine(lbrack + SkipTo(rbrack,ignore=escapedChar) + rbrack)
reLiteral = ( escapedChar | oneOf(list(reLiteralChar)) )
reDot = Literal(".")
repetition = (
( lbrace + Word(nums).setResultsName("count") + rbrace ) |
( lbrace + Word(nums).setResultsName("minCount")+","+ Word(nums).setResultsName("maxCount") + rbrace ) |
oneOf(list("*+?"))
)
reRange.setParseAction(handleRange)
reLiteral.setParseAction(handleLiteral)
reMacro.setParseAction(handleMacro)
reDot.setParseAction(handleDot)
reTerm = ( reLiteral | reRange | reMacro | reDot )
reExpr = operatorPrecedence( reTerm,
[
(repetition, 1, opAssoc.LEFT, handleRepetition),
(None, 2, opAssoc.LEFT, handleSequence),
(Suppress('|'), 2, opAssoc.LEFT, handleAlternative),
]
)
_parser = reExpr
return _parser
def count(gen):
"""Simple function to count the number of elements returned by a generator."""
i = 0
for s in gen:
i += 1
return i
def invert(regex):
"""Call this routine as a generator to return all the strings that
match the input regular expression.
for s in invert("[A-Z]{3}\d{3}"):
print s
"""
invReGenerator = GroupEmitter(parser().parseString(regex)).makeGenerator()
return invReGenerator()
def main():
tests = r"""
[A-EA]
[A-D]*
[A-D]{3}
X[A-C]{3}Y
X[A-C]{3}\(
X\d
foobar\d\d
foobar{2}
foobar{2,9}
fooba[rz]{2}
(foobar){2}
([01]\d)|(2[0-5])
([01]\d\d)|(2[0-4]\d)|(25[0-5])
[A-C]{1,2}
[A-C]{0,3}
[A-C]\s[A-C]\s[A-C]
[A-C]\s?[A-C][A-C]
[A-C]\s([A-C][A-C])
[A-C]\s([A-C][A-C])?
[A-C]{2}\d{2}
@|TH[12]
@(@|TH[12])?
@(@|TH[12]|AL[12]|SP[123]|TB(1[0-9]?|20?|[3-9]))?
@(@|TH[12]|AL[12]|SP[123]|TB(1[0-9]?|20?|[3-9])|OH(1[0-9]?|2[0-9]?|30?|[4-9]))?
(([ECMP]|HA|AK)[SD]|HS)T
[A-CV]{2}
A[cglmrstu]|B[aehikr]?|C[adeflmorsu]?|D[bsy]|E[rsu]|F[emr]?|G[ade]|H[efgos]?|I[nr]?|Kr?|L[airu]|M[dgnot]|N[abdeiop]?|Os?|P[abdmortu]?|R[abefghnu]|S[bcegimnr]?|T[abcehilm]|Uu[bhopqst]|U|V|W|Xe|Yb?|Z[nr]
(a|b)|(x|y)
(a|b) (x|y)
""".split('\n')
for t in tests:
t = t.strip()
if not t: continue
print '-'*50
print t
try:
print count(invert(t))
for s in invert(t):
print s
except ParseFatalException,pfe:
print pfe.msg
print
continue
print
if __name__ == "__main__":
main()
@preg_match($regexToTest, '');
SyntaxError
// VALID ONE
> /yes[^]*day/
Out: /yes[^]*day/
// INVALID ONE
> /yes[^*day/
Out: VM227:1 Uncaught SyntaxError: Invalid regular expression: missing /
var RegexParser = function(input) {
// Parse input
var m = input.match(/(\/?)(.+)\1([a-z]*)/i);
// Invalid flags
if (m[3] && !/^(?!.*?(.).*?\1)[gmixXsuUAJ]+$/.test(m[3])) {
return RegExp(input);
}
// Create the regular expression
return new RegExp(m[2], m[3]);
};
var RegexString = "/yes.*day/"
var isRegexValid = input => {
try {
const regex = RegexParser(input);
}
catch(error) {
if(error.name === "SyntaxError")
{
return false;
}
else
{
throw error;
}
}
return true;
}