it-swarm.com.de

Gibt es einen regulären Ausdruck, um einen gültigen regulären Ausdruck zu erkennen?

Ist es möglich, einen gültigen regulären Ausdruck mit einem anderen regulären Ausdruck zu erkennen? Wenn ja, geben Sie bitte den folgenden Beispielcode an.

681
psytek
/
^                                             # 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
/

Dies ist ein rekursiver regulärer Ausdruck und wird von vielen regulären Ausdrücken nicht unterstützt. PCRE-basierte sollten dies unterstützen.

Ohne Leerzeichen und Kommentare:

/^((?:(?:[^?+*{}()[\]\\|]+|\\.|\[(?:\^?\\.|\^[^\\]|[^\\^])(?:[^\]\\]+|\\.)*\]|\((?:\?[:=!]|\?<[=!]|\?>)?(?1)??\)|\(\?(?:R|[+-]?\d+)\))(?:(?:[?+*]|\{\d+(?:,\d*)?\})[?+]?)?|\|)*)$/

.NET unterstützt keine direkte Rekursion. (Das (?1) und (?R) Konstrukte.) Die Rekursion müsste konvertiert werden, um ausgeglichene Gruppen zu zählen:

^                                         # start of string
(?:
  (?: [^?+*{}()[\]\\|]+                   # literals and ^, $
   | \\.                                  # escaped characters
   | \[ (?: \^?\\. | \^[^\\] | [^\\^] )   # character classes
        (?: [^\]\\]+ | \\. )* \]
   | \( (?:\?[:=!]
         | \?<[=!]
         | \?>
         | \?<[^\W\d]\w*>
         | \?'[^\W\d]\w*'
         )?                               # opening of group
     (?<N>)                               #   increment counter
   | \)                                   # closing of group
     (?<-N>)                              #   decrement counter
   )
  (?: (?:[?+*]|\{\d+(?:,\d*)?\}) [?+]? )? # quantifiers
| \|                                      # alternative
)*                                        # repeat content
$                                         # end of string
(?(N)(?!))                                # fail if counter is non-zero.

Verdichtet:

^(?:(?:[^?+*{}()[\]\\|]+|\\.|\[(?:\^?\\.|\^[^\\]|[^\\^])(?:[^\]\\]+|\\.)*\]|\((?:\?[:=!]|\?<[=!]|\?>|\?<[^\W\d]\w*>|\?'[^\W\d]\w*')?(?<N>)|\)(?<-N>))(?:(?:[?+*]|\{\d+(?:,\d*)?\})[?+]?)?|\|)*$(?(N)(?!))
663
Markus Jarderot

Unwahrscheinlich.

Bewerten Sie es in einem try..catch oder was auch immer Ihre Sprache bietet.

242
Dan

Nein, wenn Sie streng genommen von regulären Ausdrücken sprechen und einige Implementierungen von regulären Ausdrücken, die eigentlich kontextfreie Grammatiken sind, nicht einschließen.

Es gibt eine Einschränkung bei regulären Ausdrücken, die es unmöglich macht, einen regulären Ausdruck zu schreiben, der allen und nur regulären Ausdrücken entspricht. Sie können Implementierungen wie z. B. geschweifte Klammern, die gekoppelt sind, nicht zuordnen. Regexe verwenden viele solcher Konstrukte. Nehmen wir als Beispiel []. Wann immer es eine gibt [es muss eine passende geben]. Einfach genug für einen regulären Ausdruck "[. *]".

Was Regexes unmöglich macht, ist, dass sie verschachtelt werden können. Wie können Sie einen regulären Ausdruck schreiben, der verschachtelten Klammern entspricht? Die Antwort ist, Sie können nicht ohne eine unendlich lange Regex. Sie können mit Brute Force eine beliebige Anzahl von verschachtelten Parens zuordnen, aber Sie können niemals einen beliebig langen Satz von verschachtelten Klammern zuordnen.

Diese Funktion wird oft als Zählen bezeichnet (Sie zählen die Tiefe der Verschachtelung). Ein regulärer Ausdruck kann per Definition nicht zählen.

BEARBEITEN: Es endete damit, einen Blog-Beitrag darüber zu schreiben: Regular Expression Limitations

160
JaredPar

