Die Programmiersprache Ruby

Blog| Forum| Wiki  

Ein Regulärer Ausdruck (kurz auch Regexp, RegExp, Regexe oder Regex von engl. Regular Expression) ist im Prinzip ein Muster, das man auf einen String anwenden kann. Ruby bietet eine Literalmöglichkeit, um Reguläre Ausrücke zu erzeugen:

1
2
3
4
5
6
7
/../ #, wobei .. f��r irgendeinen Audruck steht. 
#Au��erdem kann man das auch so machen:
Regexp.new("..")
#F��r Ausdr��cke mit vielen Slashes / eignet sich au��erdem diese Syntax: 
%r(..) #, wobei ( und ) durch ein beliebiges, nichtalphabetisches Zeichen ersetzt werden d��rfen, z.B. 
%r!..! #oder
%r<..>

Die Regulären Ausdrücke von Ruby sind weitestgehend mit denen von Perl identisch.

Inhaltsverzeichnis

Grundlegendes

Ein Regulärer Ausdruck kann mithilfe der Methode String#match auf Strings angewandt werden. Daneben gibt es noch diverse weitere Methoden, die Reguläre Ausfrücke akzeptieren, beispielsweise String#sub. Darüberhinaus kann die Operatormethode String#=~ genutzt werden, um zu prüfen, ob ein Muster auf einen String anwendbar ist.

Syntax

Wie schon oben genannt, kann ein Regulärer Ausdruck über ein Literal definiert werden. In diesem Ausdruck dürfen verschiedene Musterelemente vorkommen. Die Zeichen a-z und A-Z sowie Zahlen haben so geschrieben keine Sonderbedeutung.

1
2
3
string = "Hello"
puts string =~ /el/ #=> 1
puts string =~ /xyz/ #=> nil

Gruppen

In einem Regulären Ausdruck können mithilfe von Klammern ( und ) Gruppen erstellt werden, die ihre Ergebnisse an die Globalen Variablen $1 bis $n (n ist die Anzahl der zuweisenden Klammern in einem Regulären Ausdruck) speichert. Ferner gruppieren Klammern einen Ausdruck so, dass er wie ein einziges Zeichen wirkt. Ein Beispiel zu Letzterem findet sich im nächsten Abschnitt. Nicht-zuweisende, also nur-gruppierende Klammern, lassen sich mit dieser Syntax allein nicht erzeugen.

1
2
3
4
5
string = "hello"
string.match(/(el)/)
puts $1 #=> el
#Au��erdem gibt String#match ein MatchData-Objekt zur��ck, das diese Werte beinhaltet: 
puts string.match(/(el)/)[1] #=> el

Quantoren

In einem Regulären Ausdruck dürfen sogenannte Quantoren vorkommen. Sie spezifizieren, wie oft ein vorangegangener Ausdruck an dieser Stelle wiederholt werden soll. Um dies zu verdeutlichen, mache ich mir die bereits im vorigen Abschnitt genannte Eigenschaft der Gruppierung von Klammern zu Nutze. $& oder das Element 0 des MatchData-Objekts beinhalten übrigens den gesamten String, auf den sich das Muster anwenden lies.

1
2
3
4
5
string = "abcabcXXabc"
#Auf herk��mmliche Art und Weise: 
puts string.match(/abcabc/)[0] #=> abcabc
#Mit Quantoren
puts string.match(/(abc)+/)[0] #=> abcabc

Mögliche Quantoren in Ruby sind:

  • +
    • Das vorige Zeichen muss mindestens einmal vorkommen, dann aber beliebig oft.
  • *
    • Das vorige Zeichen muss nicht vorkommen, wenn, dann aber beliebig oft.
  •  ?
    • Das vorherige Zeichen muss nicht vorkommen, darf aber auch höchstens nur einmal vorhanden sein.
  • {n}
    • Das vorangegangene Zeichen muss exakt n-mal vorkommen.
  • {m,n}
    • Das vorige Zeichen muss mindestens m-mal vorkommen, höchstens aber n-mal. Erlaubt auch die Varianten {,n} um nur eine Höchstanzahl, und {m,} um nur eine Mindestanzahl anzugeben.

Diese Quantoren versuchen immer, den größtmöglichen String zu finden, man nennt sie daher gierig. Die nicht gierigen Quantoren machen das Gleiche wie ihre gierigen Pendanten, aber veruschen im Gegensatz zu ihnen immer den kleinstmöglichen String zu finden. Sie sind durch ein ? gekennzeichnet, beispielsweise +?.

Anker

  • Das Zeichen ^ passt immer auf einen Zeilenanfang.
  • Das Zeichen $ passt immer auf ein Zeilenende.
  • Das Zeichen \A passt immer auf den Stringanfang.
  • Das Zeichen \Z passt immer auf das Stringende.

Modifikatoren

