Существует ли регулярное выражение для определения правильного регулярного выражения?

Ответ 1

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

Это рекурсивное регулярное выражение, которое не поддерживается многими механизмами регулярных выражений. PCRE должны поддерживать это.

Без пробелов и комментариев:

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

.NET не поддерживает рекурсию напрямую. (Конструкции (?1) и (?R).) Рекурсию необходимо преобразовать в подсчет сбалансированных групп:

^                                         # 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.

Уплотненный:

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

Из комментариев:

Будет ли это подтверждать замены и переводы?

Он будет проверять только часть регулярных выражений с заменами и переводами. s/<this part>/.../

Теоретически невозможно сопоставить все действительные грамматики регулярных выражений с регулярными выражениями.

Это возможно, если механизм регулярных выражений поддерживает рекурсию, такую как PCRE, но это больше нельзя называть регулярными выражениями.

Действительно, "рекурсивное регулярное выражение" не является регулярным выражением. Но это часто принимаемое расширение для двигателей регулярных выражений... Как ни странно, это расширенное регулярное выражение не соответствует расширенным регулярным выражениям.

"Теоретически, теория и практика - это одно и то же. На практике это не так". Почти каждый, кто знает регулярные выражения, знает, что регулярные выражения не поддерживают рекурсию. Но PCRE и большинство других реализаций поддерживают гораздо больше, чем базовые регулярные выражения.

используя это со сценарием оболочки в команде grep, он показывает мне некоторую ошибку.. grep: недопустимое содержимое {}. Не могли бы вы помочь, я делаю сценарий, который может grep кода базы, чтобы найти все файлы, которые содержат регулярные выражения

Этот шаблон использует расширение, называемое рекурсивными регулярными выражениями. Это не поддерживается разновидностью регулярных выражений POSIX. Вы можете попробовать с помощью переключателя -P включить поддержку регулярных выражений PCRE.

Само регулярное выражение "не является регулярным языком и, следовательно, не может быть проанализировано с помощью регулярного выражения..."

Это верно для классических регулярных выражений. В некоторых современных реализациях допускается рекурсия, что делает его языком без контекста, хотя это несколько многословно для этой задачи.

Я вижу, где вы подходите []()/\. и другие специальные символы регулярных выражений. Где вы разрешаете не специальные символы? Кажется, что это будет соответствовать ^(?:[\.]+)$, но не ^abcdefg$. Это действительное регулярное выражение.

[^?+*{}()[\]\\|] будет соответствовать любому отдельному символу, не являющемуся частью какой-либо другой конструкции. Это включает в себя как литералы (a - z), так и некоторые специальные символы (^, $, .).

Ответ 2

Вряд ли.

Оцените его в try..catch или независимо от того, что предоставляет ваш язык.

Ответ 3

Нет, если вы строго говорите о регулярных выражениях и не включаете некоторые реализации регулярных выражений, которые на самом деле являются контекстно-свободными грамматиками.

Существует одно ограничение регулярных выражений, которое делает невозможным запись регулярного выражения, которое соответствует всем и только регулярным выражениям. Вы не можете сопоставлять реализации, например, фигурные скобки. Regexes использует много таких конструкций, поэтому возьмем [] в качестве примера. Всякий раз, когда есть [должно быть соответствие]. Достаточно просто для регулярного выражения "[. *]".

Что делает невозможным регулярное выражение, так это то, что они могут быть вложенными. Как вы можете написать регулярное выражение, соответствующее вложенным скобкам? Ответ: вы не можете без бесконечно длинного регулярного выражения. Вы можете сопоставить любое количество вложенных парсов с помощью грубой силы, но вы никогда не сможете сопоставить произвольно длинный набор вложенных скобок.

Эта способность часто упоминается как подсчет (вы считаете глубину вложенности). Регулярное выражение по определению не имеет возможности подсчитать.

EDIT: Закончилось писать сообщение в блоге об этом: Ограничения регулярного выражения

Ответ 4

Однако: если вы отмените требование и добавите рекурсию, вы, вероятно, сможете это сделать. Причина в том, что рекурсия может действовать как "стек", позволяя вам "подсчитать" текущую глубину вложенности, нажав на этот стек.

Russ Cox написал замечательный трактат о реализации двигателя regex: Регуляция регулярных выражений может быть простой и быстрой

Ответ 5

Нет, если вы используете стандартные регулярные выражения.

Причина в том, что вы не можете удовлетворить прокачку леммы для обычных языков. Лемма накачки гласит, что строка, принадлежащая языку L, является правильной, если существует число N, такое, что после разделения строки на 3 подстроки xyz, такое что | x |> = 1 && | xy | & lt; = N, вы можете повторять y столько раз, сколько хотите, и вся строка все равно будет принадлежать L.

Следствием леммы прокачки является то, что вы не можете иметь регулярные строки в форме a^Nb^Mc^N, то есть две подстроки одинаковой длины, разделенные другой строкой. В любом случае, разбивая такие строки на x y и z, вы не можете "качать" y, не получив строку с другим числом "a" и "c", оставляя тем самым исходный язык. Это случай, например, с круглыми скобками в регулярных выражениях.

Ответ 6

Хотя вполне возможно использовать рекурсивное регулярное выражение, которое опубликовал MizardX, для такого рода вещей гораздо полезнее парсер. Regexes изначально предназначались для использования с обычными языками, будучи рекурсивными или имеющими балансировочные группы - это всего лишь патч.

Язык, который определяет действительные регулярные выражения, на самом деле является контекстно-свободной грамматикой, и вы должны использовать соответствующий синтаксический анализатор для его обработки. Ниже приведен пример университетского проекта для синтаксического анализа простых регулярных выражений (без большинства конструкций). Он использует 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; }
}

Ответ 7

Вы можете отправить регулярное выражение в preg_match, которое вернет false, если регулярное выражение недопустимо. Не забудьте использовать "@" для подавления сообщений об ошибках:

@preg_match($regexToTest, '');

• Вернет 1, если регулярное выражение равно "//".
• Вернет 0, если регулярное выражение в порядке.
• Вернет ложь в противном случае.

Ответ 8

В следующем примере Пола Макгуайра, который изначально был написан на pyparsing wiki, но теперь доступен только через Wayback Machine, приведена грамматика для анализа некоторых регулярных выражений с целью возврата набора совпадающих строк. Как таковой, он отклоняет те, которые включают неограниченные термины повторения, такие как "+" и "*". Но это должно дать вам представление о том, как структурировать синтаксический анализатор, который будет обрабатывать его.

# 
# 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()

Ответ 9

Попробуйте этот...

//regular expression for email
    var pattern = /^(([^<>()[\]\\.,;:\[email protected]\"]+(\.[^<>()[\]\\.,;:\[email protected]\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
    if(pattern.test(email)){
        return true;
    } else {
        return false;
    }