Czy istnieje wyrażenie regularne do wykrywania poprawnego wyrażenia regularnego?

Mało prawdopodobne.

Oceń go w {[0] } lub w dowolnym języku.

Nie, jeśli ściśle mówisz o wyrażeniach regularnych i nie uwzględniasz niektórych implementacji wyrażeń regularnych, które w rzeczywistości są gramatykami bezkontekstowymi.

Istnieje jedno ograniczenie wyrażeń regularnych, które uniemożliwia zapisanie wyrażeń regularnych, które pasują do wszystkich i tylko wyrażeń regularnych. Nie można dopasować implementacji, takich jak sparowane szelki. Wyrażenia regularne używają wielu takich konstrukcji, weźmy jako przykład []. Ilekroć istnieje [musi być dopasowanie]. Dość proste for a regex "[.*]".

Niemożliwe dla wyrażeń regularnych jest to, że mogą być zagnieżdżone. Jak napisać Wyrażenie regularne pasujące do zagnieżdżonych nawiasów? Odpowiedź jest taka, że nie możesz bez nieskończenie długiego wyrażenia regularnego. Możesz dopasować dowolną liczbę zagnieżdżonych nawiasów za pomocą brute force, ale nigdy nie możesz dopasować arbitralnie długiego zestawu zagnieżdżonych nawiasów.

Ta funkcja jest często określana jako liczenie (liczysz głębokość zagnieżdżenia). Regex z definicji nie ma możliwość liczenia.

Edytuj: Skończyło się na napisaniu posta na blogu o tym: ograniczenia wyrażeń regularnych

Dobre pytanie. Prawdziwe języki regularne nie mogą decydować arbitralnie głęboko zagnieżdżone dobrze uformowany nawias. Jeśli twój alfabet zawiera '(' i')', celem jest ustalenie, czy ciąg z nich ma dobrze uformowany nawias. Ponieważ jest to wymóg konieczny dla wyrażeń regularnych, odpowiedź brzmi nie.

Jednakże: jeśli poluzujesz wymóg i dodasz rekurencję, prawdopodobnie możesz to zrobić. Powodem jest to, że rekurencja może działać jako "stos" pozwalający "policzyć" bieżący głębokość zagnieżdżania naciskając na ten stos.

Russ Cox napisał wspaniały Traktat o implementacji silnika regex: dopasowywanie wyrażeń regularnych może być proste i szybkie

Chociaż jest całkowicie możliwe użycie rekurencyjnego wyrażenia regularnego, jak opublikował MizardX, dla tego rodzaju rzeczy jest o wiele bardziej przydatny parser. Wyrażenia regularne były pierwotnie przeznaczone do użycia z językami regularnymi, będąc rekurencyjne lub posiadające grupy równoważące to tylko łatka.

Język, który definiuje poprawne wyrażenia regularne, jest w rzeczywistości gramatyką bezkontekstową i powinieneś użyć odpowiedniego parsera do obsługi GO. Oto przykład projektu uniwersyteckiego do parsowania prostych wyrażeń regularnych (bez większość konstrukcji). Używa JavaCC. I tak, komentarze są w języku hiszpańskim, choć nazwy metod są dość oczywiste.

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

Możesz przesłać Wyrażenie regularne do preg_match, które zwróci false, jeśli wyrażenie regularne nie jest poprawne. Nie zapomnij użyć'@', aby stłumić komunikaty o błędach:

@preg_match($regexToTest, '');

• zwróci 1, jeśli regex to '//'.
• zwróci 0, jeśli regex jest w porządku.
• zwróci false w przeciwnym razie.

Ten Przykład na pyparsing wiki daje gramatykę do parsowania niektórych wyrażeń regularnych, w celu zwrócenia zestawu pasujących łańcuchów. Jako takie odrzuca te re, które zawierają nieograniczone terminy powtórzeń, takie jak " + "i"*". Ale powinno dać ci wyobrażenie o tym, jak skonstruować parser, który przetwarzałby re.

Spróbuj tego...

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