Reguläre Ausdrücke sind ein mächtiges Programmierwerkzeug, doch die meisten Entwickler die ich kenne, benutzen diese ungern, da die Syntax doch sehr kryptisch ist. Ich benutze die RegEx-Klasse immer häufiger und deshalb werde hier einfach einmal ein kleines Tutorial, ohne den Anspruch der Vollständigkeit vorstellen.
Aufbau von Regulären Ausdrücken
Reguläre Ausdrücke werden in Zeichen, Zeichenklassen und Metazeichen unterteilt.
Jedes normale Zeichen steht für sich selbst, das heißt, dass der Ausdruck xy auf alle Zeichenketten passt, in denen xy vorkommt, wie z.B. in Proxy.
Zeichenklassen werden in eckigen Klammern definiert.
– [a-z] steht für einen beliebigen Buchstaben, der zwischen a und z vorkommt
– [abcxy] steht für einen der Buchstaben a,b,c,x,y
| . | Alle Zeichen außer \n | .a |
| ^ | Anfang einer Zeichenkette | ^z |
| $ | Ende einer Zeichenkette | w$ |
| | | Alternativen | a|b |
| ( ) | Zusammenfassen von Teilen | (ab)|c |
| [ ] | Erstellung von Zeichenklassen | [jhklWZ] |
| { } | Quantifizierer | a{2} |
| \ | Maskierung von Zeichen | |
| \b , \B \b | Leere Zeichenkette am Wortanfang oder am Wortende | |
| \B | Leere Zeichenkette nicht am Ende oder Anfang | |
| \s , \S \s | Whitespace | |
| \S | Non- Whitespace | |
| \d , \D \d | alle Ziffern | |
| \D | alle Zeichen außer Ziffern | |
| \w , \W \w | alle Wortzeichen | |
| \W | alle Nicht-Wortzeichen | |
| \n | Zeilenumbruch | |
| \t | Tabulator | |
| \r | Carriage Return | |
| \xYY | definiert das Zeichen mit hexadezimalem Zeichencode YY | |
| \YYY | steht für das Zeichen mit oktalen Zeichencode YYY |
Metazeichen verändern die Bedeutung von normalen Zeichen
Steht ^ am Anfang einer Zeichenmenge, so wird diese Menge negiert
– definiert einen Bereich in Zeichenmengen.
Quantifier
Quantifier geben die maximale, minimale oder genaue Anzahl von Wiederholungen an und beziehen sich auf den direkt vorher stehenden Ausdruck.
Quantifier dienen dabei der Abkürzung der Schreibweise.
| * | Allquantor, Vorkommen des Zeichens beliebig oft | a* |
| + | Existenzquantor, Ausdruck kommt mindestens einmal vor | a+ |
| ? | Genau einmal oder kein Vorkommen | ab?a |
| {n} | Genau n- maliges Vorkommen | a{5} |
| {n,} | Mindestens n- maliges Vorkommen | a{2,} |
| {,m} | Maximal m- maliges Vorkommen | a{,3} |
| {n,m} | Mindestens n- maliges, maximal m- maliges Vorkommen | a{1,6} |
Quantifier versuchen auf die größtmögliche Zeichenfolge zu passen, das heißt dass der Ausdruck
(.b)* in absbgbhb
nur einmal gefunden wird.
Die Abhilfe dafür ist: (.b)*?
Damit wird nur der kürzeste passende Teilstring gefunden und liefert:
ab, sb, gb, hb als Ergebnis zurück.
Modifier
Werden verwendet um das Matchingverhalten zu verändern.
Optionale Parameter können bei der Erstellung einer Instanz von Regex angegeben werden, alternativ auch am Ende des regulären Ausdruckes.
| i | case- insensitive Auswertung, Groß- und Kleinschreibung wird nicht beachtet |
| m | Multiline, ^ und $ beziehen sich auf Beginn und Ende einer Zeile (anstatt auf die Zeichenkette) |
| s | Singleline, “.“ bezieht sich auf alle Zeichen (anstatt auf alle außer \n) |
Namespace System.Text.RegularExpressions
Der Namespace System.Text.RegularExpressions besteht aus folgenden Klassen:
– RegEx
– Capture/CaptureCollection
– Group/GroupCollection
– Match/MatchCollection
– RegexCompilationInfo
Und außerdem noch:
– Enumeration RegexOptions
– Delegate MatchEvaluator
RegEx dient zum Erzeugen und zum Überprüfen von regulären Ausdrücken.
Methoden:
| IsMatch(strString) | liefert true/false |
| Match(strString) | liefert ein Match |
| Matches(strString) | liefert eine MatchCollection |
| Replace(erster, zweiter) | ersetzt Vorkommen von erster durch zweiter |
| Split(strString) | trennt strString zwischen den Fundstellen des regulären Ausdrucks |
Beispiele
Beispiel zur Erzeugung
public bool RegexBeispiel() {
//Teststring erzeugen
string myString ="lalala";
//regulären Ausdruck erstellen
Regex r = new Regex("(la)+");
//Teststring überprüfen
return r.IsMatch(myString);
}
Beispiele für Replace:
//Wandelt alle a in A um
public string nurGrosseA(string input) {
return Regex.Replace(input,"a","A");
}
//Entfernt alle Buchstaben aus den Inputstring und
//lässt nur Zahlen über.
public string nurZahlen(string input) {
return Regex.Replace(input, [a-z],"");
}
Beispiel für MatchCollection
//Neues Objekt erzeugen
Regex r = new Regex("abc");
//Ein Match suchen
MatchCollection mc = r.Matches("123abc456abcd");
//Wenn ein Match gefunden wurde, dann Details ausgeben
for (int i=0; i < mc.Count; i++){
Console.WriteLine("Treffer an Position: " + mc[i].Index);
Console.WriteLine("Gefunden wurde: " + mc[i].Value);
}
Ausgabe:
Treffer an Position: 3
Gefunden wurde: abc
Treffer an Position: 9
Gefunden wurde: abc
Beispiel zum überprüfen einer eMail-Adresse
public bool IsEmail(string email){
string pattern = @"^(([A-Za-z0-9]+_+)|([A-Za-z0-9]+\-+)|" +
"([A-Za-z0-9]+\.+)|([A-Za-z0-9]+\++))*" +
"[A-Za-z0-9\.]+@((\w+\-+)|(\w+\.))*" +
"\w{1,63}\.[a-zA-Z]{2,6}$";
Regex RegEx = new Regex(pattern);
return RegEx.IsMatch(email);
}
Hinweis:
Der Ausdruck [A-Za-z0-9] ist die Kurzschreibweise für [A-Z][a-z][0-9]
Update 01.12.2009
Der Kosmonaut hat das Tool Regulator (http://sourceforge.net/projects/regulator/) ja bereits in einem Kommentar empfohlen.
Ich habe jetzt ein weiteres Werkzeug zum interaktiven Erstellen von regulären Ausdrücken entdeckt: Regulazy