Es gibt einige Modifikatoren, die, an einen Regulären Ausdruck angehangen, die Arbeitsweise von diesem beeinflussen. Sie werden angewandt, indem sie bei der Literalschreibweise hinter den abschließenden Schrägstrich / gesetzt werden.

  • m: (multiline) Mehrzeilge Anwendung des Ausdrucks. Das Spezialzeichen . und die Gruppe \s beinhalten ab jetzt Newlines.
  • i: (ignore-case) Missachtung von Groß- und Kleinschreibung.
  • x: (extended mode): Erweiterter Modus, der mehrzeilige Ausdrücke mit Kommentaren erlaubt.
1
2
3
4
5
puts "ABC" =~ /abc/ #=> nil
puts "ABC" =~ /abc/i #=> 0

puts "ab\nc" =~ /ab.c/ #=> nil
puts "ab\nc" =~ /ab.c/m #=> 0

Zeichenklassen und Alternativen

Zeichen, die innerhalb von eckigen Klammern [ und ] stehen, beschreiben eine Zeichenklasse. An der angegebenen Stelle darf nur ein Zeichen der in der Klammer notierten vorkommen. Alternativen ermöglichen dies mit größeren Zeichenmengen, sie werden durch den Balken | getrennt.

1
2
3
4
5
6
name = "Mathias"
puts name.match(/^Ma(t|tt)hias$/)[0] #=> Mathias
string = "Ein Zeichen zwischen a und e: d"
puts string.match(/: [abcde]/)[0] #=> : d
#Verk��rzt:
puts string.match(/: [a-e]/)[0] #=> : d

Folgende Zeichenklassen stehen bereits vordefiniert zur Verfügung:

  • \d = [0-9]
  • \D = [^0-9]
  • \w = [a-zA-Z]
  • \W = [^a-ZA-Z]
  • \s = Leerzeichen, Tabulator und ähnlicher Whitespace
  • \S = Alles, was nicht in \s ist.

Steht ein ^ am Anfang einer Zeichenklasse, so wird ihre Bedeutung umgewandelt in: "Alles, was nicht in dieser Zeichenklasse vorkommt, ist erlaubt. "

Einfache und Erweiterte Reguläre Ausdrücke

Alles, was in diesem Artikel beschrieben wird, gehört zu den Einfachen Regulären Ausdrücken. Ruby bietet weit mehr Optionen, die allerdings den Rahmen dieses Artikels sprengen würden und strenggenommen auch nicht mehr zu den Regulären Ausdrücken gehören. Diese Erweiterten Regulären Ausdrücke werden exzellent von WoNáDo in seinen Regexp-Tutorials auf der Ruby-Mine erläutert.

Sonderzeichenreferenz

Eine kleine Zusammenfassung der Sonderzeichen Regulärer Ausdrücke in Ruby.

Zeichen Bedeutung
. Beliebiges Zeichen außer Newline.
() Gruppierende und zuweisende Klammer.
[] Beschreibt eine Zeichenklasse.
| Alternative.
^ Zeilenanfang-Anker. In Zeichenklassen wirkt er negierend.
$ Zeilenende-Anker.
? Etliche Bedeutungen, besonders in Erweiterten Regulären Ausdrücken. Als Quantor 0 oder 1 Vorkommen, nach Quantoren "genügsam machend".
/ Zeichenliteral, das einen Regulären Ausdruck begrenzt.
- Kürzende Schreibweise in Zeichenklassen.
+Quantor: 1 oder beliebig viele Vorkommen.
* Quantor: 0 oder beliebig viele Vorkommen.
: Spezieller Begrenzer in Erweiterten Regulären Ausdrücken.
\ Escape-Zeichen oder Beginn einer Sondersequenz wie \w. Ein Backslash neutralisiert die Bedeutung von Sonderzeichen, wenn er ihnen vorangestellt wird.
#{..}-Syntax Die bereits von Strings bekannte Substitutionssyntax. Fügt einen anderen Regulären Ausdruck oder einen String in den Ausdruck ein. Sonderzeichen werden nicht neutralisiert; siehe dazu die Methode Regexp.escape.

Globale Variablen

Jeder Musterabgleich mit Regulären Ausdrücken weist Globalen Variablen Werte zu. Diese globalen Variablen sind:

Variable Bedeutung
$& Alles, worauf das Muster gepasst hat.
$' Alles nach dem Muster.
$` Alles vor dem Muster.
$1..$n Zugriff auf die zuweisende Klammer n.
$~ Das gesamte MatchData-Objekt des Abgleichs.

Änderungen an Regulären Ausdrücken zu Ruby 1.9.1

Ein Wort genügt: Oniguruma. Rubys neue Regexp-Maschine bietet viele neue Möglichkeiten. Ich verweise an dieser Stelle erneut auf WoNáDos Regexp-Tutorials auf der Ruby-Mine (Link siehe unten). Er hat sich dort viel mit den Möglichkeiten beschäftigt.

Siehe auch