Reguläre Ausdrücke
"Was sind reguläre Ausdrücke?"
Ein regulärer Ausdruck (kurz Regexp von engl. regular expression) dient dazu, eine formale Sprache zu beschreiben--
"Okay, und jetzt bitte für Leute, die nicht Informatik studieren."
Eine formale Sprache ist - grob gesagt - eine Reihe von Regeln. Anhand dieser Regeln kann man sagen, ob eine Zeichenkette zur Sprache gehört oder nicht. Regexps sind eine Möglichkeit, eine solche Sprache zu beschreiben.
"Klingt nicht wirklich nützlich..."
Auf den ersten Blick vielleicht nicht. Andererseits kommt es recht häufig vor, daß man Zeichenketten mit Regeln zusammenbringt: Man will überprüfen, ob eine Zeichenkette ein bestimmtes Format hat oder beispielsweise alle Bilder aus einem HTML-Dokument entfernen.
Das geht mit Regexps sehr bequem: Man definiert eine Sprache und läßt den Computer sie mit der zu überprüfenden Zeicehnkette verrechnen. Nehmen wir mal das Beispiel der zu entfernen Bilder. Wir haben unseren Input:
Alle Bilder haben folgendes Format: <img[irgendeine Zeichenfolge]>. Also müssen wir eine Sprache definieren, die genau das beinhaltet und sonst nichts. Bei Regexps sieht das so aus (auf die Syntax gehe ich weiter unten ein):Code:<html>
<body>
<p>Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.<br>
LOL Text!<img src="http://domain.tld/pfad/datei.ext">LOL, Bilder!<img src="../lokaler/pfad/anderedatei.ext"></p>
</body>
</html>
/<img.*?>/
Aufgeschlüsselt haben wir folgendes:
- /<img.*?>/ - die Begrenzungszeichen. Die meisten Regexp-Implementierungen haben solche. Sie sagen, wo der Regexp anfängt und wo er aufhört; das ist wichtig zu wissen, da man Regexps auch Modifikatoren mitgeben kann
- /<img.*?>/ - Klartext. Jeder Text, der kein Steuerzeichen ist, wird so gesucht. In unserem Fall suchen wir also Text, wo am Anfang <img steht, dann irgendwas und dann >
- /<img.*?>/ - Ja, .*? bedeutet tatsächlich "irgendwas". Genauer gesagt steht der Punkt für ein beliebiges Zeichen, das Sternchen für beliebig viele Wiederholungen und das Fragezeichen dafür, das so wenig wie möglich erkannt werden soll
Das Fragezeichen ist wichtig, wie ich gleich zeige. BTW, dieser Regep tut so nichts, außer eine bestimmte Zeichenkette zu erkennen ("matchen"). Das Löschen müssen wir über eine geeignete Funktion selbst machen.
Sehen wir uns mal die Zeile mit den Bildern an, nachdem wir per Regexp die Bilder entfernt haben - und zwar einmal mit und einmal ohne Fragezeichen:
Der Regexp ohne Fragezeichen matcht alles vom ersten <img bis zum letzten >, weil Regexps von Natur aus gierig sind, d.h. sie versuchen, so viel wie möglich zu matchen.Code:/<img.*?>/
LOL Text!LOL, Bilder!</p>
/<img.*>/
LOL Text!
Der Regexp mit Fragezeichen hingegen hat eine Begrenzung: Das .* soll so wenige Zeichen erkennen wie möglich. Eswerden also nur so lange Zeichen verarbeitet, bis das nächste Zeichen ein > ist - sprich: Bis zum Ende des Tags.
Zu gierige Regexps können sehr interessante (= katastrophal falsche) Ergebnisse bringen, sind aber zum Glück einfach zu erkennen.
"Hm, die Dinger sind ja ziemlich mächtig... Aber sind sie auch lesbar?"
Ich zitiere einfach mal aus einem Skript, das mIRC-Logs verarbeitet. Der folgende Regexp matcht alle Zeilen, bei denen der Text in eckigen Klammern steht:
/(\[)(\d\d:\d\d)(])(\s+)(<)(\S+)(>)(\s+)(\[)([^\n\r]+?)(\])([^\n\r]*?)(.*)/U⁄
Noch Fragen?
"Ja, wie schreibt man die verdammten Dinger jetzt?"
Ah, die Syntax...
Zuerst einigen wir uns auf einige Konventionen. Und wenn ich sage "wir einigen uns" dann meine ich "ich lege sie fest und ihr müßt damit leben". Alle Regexps schreibe ich in Rot, den Text, auf den ein Regexp angewendet wird Grün und den gematchten Text Blau.
Das Rot ist schon der erste funktionierende Regexp. Er matcht - richtig - den String "Rot". Alle Zeichen, die keine Steuerzeichen sind, werden in Regexps als genau das genommen, was da steht.
Was sind also Steuerzeichen? Exakt folgende elf Zeichen: Die linke eckige Klammer [, den Backslash \, das Zirkumflex ^, das Dollarzeichen $, den Punkt ., den Querstrich |, das Fragezeichen ?, das Sternchen *, das Plus + und beide runde Klammern, ( und ). Diese Zeichen werden auch "Metazeichen" genannt, weil die meisten von ihnen für andere Zeichen stehen (wie beispielsweise das ., das ja für jedes Zeichen stehen kann).
Gruppen und Alternativen
Die runden Klammern (( und )) bieten euch die Möglichkeit, den Regexp in Gruppen zu unterteilen. Das ist sinnvoll, wenn ihr mit Funktionen arbeitet, die es erlauben, auf bestimmte Gruppen des Ergebnisses zuzugreifen, es kann aber auch in Verbindung mit Alternativen (siehe unten) nützlich sein. Die Klammern haben ansonsten keinen Einfluß auf den Regexp; Hallo und H(all)o tun das gleiche.
Der Querstrich (|) bietet euch die Möglichkeit, Alternativen einzubauen. Beispielsweise wollen wir mit einem Regexp die Zeichenketten RPG-Ring und RPG-Ringdom matchen. Der Regexp, der das tut ist RPG-(Ring|Kingdom).
Escapezeichen
Der Backslash (\) dient wie bei so vielen anderen Sprachen auch dazu, Sonderzeichen zu escapen. (Ja, Regexps sind eine Sprache, mit der man Sprachen beschreibt... Willkommen in der bunten Wunderwelt der Metasprachen.)
Wenn ich also Ich bin toll. matchen will, dann brauche ich diesen Regexp: Ich bin toll\.
So kann man auch Zeilenenden etc. beschreiben, wie man das von anderen sprachen kannt: \n ist ein Linefeed, \r ist ein Wagenrücklauf, \t ist ein Tab, \e ist ein Escape, \v ist ein vertikaler Tab. Achtung: Windows verwendet als Zeilenende \r\n, während *nix \n verwendet (OS X ist ein *nix).
Man kann sogar über Hexwerte beliebige Zeichen beschreiben: \x20 ist im ISO-8859-15-Zeichensatz das Leerzeichen. Wenn der verwendete Regexp-Dialekt Unicode beherrscht kann man über \uFFFF ein Unicode-Zeichen matchen, beispielsweise \u20A0 für das Eurozeichen.
Der Backslash kann sogar noch mehr: Über ihn kriegt man auch Zugriff auf kurze Charakterklassen. Um zu erklären, was das ist erkläre ich erst mal Charakterklassen im Allgmeinen.
Charakterklassen
Die linke eckige Klammer ([) dient dazu, eine Charakterklasse einzuleiten. Charakterklassen bieten uns eine Möglichkeit, für ein Zeichen mehrere Möglichkeiten zum Matchen zu haben. Beispielsweise wollt ihr einen Regexp schreiben, der eine beliebige Ziffer matcht. Kein Problem, wir schreiben einfach (1|2|3|4|5|6|7|8|9|0). Das ist nur ein bißchen lang.
Alle Zeichen zwischen den eckigen Klammern (mit bestimtmen Ausnahmen) werden als Alternativen für das Matchen eines Zeichens verwendet. Wir können also schreiben: [1234567890]
Immer noch lang, oder? Zum Glück können Charakterklassen ganze Reihen von Zeichen abdecken. Wir schreiben <Startzeichen>-<Endzeichen>, in unserem Fall also: [0-9]
Ist das kurz oder was?
Als Reihen gehen alle Zahlen (0-9), alle Kleinbuchstaben (a-z) und alle Großbuchstaben (A-Z) sowie alle Untermengen (beispielsweise a-f). Man kann auch lustig kombinieren: [2-7a-nJ-Lx] matcht alle Ziffern zwischen 2 und 7, alle Großbuchstaben zwischen J und L, alle Kleinbuchstaben zwischen a und n sowie den Kleinbuchstaben x.
Die Reihenfolge spielt keine Rolle.
Aber es geht noch weiter. Was, wenn man alle Zeichen matchen will, die keine Zahl sind? Ganz einfach, man negiert die Charakterklasse. Das tut man, indem man als erstes Zeichen ein Zirkumflex (^) einfügt. (Achtung: Außerhalb von Charakterklassen hat das Zirkumflex eine ganz andere Bedeutung!) Wir matchen also alles außer Zahlen mit [^0-9].
Wenn das Zirkumflex an einer anderen Stelle als der ersten in der Charakterklasse steht hat es keine Sonderfunktion und wird als ganz normales Zirkumflex gewertet.
In Charakterklassen haben fast alle normalen Metazeichen keine Bedeutung und werden nicht ausgewertet. Es gelten nur das Zirkumflex (^, negiert die Klasse), das Minus (-, dient zur Definition einer Reihe von Zeichen), der Backslash (\, dient als Escapezeichen) und die rechte eckige Klammer (], schließt die Charakterklasse). Man kann übrigens normale Metazeichen in Charakterklassen escapen ([\*]), aber man muß es nicht.
Kurze Charakterklassen
Als ich gesagt habe, daß [0-9] wirklich kurz ist, habe ich gelogen. Man kann genau das gleiche auch mit \d ausdrücken. \d ist eine Kurzform für [0-9]. Es gibt da einige Kurzformen:
- \d - matcht alle Ziffern. Entspricht [0-9]
- \w - matcht alle Buchstaben und manchmal noch mehr (beispielsweise wird oft auch _ gematcht). Entspricht mindestens [a-zA-Z]
- \s - matcht Whitespace. Was gematcht wird hängt vom Regexp-Dialekt ab. Entspricht mindestens [ ]
- . - ja, der Punkt ist auch eine kurze Charakterklasse. Er matcht alles bis auf Zeilenumbrüche: [^\n]. Die meisten Regexp-Dialekte haben aber auch eine Option, mit der der Punkt sogar Zeilenumbrüche matcht
Man kann diese Kurzformen negieren, indem man sie groß schreibt: \D entspricht [^\d], \W entspricht [^\w] und \S entspricht [^\s].
Man kann diese Kurzformen in Charakterklassen verbauen (beispielsweise könnte man Hexzahlen mit [\da-fA-F].* matchen), man muß aber mit den negierten Kurzformen aufpassen: [\D\S] matcht jedes Zeichen, das entweder keine Ziffer oder kein Whitespace ist. Ziffern sind kein Whitespace und Whitespace ist keine Ziffer, also wird jedes Zeichen gematcht. [\D\S] und [^\d\s] sind nicht äquivalent!
Wiederholungen und optionale Zeichen
Ich habe ja schon erwähnt, daß * für eine beliebige Wiederholung steht. Das stimmt nicht so ganz. * bedeutet, daß das letzte Zeichen null mal oder öfter vorkommt.
Für Zeichen, die mindestens einmal vorkommen sollen gibt es + (das Zeichen kommt einmal oder öfter vor).
Aber was ist, wenn ein Zeichen nicht oder einmal vorkommen soll? Dafür gibt es ?. Achtung: ? bedeutet etwas anderes, wenn es nach einem der hier genannten Metazeichen steht. Dazu gleich mehr.
Natürlich kann man auch sagen, daß ein Zeichen n mal wiederholt werden soll ({n}). Man kann auch sagen, daß man m bis n Wiederholungen will ({m, n}). n oder mehr Wiederholungen gehen auch ({n,}).
Nehmen wir den String Klaatu Verata Niktu. Wir setzen mal ein paar Regexps auf ihn an: (Anmerkung: Es sind immer mehrere Stellen markiert. die werden nicht auf einmal gematcht, das sind nur alle Stellen an denen gematcht werden könnte.)
a*t matcht Klaatu Verata Niktu
a+t matcht Klaatu Verata Niktu
a?t matcht Klaatu Verata Niktu
a{2,}t matcht Klaatu Verata Niktu
Man kann übrigens neben Zeichen auch Gruppen vervielfachen. l(ol)* ist also in der Lage, redundantes lautes Gelächter zu matchen. Nett, oder?
Gieriges und ungieriges Matchen
Ich habe oben schon erwähnt, daß das Fragezeichen eine weitere Funktion hat und ganz oben steht was von wegen "Regexps sind gierig". Regexps wollen immer so viel matchen wie möglich, was oft unpraktisch ist, wie ich oben schon demonstriert habe. (Eine Erklärung für dieses Verhalten gibt es unter [1])
Wenn man einem Wiederholungsmetazeichen ein ? anhängt wird es ungierig.
Zum Vergleich untersuchen wir wieder Klaatu Verata Niktu.
a.*t matcht Klaatu Verata Niktu
a.*?t matcht Klaatu Verata Niktu
Man kann das Fragezeichen hinter *, +, ?, {n, m} und {n,} packen - auch wenn es bei ? eher begrenzten Nutzen hat.
Anker
Was, wenn wir alle Strings matchen wollen, die mit "Foobar" anfangen, aber keine wo das Wort mittendrin vorkommt? In diesem Fall brauchen wir Anker. Anker beziehen sich nicht auf Zeichen(ketten) sondern auf Positionen.
^ matcht die Position vor dem ersten Zeichen. ^Foobar matcht also nur dann, wenn der untersuchte String mit "Foobar" anfängt.
$ macht das genaue Gegenteil: Es matcht die Position nach dem letzten Zeichen. In Klaatu Verata Niktu matcht Niktu$ das letzte Wort, Klaatu$ hingegen gar nicht.
Man kann mit Ankern auch Matches mit der Länge 0 erzeugen, was sinnvoll ist, wenn beispielsweise ein leerer String erkannt werden soll oder wenn man in einen String etwas einfügen will.
Es gibt übrigens noch mehr Anker, aber das hier sind wohl die wichtigsten.
Regexps haben noch mehr Eigenschaften, auf die ich hier nicht näher eingehe, beispielsweise Rückreferenzen, Lookaround, einige Anker und die Optionen. Dieser "kleine" Artikel sollte aber einen groben Überblick über das Thema geben und genug Informationen beinhalten, daß man anfangen kann, sich in Regexps einzuarbeiten.
Regexps sind kryptisch, aber sie werden von vielen Sprachen und Programmen unterstützt und sind extrem mächtig. Wenn man Strings manipuliert können Regexps einem viel Arbeit sparen.
In dem Sinne: Viel Spaß beim Matchen.
PS: Den Artikel zu getsize habe ich gerade verlegt :/
Lektüre:
[1] http://regular-expressions.info/ - enthält nützliche Informationen zu regulären Ausdrücken, beispielsweise Einblick in die Funktionsweise einer Regexp-Engine und eine Referenz
getsize
getsize ist aus der typischen Open Source-Grundhaltung heraus entstanden: Etwas nervt mich, also schreibe ich ein Programm, das es korrigiert.
In meinem Fall war das Problem folgendes: Unter Linux kann man eine Reihe nützlicher Informationen über ein Programm kriegen, indem man stat <Dateiname> aufruft. Ich benutze das oft, um Dateigrößen zu bestimmen. Unter OS X gibt es stat aber nicht, also mußte ein Ersatz her. Und da ich versuche, neue Shellskripte in Ruby zu schreiben, schrieb ich es in Ruby. Wow.
Im Prinzip ist getsize recht einfach: Es geht die Liste der Dateien durch, holt die jeweiligen Dateigrößen und gibt sie hübsch formatiert aus. Was ist an dem Kram also interessant?
- Es werwendet getopt, um Parameter zu interpretieren
- Es formatiert die Dateigrößen mit einem recht großen Grad der Konfigurierbarkeit
- Es war die einzige Einsendung :p
Sehen wir uns mal den Teil mit getopt an:
Im ersten Teil des Codes stellen wir sicher, daß die Hilfe angezeigt wird, wenn keine Parameter übergeben wurden, und parsen die Parameter. GetoptLong geht alle Parameter durch und sieht nach, ob sie einer der Optionen in der Liste entsprechen. Wenn das der Fall ist wird der Parameter aus der Parameterliste entfernt und in ein Array getan, das GetoptLong zurückgibt. Die Syntax des GetoptLong-Aufrufs dürfte relativ selbsterklärend sein.Code:# Dieses Skript verwendet getopt
require 'getoptlong'
[...]
# Wenn keine Parameter gegeben sind wird die Hilfe angezeigt
if (ARGV.size == 0) then ARGV = [ "--help" ] end
# getopt holt die Optionen aus der Parameterliste
opts = GetoptLong.new(
[ "--verbose", "-v", "-h", GetoptLong::NO_ARGUMENT ],
[ "--prefix", "-p", GetoptLong::OPTIONAL_ARGUMENT ],
[ "--help", GetoptLong::NO_ARGUMENT ],
[ "--si", "--use-si-numbers", "-s", GetoptLong::NO_ARGUMENT ],
[ "--precision", "-c", GetoptLong::OPTIONAL_ARGUMENT ],
[ "--no-invalid", "-n", GetoptLong::NO_ARGUMENT ]
)
# Und hier verarbeiten wir die Optionen
opts.each do |opt, xarg|
if (opt == "--si") then bSI = true # SI-Einheiten verwenden?
elsif (opt == "--no-invalid") then bNoInvalid = true # Fehlende Dateien überspringen?
elsif (opt == "--verbose") then bVerbose = true # Lesbaren Output erzeugen?
elsif (opt == "--precision") then # Anzahl der Nachkommastellen festlegen
intPrecision = xarg.to_i
if (intPrecision > 10) then intPrecision = 10 end # Mehr als zehn Stellen gehen nicht
elsif (opt == "--prefix") then # Präfix festlegen
xarg = xarg.upcase # Wenn kein fester Präfix angegeben wird
if ((xarg != "B") && # berechnet das Skript für jede Datei den
(xarg != "K") && # jeweils angemessenen Präfix
(xarg != "M") &&
(xarg != "G") &&
(xarg != "T")) then xarg = "" # Das tut es auch, wenn kein gültiger Präfix
end # angegeben wurde
strPrefix_arg = xarg
elsif (opt == "--help") then # Die Hilfe. Muß nicht weiter kommentiert werden
# Eine Menge Output
exit
end
end
Nachdem wir die Optionen isoliert haben gehen wir sie in der each-Schleife durch. Die beiden Variablen, die wir dem Schleifeninhalt übergeben, enthalten den Optionsnamen und (falls vorhanden) das Optionsargument - wenn also beispielsweise dem Skript der Parameter "-c9" übergeben würde, würde opt "-c" und xarg "9" sein.
Der Rest des Codes ist nicht fürchterlich eindrucksvoll - es wird einfach nachgesehen, was der User angegeben hat und entsprechend die Dateigröße umgerechnet. Wenn der User keinen Präfix angegeben hat wird der jeweils passende berechnet (es wird der kleinste Präfix genommen, bei dem der Output unter 1000, bzw. 1024 liegt), ansonsten wird der angegebene verwendet. Wenn man mit SI-Einheiten rechnet wird durch 1000 geteilt, sonst durch 1024... Und so weiter. Standardkram.
