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

Вряд ли.

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

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

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

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

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

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

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

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

Хотя вполне возможно использовать рекурсивное регулярное выражение, которое опубликовал 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; }
}

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

@preg_match($regexToTest, '');

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

Этот пример в вики-каталоге pyparsing дает грамматику для разбора некоторых регулярных выражений с целью возврата набора совпадающих строк. Таким образом, он отвергает те, которые включают неограниченные термины повторения, такие как "+" и "*". Но это должно дать вам представление о том, как структурировать парсер, который будет обрабатывать re.

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

//regular expression for email
    var pattern = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[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;
    }