Gute Frage. Wahre reguläre Sprachen können sich nicht für beliebig tief verschachtelte wohlgeformte Klammern entscheiden. Das heißt, wenn Ihr Alphabet '(' und ')' enthält, besteht das Ziel darin, zu entscheiden, ob eine Zeichenfolge aus diesen gut geformten, übereinstimmenden Klammern besteht. Da dies eine notwendige Voraussetzung für reguläre Ausdrücke ist, lautet die Antwort nein.

Allerdings: Wenn Sie die Anforderung lösen und eine Rekursion hinzufügen, können Sie dies wahrscheinlich tun. Der Grund dafür ist, dass die Rekursion als "Stapel" fungieren kann und Sie die aktuelle Verschachtelungstiefe durch Aufschieben auf diesen Stapel "zählen" können.

Russ Cox hat eine wunderbare Abhandlung über die Implementierung von Regex-Engines geschrieben: Matching mit regulären Ausdrücken kann einfach und schnell sein

40

Obwohl es durchaus möglich ist, einen rekursiven regulären Ausdruck zu verwenden, wie es MizardX gepostet hat, ist es für diese Art von Dingen viel nützlicher, einen Parser zu verwenden. Regexe sollten ursprünglich mit regulären Sprachen verwendet werden. Rekursiv zu sein oder Bilanzgruppen zu haben, ist nur ein Patch.

Die Sprache, die gültige reguläre Ausdrücke definiert, ist eigentlich eine kontextfreie Grammatik, und Sie sollten einen geeigneten Parser für die Handhabung verwenden. Hier ist ein Beispiel für ein Universitätsprojekt zum Parsen einfacher regulärer Ausdrücke (ohne die meisten Konstrukte). Es verwendet JavaCC. Und ja, Kommentare sind auf Spanisch, obwohl Methodennamen ziemlich selbsterklärend sind.

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; }
}
8

Sie können den regulären Ausdruck an preg_match senden, der false zurückgibt, wenn der reguläre Ausdruck ungültig ist. Vergessen Sie nicht, das '@' zu verwenden, um Fehlermeldungen zu unterdrücken:

@preg_match($regexToTest, '');
  • Gibt 1 zurück, wenn der reguläre Ausdruck '//' ist.
  • Gibt 0 zurück, wenn der reguläre Ausdruck in Ordnung ist.
  • Wird sonst false zurückgeben.

Das folgende Beispiel von Paul McGuire, ursprünglich aus dem Pyparsing-Wiki, aber jetzt nur über die Wayback-Maschine verfügbar , enthält eine Grammatik zum Parsen einiger reguläre Ausdrücke, um den Satz passender Zeichenfolgen zurückzugeben. Als solches lehnt es diejenigen Re's ab, die unbegrenzte Wiederholungsbegriffe wie '+' und '*' enthalten. Aber es sollte Ihnen eine Vorstellung davon geben, wie Sie einen Parser strukturieren, der Re's verarbeiten würde.

# 
# 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 __== "__main__":
    main()
4
PaulMcG

Nein, wenn Sie reguläre Standardausdrücke verwenden.

Der Grund dafür ist, dass Sie das pumpfähige Lemma für reguläre Sprachen nicht erfüllen können. Das Pumping-Lemma besagt, dass eine Zeichenfolge, die zur Sprache L gehört, regulär ist, wenn es eine Zahl N gibt, sodass Sie y wiederholen können, nachdem Sie die Zeichenfolge in 3 Teilzeichenfolgen xyz unterteilt haben, sodass | x |> = 1 && | xy | <= N so oft du willst und die gesamte Saite wird immer noch zu L gehören.

Eine Konsequenz des Pump-Lemmas ist, dass Sie keine regulären Zeichenfolgen in der Form a^Nb^Mc^N Haben können, dh zwei Teilzeichenfolgen mit derselben Länge, die durch eine andere Zeichenfolge getrennt sind. Wenn Sie solche Zeichenfolgen in x, y und z aufteilen, können Sie y nicht "pumpen", ohne eine Zeichenfolge mit einer anderen Anzahl von "a" und "c" zu erhalten, wodurch die Originalsprache erhalten bleibt. Dies ist beispielsweise bei Klammern in regulären Ausdrücken der Fall.

1
Davide Visentin