class Regexp

Ein regulärer Ausdruck (auch regexp genannt) ist ein Abgleichmuster (auch einfach Muster genannt).

Eine gängige Notation für eine Regexp verwendet einschließende Schrägstriche

/foo/

Eine Regexp kann auf einen Zielstring angewendet werden; Der Teil des Strings (falls vorhanden), der dem Muster entspricht, wird als Treffer bezeichnet und kann als übereinstimmend bezeichnet werden

re = /red/
re.match?('redirect') # => true   # Match at beginning of target.
re.match?('bored')    # => true   # Match at end of target.
re.match?('credit')   # => true   # Match within target.
re.match?('foo')      # => false  # No match.

Verwendung von Regexp

Eine Regexp kann verwendet werden

Um Teilstrings basierend auf einem gegebenen Muster zu extrahieren

re = /foo/              # => /foo/
re.match('food')        # => #<MatchData "foo">
re.match('good')        # => nil

Siehe Abschnitte Methode match und Operator =~.

Um zu bestimmen, ob ein String einem gegebenen Muster entspricht
```
re.match?('food') # => true
re.match?('good') # => false
```
Siehe Abschnitt Methode match?.
Als Argument für Aufrufe bestimmter Methoden in anderen Klassen und Modulen; die meisten solchen Methoden akzeptieren ein Argument, das entweder ein String oder die (viel mächtigere) Regexp sein kann.

Siehe Regexp-Methoden.

Regexp-Objekte

Ein Regexp-Objekt hat

Eine Quelle; siehe Quellen.
Mehrere Modi; siehe Modi.
Ein Timeout; siehe Timeouts.
Eine Kodierung; siehe Kodierungen.

Erstellen einer Regexp

Ein regulärer Ausdruck kann erstellt werden mit

Einem Regexp-Literal mit Schrägstrichen (siehe Regexp-Literale)
```
# This is a very common usage.
/foo/ # => /foo/
```

Einem %r-Regexp-Literal (siehe %r: Regexp-Literale)

# Same delimiter character at beginning and end;
# useful for avoiding escaping characters
%r/name\/value pair/ # => /name\/value pair/
%r:name/value pair:  # => /name\/value pair/
%r|name/value pair|  # => /name\/value pair/

# Certain "paired" characters can be delimiters.
%r[foo] # => /foo/
%r{foo} # => /foo/
%r(foo) # => /foo/
%r<foo> # => /foo/

Methode Regexp.new.

Methode `match`

Jede der Methoden Regexp#match, String#match und Symbol#match gibt ein MatchData-Objekt zurück, wenn ein Treffer gefunden wurde, ansonsten nil; jede setzt auch globale Variablen

'food'.match(/foo/) # => #<MatchData "foo">
'food'.match(/bar/) # => nil

Operator `=~`

Jeder der Operatoren Regexp#=~, String#=~ und Symbol#=~ gibt einen ganzzahligen Offset zurück, wenn ein Treffer gefunden wurde, ansonsten nil; jeder setzt auch globale Variablen

/bar/ =~ 'foo bar' # => 4
'foo bar' =~ /bar/ # => 4
/baz/ =~ 'foo bar' # => nil

Methode `match?`

Jede der Methoden Regexp#match?, String#match? und Symbol#match? gibt true zurück, wenn ein Treffer gefunden wurde, ansonsten false; keine setzt globale Variablen

'food'.match?(/foo/) # => true
'food'.match?(/bar/) # => false

Globale Variablen

Bestimmte regexp-orientierte Methoden weisen globalen Variablen Werte zu

match: siehe Methode match.
=~: siehe Operator =~.

Die betroffenen globalen Variablen sind

$~: Gibt ein MatchData-Objekt oder nil zurück.
$&: Gibt den übereinstimmenden Teil des Strings oder nil zurück.
$`: Gibt den Teil des Strings links vom Treffer oder nil zurück.
$': Gibt den Teil des Strings rechts vom Treffer oder nil zurück.
$+: Gibt die zuletzt übereinstimmende Gruppe oder nil zurück.
$1, $2, usw.: Gibt die erste, zweite usw. übereinstimmende Gruppe oder nil zurück. Beachten Sie, dass $0 ganz anders ist; es gibt den Namen des aktuell ausgeführten Programms zurück.

Diese Variablen, außer $~, sind Kurzformen für Methoden von $~. Siehe Globale Variablen-Äquivalenz bei MatchData.

Beispiele

# Matched string, but no matched groups.
'foo bar bar baz'.match('bar')
$~ # => #<MatchData "bar">
$& # => "bar"
$` # => "foo "
$' # => " bar baz"
$+ # => nil
$1 # => nil

# Matched groups.
/s(\w{2}).*(c)/.match('haystack')
$~ # => #<MatchData "stac" 1:"ta" 2:"c">
$& # => "stac"
$` # => "hay"
$' # => "k"
$+ # => "c"
$1 # => "ta"
$2 # => "c"
$3 # => nil

# No match.
'foo'.match('bar')
$~ # => nil
$& # => nil
$` # => nil
$' # => nil
$+ # => nil
$1 # => nil

Beachten Sie, dass Regexp#match?, String#match? und Symbol#match? keine globalen Variablen setzen.

Quellen

Wie oben gezeigt, verwendet die einfachste Regexp einen literalen Ausdruck als Quelle

re = /foo/              # => /foo/
re.match('food')        # => #<MatchData "foo">
re.match('good')        # => nil

Eine reichhaltige Sammlung verfügbarer Unterdrücke verleiht der Regexp große Macht und Flexibilität

Sonderzeichen

Regexp-Sonderzeichen, genannt Metazeichen, haben in bestimmten Kontexten besondere Bedeutungen; je nach Kontext sind dies manchmal Metazeichen

. ? - + * ^ \ | $ ( ) [ ] { }

Um ein Metazeichen buchstäblich abzugleichen, maskieren Sie es mit einem Backslash

# Matches one or more 'o' characters.
/o+/.match('foo')  # => #<MatchData "oo">
# Would match 'o+'.
/o\+/.match('foo') # => nil

Um einen Backslash buchstäblich abzugleichen, maskieren Sie ihn mit einem Backslash

/\./.match('\.')  # => #<MatchData ".">
/\\./.match('\.') # => #<MatchData "\\.">

Die Methode Regexp.escape gibt einen maskierten String zurück

Regexp.escape('.?-+*^\|$()[]{}')
# => "\\.\\?\\-\\+\\*\\^\\\\\\|\\$\\(\\)\\[\\]\\{\\}"

Quellenliterale

Das Quellenliteral verhält sich weitgehend wie ein doppelt Anführungszeichen enthaltender String; siehe Literale mit doppelten Anführungszeichen.

Insbesondere kann ein Quellenliteral interpolierte Ausdrücke enthalten

s = 'foo'         # => "foo"
/#{s}/            # => /foo/
/#{s.capitalize}/ # => /Foo/
/#{2 + 2}/        # => /4/

Es gibt Unterschiede zwischen einem gewöhnlichen String-Literal und einem Quellenliteral; siehe Kurzschreibzeichenklassen.

\s in einem gewöhnlichen String-Literal ist äquivalent zu einem Leerzeichen; in einem Quellenliteral ist es eine Kurzform für das Abgleichen eines Leerzeichens.
In einem gewöhnlichen String-Literal sind dies (unnötig) maskierte Zeichen; in einem Quellenliteral sind sie Kurzformen für verschiedene abzugleichende Zeichen
```
\w \W \d \D \h \H \S \R
```

Zeichenklassen

Eine Zeichenklasse ist durch eckige Klammern abgegrenzt; sie gibt an, dass bestimmte Zeichen an einer bestimmten Stelle im Zielstring übereinstimmen

# This character class will match any vowel.
re = /B[aeiou]rd/
re.match('Bird') # => #<MatchData "Bird">
re.match('Bard') # => #<MatchData "Bard">
re.match('Byrd') # => nil

Eine Zeichenklasse kann Bindestriche enthalten, um Zeichenbereiche anzugeben

# These regexps have the same effect.
/[abcdef]/.match('foo') # => #<MatchData "f">
/[a-f]/.match('foo')    # => #<MatchData "f">
/[a-cd-f]/.match('foo') # => #<MatchData "f">

Wenn das erste Zeichen einer Zeichenklasse ein Caret (^) ist, wird die Bedeutung der Klasse umgekehrt: Sie entspricht jedem Zeichen außer denen, die angegeben sind.

/[^a-eg-z]/.match('f') # => #<MatchData "f">

Eine Zeichenklasse kann eine andere Zeichenklasse enthalten. An sich ist dies nicht nützlich, da [a-z[0-9]] die gleiche Menge wie [a-z0-9] beschreibt.

Zeichenklassen unterstützen jedoch auch den Operator &&, der die Schnittmenge seiner Argumente durchführt. Die beiden können wie folgt kombiniert werden

/[a-w&&[^c-g]z]/ # ([a-w] AND ([^c-g] OR z))

Dies ist äquivalent zu

/[abh-w]/

Kurzschreibzeichenklassen

Jedes der folgenden Metazeichen dient als Kurzform für eine Zeichenklasse

/./: Gleicht jedem Zeichen außer einem Zeilenumbruch ab

/./.match('foo') # => #<MatchData "f">
/./.match("\n")  # => nil

/./m: Gleicht jedem Zeichen ab, einschließlich eines Zeilenumbruchs; siehe Mehrzeiliger Modus
```
/./m.match("\n") # => #<MatchData "\n">
```

/\w/: Gleicht einem Wortzeichen ab: äquivalent zu [a-zA-Z0-9_]

/\w/.match(' foo') # => #<MatchData "f">
/\w/.match(' _')   # => #<MatchData "_">
/\w/.match(' ')    # => nil

/\W/: Gleicht keinem Wortzeichen ab: äquivalent zu [^a-zA-Z0-9_]

/\W/.match(' ') # => #<MatchData " ">
/\W/.match('_') # => nil

/\d/: Gleicht einer Ziffer ab: äquivalent zu [0-9]

/\d/.match('THX1138') # => #<MatchData "1">
/\d/.match('foo')     # => nil

/\D/: Gleicht keiner Ziffer ab: äquivalent zu [^0-9]

/\D/.match('123Jump!') # => #<MatchData "J">
/\D/.match('123')      # => nil

/\h/: Gleicht einem Hexadezimalziffer ab: äquivalent zu [0-9a-fA-F]

/\h/.match('xyz fedcba9876543210') # => #<MatchData "f">
/\h/.match('xyz')                  # => nil

/\H/: Gleicht keiner Hexadezimalziffer ab: äquivalent zu [^0-9a-fA-F]

/\H/.match('fedcba9876543210xyz') # => #<MatchData "x">
/\H/.match('fedcba9876543210')    # => nil

/\s/: Gleicht einem Leerzeichen ab: äquivalent zu /[ \t\r\n\f\v]/

/\s/.match('foo bar') # => #<MatchData " ">
/\s/.match('foo')     # => nil

/\S/: Gleicht keinem Leerzeichen ab: äquivalent zu /[^ \t\r\n\f\v]/

/\S/.match(" \t\r\n\f\v foo") # => #<MatchData "f">
/\S/.match(" \t\r\n\f\v")     # => nil

/\R/: Gleicht plattformunabhängig einen Zeilenumbruch ab

/\R/.match("\r")     # => #<MatchData "\r">     # Carriage return (CR)
/\R/.match("\n")     # => #<MatchData "\n">     # Newline (LF)
/\R/.match("\f")     # => #<MatchData "\f">     # Formfeed (FF)
/\R/.match("\v")     # => #<MatchData "\v">     # Vertical tab (VT)
/\R/.match("\r\n")   # => #<MatchData "\r\n">   # CRLF
/\R/.match("\u0085") # => #<MatchData "\u0085"> # Next line (NEL)
/\R/.match("\u2028") # => #<MatchData "\u2028"> # Line separator (LSEP)
/\R/.match("\u2029") # => #<MatchData "\u2029"> # Paragraph separator (PSEP)

Anker

Ein Anker ist eine Metasekvens, die eine Null-Breiten-Position zwischen Zeichen im Zielstring abgleicht.

Für einen Unterausdruck ohne Anker kann der Abgleich an jeder Stelle im Zielstring beginnen

/real/.match('surrealist') # => #<MatchData "real">

Für einen Unterausdruck mit einem Anker muss der Abgleich am übereinstimmenden Anker beginnen.

Rand-Anker

Jeder dieser Anker gleicht eine Grenze ab

^: Gleicht den Anfang einer Zeile ab

/^bar/.match("foo\nbar") # => #<MatchData "bar">
/^ar/.match("foo\nbar")  # => nil

$: Gleicht das Ende einer Zeile ab

/bar$/.match("foo\nbar") # => #<MatchData "bar">
/ba$/.match("foo\nbar")  # => nil

\A: Gleicht den Anfang des Strings ab

/\Afoo/.match('foo bar')  # => #<MatchData "foo">
/\Afoo/.match(' foo bar') # => nil

\Z: Gleicht das Ende des Strings ab; wenn der String mit einem einzelnen Zeilenumbruch endet, entspricht er direkt vor dem endenden Zeilenumbruch

/foo\Z/.match('bar foo')     # => #<MatchData "foo">
/foo\Z/.match('foo bar')     # => nil
/foo\Z/.match("bar foo\n")   # => #<MatchData "foo">
/foo\Z/.match("bar foo\n\n") # => nil

\z: Gleicht das Ende des Strings ab

/foo\z/.match('bar foo')   # => #<MatchData "foo">
/foo\z/.match('foo bar')   # => nil
/foo\z/.match("bar foo\n") # => nil

\b: Gleicht eine Wortgrenze ab, wenn nicht innerhalb von Klammern; gleicht einen Backspace ("0x08") ab, wenn innerhalb von Klammern
```
/foo\b/.match('foo bar') # => #<MatchData "foo">
/foo\b/.match('foobar')  # => nil
```

\B: Gleicht keine Wortgrenze ab

/foo\B/.match('foobar')  # => #<MatchData "foo">
/foo\B/.match('foo bar') # => nil

\G: Gleicht die erste Übereinstimmungsposition ab

In Methoden wie String#gsub und String#scan ändert er sich bei jeder Iteration. Er gleicht zunächst den Anfang des Subjekts ab und gleicht in jeder folgenden Iteration dort ab, wo der letzte Treffer endete.
```
"    a b c".gsub(/ /, '_')   # => "____a_b_c"
"    a b c".gsub(/\G /, '_') # => "____a b c"
```
In Methoden wie Regexp#match und String#match, die einen optionalen Offset annehmen, gleicht er dort ab, wo die Suche beginnt.
```
"hello, world".match(/,/, 3)   # => #<MatchData ",">
"hello, world".match(/\G,/, 3) # => nil
```

Lookaround-Anker

Lookahead-Anker

(?=pat): Positive Lookahead-Assertion: stellt sicher, dass die folgenden Zeichen pat abgleichen, aber schließt diese Zeichen nicht in den übereinstimmenden Teilstring ein.
(?!pat): Negative Lookahead-Assertion: stellt sicher, dass die folgenden Zeichen nicht pat abgleichen, aber schließt diese Zeichen nicht in den übereinstimmenden Teilstring ein.

Lookbehind-Anker

(?<=pat): Positive Lookbehind-Assertion: stellt sicher, dass die vorhergehenden Zeichen pat abgleichen, aber schließt diese Zeichen nicht in den übereinstimmenden Teilstring ein.
(?<!pat): Negative Lookbehind-Assertion: stellt sicher, dass die vorhergehenden Zeichen nicht pat abgleichen, aber schließt diese Zeichen nicht in den übereinstimmenden Teilstring ein.

Das folgende Muster verwendet positives Lookahead und positives Lookbehind, um Text innerhalb von …-Tags abzugleichen, ohne die Tags in den Treffer einzuschließen

/(?<=<b>)\w+(?=<\/b>)/.match("Fortune favors the <b>bold</b>.")
# => #<MatchData "bold">

Das Muster im Lookbehind muss eine feste Breite haben. Aber Top-Level-Alternativen können unterschiedliche Längen haben. z. B. (?<=a|bc) ist OK. (?<=aaa(?:b|cd)) ist nicht erlaubt.

Match-Reset-Anker

\K: Match-Reset: Der übereinstimmende Inhalt, der \K in der Regexp vorausgeht, wird aus dem Ergebnis ausgeschlossen. Zum Beispiel sind die folgenden beiden Regexps fast äquivalent
```
/ab\Kc/.match('abc')    # => #<MatchData "c">
/(?<=ab)c/.match('abc') # => #<MatchData "c">
```
Diese gleichen den gleichen String ab und $& ist gleich 'c', während die übereinstimmende Position unterschiedlich ist.

Ebenso verhalten sich die folgenden beiden Regexps
```
/(a)\K(b)\Kc/
/(?<=(?<=(a))(b))c/
```

Alternation

Das vertikale Balken-Metazeichen (|) kann innerhalb von Klammern verwendet werden, um Alternation auszudrücken: zwei oder mehr Unterausdrücke, von denen jeder den Zielstring abgleichen kann.

Zwei Alternativen

re = /(a|b)/
re.match('foo') # => nil
re.match('bar') # => #<MatchData "b" 1:"b">

Vier Alternativen

re = /(a|b|c|d)/
re.match('shazam') # => #<MatchData "a" 1:"a">
re.match('cold')   # => #<MatchData "c" 1:"c">

Jede Alternative ist ein Unterausdruck und kann aus anderen Unterausdrücken bestehen

re = /([a-c]|[x-z])/
re.match('bar') # => #<MatchData "b" 1:"b">
re.match('ooz') # => #<MatchData "z" 1:"z">

Die Methode Regexp.union bietet eine bequeme Möglichkeit, eine Regexp mit Alternativen zu erstellen.

Quantifizierer

Eine einfache Regexp gleicht ein Zeichen ab

/\w/.match('Hello')  # => #<MatchData "H">

Ein hinzugefügter Quantifizierer gibt an, wie viele Übereinstimmungen erforderlich oder zulässig sind

* - Gleicht null- oder mehrmals ab

/\w*/.match('')
# => #<MatchData "">
/\w*/.match('x')
# => #<MatchData "x">
/\w*/.match('xyz')
# => #<MatchData "xyz">

+ - Gleicht ein- oder mehrmals ab

/\w+/.match('')    # => nil
/\w+/.match('x')   # => #<MatchData "x">
/\w+/.match('xyz') # => #<MatchData "xyz">

? - Gleicht null- oder einmal ab

/\w?/.match('')    # => #<MatchData "">
/\w?/.match('x')   # => #<MatchData "x">
/\w?/.match('xyz') # => #<MatchData "x">

{n} - Gleicht genau n Mal ab

/\w{2}/.match('')    # => nil
/\w{2}/.match('x')   # => nil
/\w{2}/.match('xyz') # => #<MatchData "xy">

{min,} - Gleicht min oder mehr Mal ab

/\w{2,}/.match('')    # => nil
/\w{2,}/.match('x')   # => nil
/\w{2,}/.match('xy')  # => #<MatchData "xy">
/\w{2,}/.match('xyz') # => #<MatchData "xyz">

{,max} - Gleicht max oder weniger Mal ab

/\w{,2}/.match('')    # => #<MatchData "">
/\w{,2}/.match('x')   # => #<MatchData "x">
/\w{,2}/.match('xyz') # => #<MatchData "xy">

{min,max} - Gleicht mindestens min Mal und höchstens max Mal ab

/\w{1,2}/.match('')    # => nil
/\w{1,2}/.match('x')   # => #<MatchData "x">
/\w{1,2}/.match('xyz') # => #<MatchData "xy">

Gieriges, Lässiges oder Besessener Abgleich

Quantifizierer-Abgleiche können gierig, lässig oder besessener sein

Beim gierigen Abgleich werden so viele Vorkommen wie möglich abgeglichen, während der Gesamt-Abgleich weiterhin erfolgreich ist. Gierige Quantifizierer: *, +, ?, {min, max} und seine Varianten.
Beim lässigen Abgleich werden die minimale Anzahl von Vorkommen abgeglichen. Lässige Quantifizierer: *?, +?, ??, {min, max}? und seine Varianten.
Beim besessenen Abgleich gibt es nach einem gefundenen Treffer kein Backtracking; dieser Treffer wird beibehalten, selbst wenn er den Gesamt-Abgleich gefährdet. Besessene Quantifizierer: *+, ++, ?+. Beachten Sie, dass {min, max} und seine Varianten keinen besessenen Abgleich unterstützen.

Mehr

Über gierigen und lässigen Abgleich, siehe Wahl der minimalen oder maximalen Wiederholung.
Über besessenen Abgleich, siehe Überflüssiges Backtracking beseitigen.

Gruppen und Erfassungen

Eine einfache Regexp hat (höchstens) einen Treffer

re = /\d\d\d\d-\d\d-\d\d/
re.match('1943-02-04')      # => #<MatchData "1943-02-04">
re.match('1943-02-04').size # => 1
re.match('foo')             # => nil

Das Hinzufügen von einem oder mehreren Klammerpaaren, (unterausdruck), definiert Gruppen, die zu mehreren übereinstimmenden Teilstrings führen können, die als Erfassungen bezeichnet werden

re = /(\d\d\d\d)-(\d\d)-(\d\d)/
re.match('1943-02-04')      # => #<MatchData "1943-02-04" 1:"1943" 2:"02" 3:"04">
re.match('1943-02-04').size # => 4

Die erste Erfassung ist der gesamte übereinstimmende String; die anderen Erfassungen sind die übereinstimmenden Teilstrings aus den Gruppen.

Eine Gruppe kann einen Quantifizierer haben

re = /July 4(th)?/
re.match('July 4')   # => #<MatchData "July 4" 1:nil>
re.match('July 4th') # => #<MatchData "July 4th" 1:"th">

re = /(foo)*/
re.match('')       # => #<MatchData "" 1:nil>
re.match('foo')    # => #<MatchData "foo" 1:"foo">
re.match('foofoo') # => #<MatchData "foofoo" 1:"foo">

re = /(foo)+/
re.match('')       # => nil
re.match('foo')    # => #<MatchData "foo" 1:"foo">
re.match('foofoo') # => #<MatchData "foofoo" 1:"foo">

Das zurückgegebene MatchData-Objekt bietet Zugriff auf die übereinstimmenden Teilstrings

re = /(\d\d\d\d)-(\d\d)-(\d\d)/
md = re.match('1943-02-04')
# => #<MatchData "1943-02-04" 1:"1943" 2:"02" 3:"04">
md[0] # => "1943-02-04"
md[1] # => "1943"
md[2] # => "02"
md[3] # => "04"

Nicht-erfassende Gruppen

Eine Gruppe kann nicht-erfassend gemacht werden; sie ist immer noch eine Gruppe (und kann z.B. einen Quantifizierer haben), aber ihr übereinstimmender Teilstring ist nicht unter den Erfassungen enthalten.

Eine nicht-erfassende Gruppe beginnt mit ?: (innerhalb der Klammern)

# Don't capture the year.
re = /(?:\d\d\d\d)-(\d\d)-(\d\d)/
md = re.match('1943-02-04') # => #<MatchData "1943-02-04" 1:"02" 2:"04">

Rückbezüge

Ein Gruppen-Treffer kann auch innerhalb der Regexp selbst referenziert werden; eine solche Referenz wird als Rückbezug bezeichnet

/[csh](..) [csh]\1 in/.match('The cat sat in the hat')
# => #<MatchData "cat sat in" 1:"at">

Diese Tabelle zeigt, wie jeder Unterausdruck in der obigen Regexp einen Teilstring im Zielstring abgleicht

| Subexpression in Regexp   | Matching Substring in Target String |
|---------------------------|-------------------------------------|
|       First '[csh]'       |            Character 'c'            |
|          '(..)'           |        First substring 'at'         |
|      First space ' '      |      First space character ' '      |
|       Second '[csh]'      |            Character 's'            |
| '\1' (backreference 'at') |        Second substring 'at'        |
|           ' in'           |            Substring ' in'          |

Eine Regexp kann beliebig viele Gruppen enthalten

Für eine große Anzahl von Gruppen
- Die normale \n-Notation gilt nur für n im Bereich (1..9).
- Die MatchData[n]-Notation gilt für jedes nicht-negative n.
\0 ist ein spezieller Rückbezug, der sich auf den gesamten übereinstimmenden String bezieht; er kann nicht innerhalb der Regexp selbst verwendet werden, kann aber außerhalb davon verwendet werden (z.B. in einem Substitutionsmethodenaufruf)
```
'The cat sat in the hat'.gsub(/[csh]at/, '\0s')
# => "The cats sats in the hats"
```

Benannte Erfassungen

Wie oben gezeigt, kann auf eine Erfassung durch ihre Nummer verwiesen werden. Eine Erfassung kann auch einen Namen haben, vorangestellt als ?<name> oder ?'name', und der Name (symbolisiert) kann als Index in MatchData[] verwendet werden

md = /\$(?<dollars>\d+)\.(?'cents'\d+)/.match("$3.67")
# => #<MatchData "$3.67" dollars:"3" cents:"67">
md[:dollars]  # => "3"
md[:cents]    # => "67"
# The capture numbers are still valid.
md[2]         # => "67"

Wenn eine Regexp eine benannte Erfassung enthält, gibt es keine unbenannten Erfassungen

/\$(?<dollars>\d+)\.(\d+)/.match("$3.67")
# => #<MatchData "$3.67" dollars:"3">

Eine benannte Gruppe kann als \k<name> zurückbezogen werden

/(?<vowel>[aeiou]).\k<vowel>.\k<vowel>/.match('ototomy')
# => #<MatchData "ototo" vowel:"o">

Wenn (und nur wenn) eine Regexp benannte Erfassungsgruppen enthält und vor dem =~-Operator steht, werden die erfassten Teilstrings lokalen Variablen mit entsprechenden Namen zugewiesen

/\$(?<dollars>\d+)\.(?<cents>\d+)/ =~ '$3.67'
dollars # => "3"
cents   # => "67"

Die Methode Regexp#named_captures gibt einen Hash der Erfassungsnamen und Teilstrings zurück; die Methode Regexp#names gibt ein Array der Erfassungsnamen zurück.

Atomare Gruppierung

Eine Gruppe kann mit (?>unterausdruck) atomar gemacht werden.

Dies führt dazu, dass der Unterausdruck unabhängig vom Rest des Ausdrucks abgeglichen wird, so dass der übereinstimmende Teilstring für den Rest des Abgleichs fest wird, es sei denn, der gesamte Unterausdruck muss aufgegeben und anschließend wieder besucht werden.

Auf diese Weise wird Unterausdruck als unteilbares Ganzes behandelt. Atomare Gruppierung wird typischerweise verwendet, um Muster zu optimieren und unnötiges Backtracking zu verhindern.

Beispiel (ohne atomare Gruppierung)

/".*"/.match('"Quote"') # => #<MatchData "\"Quote\"">

Analyse

Der führende Unterausdruck " im Muster gleicht das erste Zeichen " im Zielstring ab.
Der nächste Unterausdruck .* gleicht den nächsten Teilstring Quote" (einschließlich des abschließenden Anführungszeichens) ab.
Nun ist nichts mehr im Zielstring übrig, um den abschließenden Unterausdruck " im Muster abzugleichen; dies würde dazu führen, dass der Gesamt-Abgleich fehlschlägt.
Der übereinstimmende Teilstring wird um eine Position zurückverfolgt: Quote.
Der letzte Unterausdruck " gleicht nun den letzten Teilstring " ab, und der Gesamt-Abgleich gelingt.

Wenn der Unterausdruck .* atomar gruppiert wird, wird das Backtracking deaktiviert und der Gesamt-Abgleich schlägt fehl

/"(?>.*)"/.match('"Quote"') # => nil

Atomare Gruppierung kann die Leistung beeinträchtigen; siehe Atomic Group.

Unterausdruck-Aufrufe

Wie oben gezeigt, gibt eine Rückbezugsnummer (\n) oder ein Name (\k<name>) Zugriff auf einen erfassten Teilstring; der entsprechende Regexp-Unterausdruck kann ebenfalls über die Nummer (\gn) oder den Namen (\g<name>) abgerufen werden

/\A(?<paren>\(\g<paren>*\))*\z/.match('(())')
# ^1
#      ^2
#           ^3
#                 ^4
#      ^5
#           ^6
#                      ^7
#                       ^8
#                       ^9
#                           ^10

Das Muster

Passt am Anfang des Strings, d. h. vor dem ersten Zeichen.
Gibt eine benannte Gruppe paren ein.
Passt das erste Zeichen im String, '('.
Ruft die Gruppe paren erneut auf, d. h. rekursiert zum zweiten Schritt.
Ruft die Gruppe paren erneut auf.
Passt das zweite Zeichen im String, '('.
Versucht, paren ein drittes Mal aufzurufen, scheitert jedoch, da dies einen erfolgreichen Gesamt-Abgleich verhindern würde.
Passt das dritte Zeichen im String, ')'; markiert das Ende des zweiten rekursiven Aufrufs
Passt das vierte Zeichen im String, ')'.
Passt das Ende des Strings.

Siehe Unterausdruck-Aufrufe.

Bedingte Ausdrücke

Die bedingte Konstruktion hat die Form (?(cond)yes|no), wobei

cond eine Erfassungsnummer oder ein Name sein kann.
Der abzugleichende Ausdruck ist yes, wenn cond erfasst wird; andernfalls ist der abzugleichende Ausdruck no.
Wenn nicht benötigt, kann |no weggelassen werden.

Beispiele

re = /\A(foo)?(?(1)(T)|(F))\z/
re.match('fooT') # => #<MatchData "fooT" 1:"foo" 2:"T" 3:nil>
re.match('F')    # => #<MatchData "F" 1:nil 2:nil 3:"F">
re.match('fooF') # => nil
re.match('T')    # => nil

re = /\A(?<xyzzy>foo)?(?(<xyzzy>)(T)|(F))\z/
re.match('fooT') # => #<MatchData "fooT" xyzzy:"foo">
re.match('F')    # => #<MatchData "F" xyzzy:nil>
re.match('fooF') # => nil
re.match('T')    # => nil

Abwesenheitsoperator

Der Abwesenheitsoperator ist eine spezielle Gruppe, die alles abgleicht, was die enthaltenen Unterausdrücke *nicht* abgleicht.

/(?~real)/.match('surrealist') # => #<MatchData "surrea">
/(?~real)ist/.match('surrealist') # => #<MatchData "ealist">
/sur(?~real)ist/.match('surrealist') # => nil

Unicode

Unicode-Eigenschaften

Die Konstruktion /\p{property_name}/ (mit Kleinbuchstaben p) gleicht Zeichen anhand eines Unicode-Eigenschaftsnamens ab, ähnlich wie eine Zeichenklasse; die Eigenschaft Alpha spezifiziert alphabetische Zeichen

/\p{Alpha}/.match('a') # => #<MatchData "a">
/\p{Alpha}/.match('1') # => nil

Eine Eigenschaft kann invertiert werden, indem dem Namen ein Caret-Zeichen (^) vorangestellt wird

/\p{^Alpha}/.match('1') # => #<MatchData "1">
/\p{^Alpha}/.match('a') # => nil

Oder indem \P (Großbuchstabe P) verwendet wird

/\P{Alpha}/.match('1') # => #<MatchData "1">
/\P{Alpha}/.match('a') # => nil

Siehe Unicode-Eigenschaften für Regexps, die auf den zahlreichen Eigenschaften basieren.

Einige häufig verwendete Eigenschaften entsprechen POSIX-Klammerausdrücken

/\p{Alnum}/: Alphabetisches und numerisches Zeichen
/\p{Alpha}/: Alphabetisches Zeichen
/\p{Blank}/: Leerzeichen oder Tabulator
/\p{Cntrl}/: Steuerzeichen
/\p{Digit}/: Ziffernzeichen und ähnliche)
/\p{Lower}/: Kleinbuchstaben-Alphabetisches Zeichen
/\p{Print}/: Wie \p{Graph}, aber einschließlich des Leerzeichens
/\p{Punct}/: Satzzeichen
/\p{Space}/: Leerzeichen ([:blank:], Zeilenumbruch, Wagenrücklauf usw.)
/\p{Upper}/: Großbuchstaben-Alphabetisch
/\p{XDigit}/: Zulässige Ziffer für eine Hexadezimalzahl (d.h. 0-9a-fA-F)

Diese werden ebenfalls häufig verwendet

/\p{Emoji}/: Unicode-Emoji.
/\p{Graph}/: Zeichen außer /\p{Cntrl}/ und /\p{Space}/. Beachten Sie, dass unsichtbare Zeichen in der Unicode-Kategorie „Format“ enthalten sind.
/\p{Word}/: Ein Mitglied in einer dieser Unicode-Zeichenkategorien (siehe unten) oder mit einer dieser Unicode-Eigenschaften
- Unicode-Kategorien
  - Mark (M).
  - Decimal Number (Nd)
  - Connector Punctuation (Pc).
- Unicode-Eigenschaften
  - Alpha
  - Join_Control
/\p{ASCII}/: Ein Zeichen im ASCII-Zeichensatz.
/\p{Any}/: Jedes Unicode-Zeichen (einschließlich nicht zugewiesener Zeichen).
/\p{Assigned}/: Ein zugewiesenes Zeichen.

Unicode-Zeichenkategorien

Ein Unicode-Zeichenkategoriename

Kann entweder sein voller Name oder sein abgekürzter Name.
Ist nicht case-sensitiv.
Behandelt Leerzeichen, Bindestrich und Unterstrich als äquivalent.

Beispiele

/\p{lu}/                # => /\p{lu}/
/\p{LU}/                # => /\p{LU}/
/\p{Uppercase Letter}/  # => /\p{Uppercase Letter}/
/\p{Uppercase_Letter}/  # => /\p{Uppercase_Letter}/
/\p{UPPERCASE-LETTER}/  # => /\p{UPPERCASE-LETTER}/

Nachfolgend sind die Abkürzungen und Namen der Unicode-Zeichenkategorien aufgeführt. Aufzählungen von Zeichen in jeder Kategorie finden Sie unter den Links.

Buchstaben

L, Letter: LC, Lm oder Lo.
LC, Cased_Letter: Ll, Lt oder Lu.
Lu, Lowercase_Letter.
Lu, Modifier_Letter.
Lu, Other_Letter.
Lu, Titlecase_Letter.
Lu, Uppercase_Letter.

Markierungen

M, Mark: Mc, Me oder Mn.
Mc, Spacing_Mark.
Me, Enclosing_Mark.
Mn, Nonapacing_Mark.

Zahlen

N, Number: Nd, Nl oder No.
Nd, Decimal_Number.
Nl, Letter_Number.
No, Other_Number.

Satzzeichen

P, Punctuation: Pc, Pd, Pe, Pf, Pi, Po oder Ps.
Pc, Connector_Punctuation.
Pd, Dash_Punctuation.
Pe, Close_Punctuation.
Pf, Final_Punctuation.
Pi, Initial_Punctuation.
Po, Other_Punctuation.
Ps, Open_Punctuation.
S, Symbol: Sc, Sk, Sm oder So.
Sc, Currency_Symbol.
Sk, Modifier_Symbol.
Sm, Math_Symbol.
So, Other_Symbol.
Z, Separator: Zl, Zp oder Zs.
Zl, Line_Separator.
Zp, Paragraph_Separator.
Zs, Space_Separator.
C, Other: Cc, Cf, Cn, Co oder Cs.
Cc, Control.
Cf, Format.
Cn, Unassigned.
Co, Private_Use.
Cs, Surrogate.

Unicode-Skripte und -Blöcke

Zu den Unicode-Eigenschaften gehören

Unicode-Skripte; siehe unterstützte Skripte.
Unicode-Blöcke; siehe unterstützte Blöcke.

POSIX-Klammerausdrücke

Ein POSIX-Klammerausdruck ist ebenfalls ähnlich einer Zeichenklasse. Diese Ausdrücke bieten eine portable Alternative zu den oben genannten, mit dem zusätzlichen Vorteil, Nicht-ASCII-Zeichen einzuschließen

/\d/ gleicht nur ASCII-Dezimalziffern 0 bis 9 ab.
/[[:digit:]]/ gleicht jedes Zeichen in der Unicode-Kategorie Decimal Number (Nd) ab; siehe unten.

Die POSIX-Klammerausdrücke

/[[:digit:]]/: Gleicht einer Unicode-Ziffer ab

/[[:digit:]]/.match('9')       # => #<MatchData "9">
/[[:digit:]]/.match("\u1fbf9") # => #<MatchData "9">

/[[:xdigit:]]/: Gleicht einer für Hexadezimalzahlen zulässigen Ziffer ab; äquivalent zu [0-9a-fA-F].

/[[:upper:]]/: Gleicht einem Unicode-Großbuchstaben ab

/[[:upper:]]/.match('A')      # => #<MatchData "A">
/[[:upper:]]/.match("\u00c6") # => #<MatchData "Æ">

/[[:lower:]]/: Gleicht einem Unicode-Kleinbuchstaben ab

/[[:lower:]]/.match('a')      # => #<MatchData "a">
/[[:lower:]]/.match("\u01fd") # => #<MatchData "ǽ">

/[[:alpha:]]/: Gleicht /[[:upper:]]/ oder /[[:lower:]]/ ab.
/[[:alnum:]]/: Gleicht /[[:alpha:]]/ oder /[[:digit:]]/ ab.

/[[:space:]]/: Gleicht einem Unicode-Leerzeichen ab

/[[:space:]]/.match(' ')      # => #<MatchData " ">
/[[:space:]]/.match("\u2005") # => #<MatchData " ">

/[[:blank:]]/: Gleicht /[[:space:]]/ oder einem Tabulatorzeichen ab

/[[:blank:]]/.match(' ')      # => #<MatchData " ">
/[[:blank:]]/.match("\u2005") # => #<MatchData " ">
/[[:blank:]]/.match("\t")     # => #<MatchData "\t">

/[[:cntrl:]]/: Gleicht einem Unicode-Steuerzeichen ab

/[[:cntrl:]]/.match("\u0000") # => #<MatchData "\u0000">
/[[:cntrl:]]/.match("\u009f") # => #<MatchData "\u009F">

/[[:graph:]]/: Gleicht jedem Zeichen außer /[[:space:]]/ oder /[[:cntrl:]]/ ab.
/[[:print:]]/: Gleicht /[[:graph:]]/ oder einem Leerzeichen ab.
/[[:punct:]]/: Gleicht jedem (Unicode-Satzzeichen}[www.compart.com/en/unicode/category/Po] ab

Ruby unterstützt auch diese (nicht-POSIX) Klammerausdrücke

/[[:ascii:]]/: Gleicht einem Zeichen im ASCII-Zeichensatz ab.
/[[:word:]]/: Gleicht einem Zeichen in einer dieser Unicode-Zeichenkategorien ab oder hat eine dieser Unicode-Eigenschaften
- Unicode-Kategorien
  - Mark (M).
  - Decimal Number (Nd)
  - Connector Punctuation (Pc).
- Unicode-Eigenschaften
  - Alpha
  - Join_Control

Comments

Ein Kommentar kann mit der Konstruktion (?#Kommentar) in einem Regexp-Muster enthalten sein, wobei Kommentar ein Teilstring ist, der ignoriert werden soll. beliebiger Text, der vom Regexp-Engine ignoriert wird

/foo(?#Ignore me)bar/.match('foobar') # => #<MatchData "foobar">

Der Kommentar darf kein unmaskiertes Trennzeichen enthalten.

Siehe auch Erweiterter Modus.

Modi

Jeder dieser Modifikatoren setzt einen Modus für die Regexp

i: /muster/i setzt den Groß-/Kleinschreibungsunempfindlichen Modus.
m: /muster/m setzt den Mehrzeiligen Modus.
x: /muster/x setzt den Erweiterten Modus.
o: /muster/o setzt den Interpolationsmodus.

Keine, alle oder keine dieser können angewendet werden.

Modifikatoren i, m und x können auf Unterausdrücke angewendet werden

(?modifikator) schaltet den Modus für nachfolgende Unterausdrücke ein
(?-modifikator) schaltet den Modus für nachfolgende Unterausdrücke aus
(?modifikator:unterausdruck) schaltet den Modus für unterausdruck innerhalb der Gruppe ein
(?-modifikator:unterausdruck) schaltet den Modus für unterausdruck innerhalb der Gruppe aus

Beispiel

re = /(?i)te(?-i)st/
re.match('test') # => #<MatchData "test">
re.match('TEst') # => #<MatchData "TEst">
re.match('TEST') # => nil
re.match('teST') # => nil

re = /t(?i:e)st/
re.match('test') # => #<MatchData "test">
re.match('tEst') # => #<MatchData "tEst">
re.match('tEST') # => nil

Die Methode Regexp#options gibt eine Ganzzahl zurück, deren Wert die Einstellungen für den Groß-/Kleinschreibungsunempfindlichen Modus, den Mehrzeiligen Modus und den Erweiterten Modus anzeigt.

Groß-/Kleinschreibungsunempfindlicher Modus

Standardmäßig ist eine Regexp Groß-/Kleinschreibungs-sensitiv

/foo/.match('FOO')  # => nil

Der Modifikator i aktiviert den Groß-/Kleinschreibungsunempfindlichen Modus

/foo/i.match('FOO')
# => #<MatchData "FOO">

Die Methode Regexp#casefold? gibt zurück, ob der Modus Groß-/Kleinschreibungs-unempfindlich ist.

Mehrzeiliger Modus

Der Mehrzeilige Modus in Ruby ist das, was man allgemein als "Dot-All-Modus" bezeichnet

Ohne den Modifikator m gleicht der Unterausdruck . keine Zeilenumbrüche ab
```
/a.c/.match("a\nc")  # => nil
```

Mit dem Modifikator tut er das

/a.c/m.match("a\nc") # => #<MatchData "a\nc">

Im Gegensatz zu anderen Sprachen beeinflusst der Modifikator m die Anker ^ und $ nicht. Diese Anker entsprechen in Ruby immer Zeilengrenzen.

Erweiterter Modus

Der Modifikator x aktiviert den Erweiterten Modus, was bedeutet, dass

Literale Leerzeichen im Muster ignoriert werden.
Das Zeichen # markiert den Rest seiner Zeile als Kommentar, der ebenfalls zu Abgleichzwecken ignoriert wird.

Im Erweiterten Modus können Leerzeichen und Kommentare verwendet werden, um eine selbstdokumentierende Regexp zu erstellen.

Regexp nicht im Erweiterten Modus (gleicht einige römische Ziffern ab)

pattern = '^M{0,3}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$'
re = /#{pattern}/
re.match('MCMXLIII') # => #<MatchData "MCMXLIII" 1:"CM" 2:"XL" 3:"III">

Regexp im Erweiterten Modus

pattern = <<-EOT
  ^                   # beginning of string
  M{0,3}              # thousands - 0 to 3 Ms
  (CM|CD|D?C{0,3})    # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 Cs),
                      #            or 500-800 (D, followed by 0 to 3 Cs)
  (XC|XL|L?X{0,3})    # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 Xs),
                      #        or 50-80 (L, followed by 0 to 3 Xs)
  (IX|IV|V?I{0,3})    # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 Is),
                      #        or 5-8 (V, followed by 0 to 3 Is)
  $                   # end of string
EOT
re = /#{pattern}/x
re.match('MCMXLIII') # => #<MatchData "MCMXLIII" 1:"CM" 2:"XL" 3:"III">

Interpolationsmodus

Der Modifikator o bedeutet, dass beim ersten Auftreten einer literalen Regexp mit Interpolationen das generierte Regexp-Objekt gespeichert und für alle zukünftigen Auswertungen dieser literalen Regexp verwendet wird. Ohne den Modifikator o wird die generierte Regexp nicht gespeichert, so dass jede Auswertung der literalen Regexp ein neues Regexp-Objekt generiert.

Ohne Modifikator o

def letters; sleep 5; /[A-Z][a-z]/; end
words = %w[abc def xyz]
start = Time.now
words.each {|word| word.match(/\A[#{letters}]+\z/) }
Time.now - start # => 15.0174892

Mit Modifikator o

start = Time.now
words.each {|word| word.match(/\A[#{letters}]+\z/o) }
Time.now - start # => 5.0010866

Beachten Sie, dass, wenn die literale Regexp keine Interpolationen hat, das o-Verhalten der Standard ist.

Kodierungen

Standardmäßig hat eine Regexp mit nur US-ASCII-Zeichen eine US-ASCII-Kodierung

re = /foo/
re.source.encoding # => #<Encoding:US-ASCII>
re.encoding        # => #<Encoding:US-ASCII>

Eine reguläre Ausdruck, die Nicht-US-ASCII-Zeichen enthält, wird angenommen, die Quellkodierung zu verwenden. Dies kann mit einem der folgenden Modifikatoren überschrieben werden.

/pat/n: US-ASCII, wenn nur US-ASCII-Zeichen enthalten sind, sonst ASCII-8BIT

/foo/n.encoding     # => #<Encoding:US-ASCII>
/foo\xff/n.encoding # => #<Encoding:ASCII-8BIT>
/foo\x7f/n.encoding # => #<Encoding:US-ASCII>

/pat/u: UTF-8
```
/foo/u.encoding # => #<Encoding:UTF-8>
```

/pat/e: EUC-JP

/foo/e.encoding # => #<Encoding:EUC-JP>

/pat/s: Windows-31J

/foo/s.encoding # => #<Encoding:Windows-31J>

Eine Regexp kann mit einem Zielstring abgeglichen werden, wenn entweder

Sie die gleiche Kodierung haben.
Die Kodierung der Regexp ist eine feste Kodierung und der String enthält nur ASCII-Zeichen. Die Methode Regexp#fixed_encoding? gibt zurück, ob die Regexp eine feste Kodierung hat.

Wenn ein Abgleich zwischen inkompatiblen Kodierungen versucht wird, wird eine Encoding::CompatibilityError-Ausnahme ausgelöst.

Beispiel

re = eval("# encoding: ISO-8859-1\n/foo\\xff?/")
re.encoding                 # => #<Encoding:ISO-8859-1>
re =~ "foo".encode("UTF-8") # => 0
re =~ "foo\u0100"           # Raises Encoding::CompatibilityError

Die Kodierung kann explizit festgelegt werden, indem Regexp::FIXEDENCODING in das zweite Argument für Regexp.new aufgenommen wird

# Regexp with encoding ISO-8859-1.
re = Regexp.new("a".force_encoding('iso-8859-1'), Regexp::FIXEDENCODING)
re.encoding  # => #<Encoding:ISO-8859-1>
# Target string with encoding UTF-8.
s = "a\u3042"
s.encoding   # => #<Encoding:UTF-8>
re.match(s)  # Raises Encoding::CompatibilityError.

Timeouts

Wenn entweder die Regexp-Quelle oder der Zielstring aus nicht vertrauenswürdigen Eingaben stammen, könnten bösartige Werte zu einem Denial-of-Service-Angriff werden; um einen solchen Angriff zu verhindern, ist es ratsam, ein Timeout festzulegen.

Regexp hat zwei Timeout-Werte

Ein Klassen-Standard-Timeout, der für eine Regexp verwendet wird, deren Instanz-Timeout nil ist; dieser Standard ist anfangs nil und kann durch die Methode Regexp.timeout= gesetzt werden
```
Regexp.timeout # => nil
Regexp.timeout = 3.0
Regexp.timeout # => 3.0
```
Ein Instanz-Timeout, der standardmäßig nil ist und in Regexp.new gesetzt werden kann
```
re = Regexp.new('foo', timeout: 5.0)
re.timeout # => 5.0
```

Wenn regexp.timeout nil ist, "fällt" das Timeout auf Regexp.timeout durch; wenn regexp.timeout nicht nil ist, steuert dieser Wert das Timeout

| regexp.timeout Value | Regexp.timeout Value |            Result           |
|----------------------|----------------------|-----------------------------|
|         nil          |          nil         |       Never times out.      |
|         nil          |         Float        | Times out in Float seconds. |
|        Float         |          Any         | Times out in Float seconds. |

Optimierung

Für bestimmte Werte des Musters und des Zielstrings kann die Abgleichzeit polynomisch oder exponentiell in Bezug auf die Eingabegröße wachsen; die daraus resultierende potenzielle Schwachstelle ist der Denial-of-Service-Angriff durch reguläre Ausdrücke (ReDoS).

Regexp-Abgleich kann eine Optimierung anwenden, um ReDoS-Angriffe zu verhindern. Wenn die Optimierung angewendet wird, erhöht sich die Abgleichzeit linear (nicht polynomisch oder exponentiell) in Bezug auf die Eingabegröße, und ein ReDoS-Angriff ist nicht möglich.

Diese Optimierung wird angewendet, wenn das Muster diese Kriterien erfüllt

Keine Rückbezüge.
Keine Unterausdruck-Aufrufe.
Keine verschachtelten Lookaround-Anker oder atomaren Gruppen.
Keine verschachtelten Quantifizierer mit Zählung (d. h. keine verschachtelten {n}, {min,}, {,max} oder {min,max}-Quantifizierer)

Sie können die Methode Regexp.linear_time? verwenden, um festzustellen, ob ein Muster diese Kriterien erfüllt

Regexp.linear_time?(/a*/)     # => true
Regexp.linear_time?('a*')     # => true
Regexp.linear_time?(/(a*)\1/) # => false

Ein nicht vertrauenswürdiger Quellcode ist jedoch möglicherweise nicht sicher, selbst wenn die Methode true zurückgibt, da die Optimierung Memoisation verwendet (was zu einem großen Speicherverbrauch führen kann).

Referenzen

Lesen

Mastering Regular Expressions von Jeffrey E.F. Friedl.
Regular Expressions Cookbook von Jan Goyvaerts & Steven Levithan.

Entdecken, testen

Rubular: interaktiver Online-Editor.

Constants

EXTENDED: siehe Regexp.options und Regexp.new
FIXEDENCODING: siehe Regexp.options und Regexp.new
IGNORECASE: siehe Regexp.options und Regexp.new
MULTILINE: siehe Regexp.options und Regexp.new
NOENCODING: siehe Regexp.options und Regexp.new

Öffentliche Klassenmethoden

compile (*args)

Alias für Regexp.new

escape(string) → new_string

Source

static VALUE
rb_reg_s_quote(VALUE c, VALUE str)
{
    return rb_reg_quote(reg_operand(str, TRUE));
}

Gibt einen neuen String zurück, der Zeichen maskiert, die in einem regulären Ausdruck eine besondere Bedeutung haben

s = Regexp.escape('\*?{}.')      # => "\\\\\\*\\?\\{\\}\\."

Für jeden String s gibt dieser Aufruf ein MatchData-Objekt zurück

r = Regexp.new(Regexp.escape(s)) # => /\\\\\\\*\\\?\\\{\\\}\\\./
r.match(s)                       # => #<MatchData "\\\\\\*\\?\\{\\}\\.">

json_create (object)

Source

# File ext/json/lib/json/add/regexp.rb, line 9
def self.json_create(object)
  new(object['s'], object['o'])
end

Siehe as_json.

last_match → matchdata oder nil

last_match(n) → string oder nil

last_match(name) → string oder nil

Source

static VALUE
rb_reg_s_last_match(int argc, VALUE *argv, VALUE _)
{
    if (rb_check_arity(argc, 0, 1) == 1) {
        VALUE match = rb_backref_get();
        int n;
        if (NIL_P(match)) return Qnil;
        n = match_backref_number(match, argv[0]);
        return rb_reg_nth_match(n, match);
    }
    return match_getter();
}

Ohne Argument wird der Wert von $~ zurückgegeben, was das Ergebnis des letzten Musterabgleichs ist (siehe Regexp-Globale Variablen)

/c(.)t/ =~ 'cat'  # => 0
Regexp.last_match # => #<MatchData "cat" 1:"a">
/a/ =~ 'foo'      # => nil
Regexp.last_match # => nil

Mit einem nicht-negativen ganzzahligen Argument n wird das _n_-te Feld in den Matchdata zurückgegeben, falls vorhanden, sonst nil

/c(.)t/ =~ 'cat'     # => 0
Regexp.last_match(0) # => "cat"
Regexp.last_match(1) # => "a"
Regexp.last_match(2) # => nil

Mit einem negativen ganzzahligen Argument n zählt es rückwärts vom letzten Feld

Regexp.last_match(-1)       # => "a"

Mit einem String- oder Symbolargument name wird der Stringwert für die benannte Erfassung zurückgegeben, falls vorhanden

/(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/ =~ 'var = val'
Regexp.last_match        # => #<MatchData "var = val" lhs:"var"rhs:"val">
Regexp.last_match(:lhs)  # => "var"
Regexp.last_match('rhs') # => "val"
Regexp.last_match('foo') # Raises IndexError.

linear_time?(re)

linear_time?(string, options = 0)

Source

static VALUE
rb_reg_s_linear_time_p(int argc, VALUE *argv, VALUE self)
{
    struct reg_init_args args;
    VALUE re = reg_extract_args(argc, argv, &args);

    if (NIL_P(re)) {
        re = reg_init_args(rb_reg_alloc(), args.str, args.enc, args.flags);
    }

    return RBOOL(onig_check_linear_time(RREGEXP_PTR(re)));
}

Gibt true zurück, wenn die Übereinstimmung mit re in linearer Zeit zur Eingabezeichenkette erfolgen kann.

Regexp.linear_time?(/re/) # => true

Beachten Sie, dass dies eine Eigenschaft des Ruby-Interpreters ist und nicht des regulären Ausdrucks. Identische reguläre Ausdrücke können je nach Ihrer Ruby-Binärdatei in linearer Zeit ausgeführt werden oder auch nicht. Es besteht weder Vorwärts- noch Rückwärtskompatibilität für den Rückgabewert dieser Methode. Unser aktueller Algorithmus ist (*1), aber dies kann sich in Zukunft ändern. Alternative Implementierungen können ebenfalls unterschiedlich verhalten. Sie geben möglicherweise immer false für alles zurück.

(*1): doi.org/10.1109/SP40001.2021.00032

new(string, options = 0, timeout: nil) → regexp

new(regexp, timeout: nil) → regexp

Source

static VALUE
rb_reg_initialize_m(int argc, VALUE *argv, VALUE self)
{
    struct reg_init_args args;
    VALUE re = reg_extract_args(argc, argv, &args);

    if (NIL_P(re)) {
        reg_init_args(self, args.str, args.enc, args.flags);
    }
    else {
        reg_copy(self, re);
    }

    set_timeout(&RREGEXP_PTR(self)->timelimit, args.timeout);

    return self;
}

Mit dem Argument string wird ein neuer regulärer Ausdruck mit der angegebenen Zeichenkette und Optionen zurückgegeben.

r = Regexp.new('foo') # => /foo/
r.source              # => "foo"
r.options             # => 0

Das optionale Argument options ist eines der folgenden:

Eine String von Optionen

Regexp.new('foo', 'i')  # => /foo/i
Regexp.new('foo', 'im') # => /foo/im

Das bitweise ODER aus einem oder mehreren der Konstanten Regexp::EXTENDED, Regexp::IGNORECASE, Regexp::MULTILINE und Regexp::NOENCODING

Regexp.new('foo', Regexp::IGNORECASE) # => /foo/i
Regexp.new('foo', Regexp::EXTENDED)   # => /foo/x
Regexp.new('foo', Regexp::MULTILINE)  # => /foo/m
Regexp.new('foo', Regexp::NOENCODING)  # => /foo/n
flags = Regexp::IGNORECASE | Regexp::EXTENDED |  Regexp::MULTILINE
Regexp.new('foo', flags)              # => /foo/mix

nil oder false, was ignoriert wird.
Jeder andere wahrheitsgemäße Wert, in diesem Fall ist der reguläre Ausdruck nicht zwischen Groß- und Kleinschreibung unterscheidend.

Wenn das optionale Schlüsselwortargument timeout angegeben wird, überschreibt sein Float-Wert das Zeitlimit für die Klasse Regexp.timeout. Wenn nil als +timeout übergeben wird, wird das Zeitlimit für die Klasse Regexp.timeout verwendet.

Mit dem Argument regexp wird ein neuer regulärer Ausdruck zurückgegeben. Die Quelle, Optionen und das Timeout sind dieselben wie bei regexp. Die Argumente options und n_flag sind unwirksam. Das Timeout kann durch das Schlüsselwort timeout überschrieben werden.

options = Regexp::MULTILINE
r = Regexp.new('foo', options, timeout: 1.1) # => /foo/m
r2 = Regexp.new(r)                           # => /foo/m
r2.timeout                                   # => 1.1
r3 = Regexp.new(r, timeout: 3.14)            # => /foo/m
r3.timeout                                   # => 3.14

escape(string) → new_string

Source

static VALUE
rb_reg_s_quote(VALUE c, VALUE str)
{
    return rb_reg_quote(reg_operand(str, TRUE));
}

Gibt einen neuen String zurück, der Zeichen maskiert, die in einem regulären Ausdruck eine besondere Bedeutung haben

s = Regexp.escape('\*?{}.')      # => "\\\\\\*\\?\\{\\}\\."

Für jeden String s gibt dieser Aufruf ein MatchData-Objekt zurück

r = Regexp.new(Regexp.escape(s)) # => /\\\\\\\*\\\?\\\{\\\}\\\./
r.match(s)                       # => #<MatchData "\\\\\\*\\?\\{\\}\\.">

timeout → float or nil

Source

static VALUE
rb_reg_s_timeout_get(VALUE dummy)
{
    double d = hrtime2double(rb_reg_match_time_limit);
    if (d == 0.0) return Qnil;
    return DBL2NUM(d);
}

Gibt das aktuelle Standard-Timeoutintervall für den Abgleich von Regexp in Sekunden zurück. nil bedeutet keine Standard-Timeoutkonfiguration.

timeout = float or nil

Source

static VALUE
rb_reg_s_timeout_set(VALUE dummy, VALUE timeout)
{
    rb_ractor_ensure_main_ractor("can not access Regexp.timeout from non-main Ractors");

    set_timeout(&rb_reg_match_time_limit, timeout);

    return timeout;
}

Legt das Standard-Timeoutintervall für den Abgleich von Regexp in Sekunden fest. nil bedeutet keine Standard-Timeoutkonfiguration. Diese Konfiguration ist prozessweit gültig. Wenn Sie das Timeout für jeden einzelnen Regexp festlegen möchten, verwenden Sie das Schlüsselwort timeout für Regexp.new.

Regexp.timeout = 1
/^a*b?a*$/ =~ "a" * 100000 + "x" #=> regexp match timeout (RuntimeError)

try_convert(object) → regexp or nil

Source

static VALUE
rb_reg_s_try_convert(VALUE dummy, VALUE re)
{
    return rb_check_regexp_type(re);
}

Gibt object zurück, wenn es sich um einen regulären Ausdruck handelt.

Regexp.try_convert(/re/) # => /re/

Andernfalls, wenn object auf :to_regexp reagiert, wird object.to_regexp aufgerufen und das Ergebnis zurückgegeben.

Gibt nil zurück, wenn object nicht auf :to_regexp reagiert.

Regexp.try_convert('re') # => nil

Löst eine Ausnahme aus, es sei denn, object.to_regexp gibt einen regulären Ausdruck zurück.

union(*patterns) → regexp

union(array_of_patterns) → regexp

Source

static VALUE
rb_reg_s_union_m(VALUE self, VALUE args)
{
    VALUE v;
    if (RARRAY_LEN(args) == 1 &&
        !NIL_P(v = rb_check_array_type(rb_ary_entry(args, 0)))) {
        return rb_reg_s_union(self, v);
    }
    return rb_reg_s_union(self, args);
}

Gibt einen neuen regulären Ausdruck zurück, der die Vereinigung der gegebenen Muster ist.

r = Regexp.union(%w[cat dog])      # => /cat|dog/
r.match('cat')      # => #<MatchData "cat">
r.match('dog')      # => #<MatchData "dog">
r.match('cog')      # => nil

Für jedes Muster, das eine Zeichenkette ist, wird Regexp.new(pattern) verwendet.

Regexp.union('penzance')             # => /penzance/
Regexp.union('a+b*c')                # => /a\+b\*c/
Regexp.union('skiing', 'sledding')   # => /skiing|sledding/
Regexp.union(['skiing', 'sledding']) # => /skiing|sledding/

Für jedes Muster, das ein regulärer Ausdruck ist, wird es unverändert übernommen, einschließlich seiner Flags.

Regexp.union(/foo/i, /bar/m, /baz/x)
# => /(?i-mx:foo)|(?m-ix:bar)|(?x-mi:baz)/
Regexp.union([/foo/i, /bar/m, /baz/x])
# => /(?i-mx:foo)|(?m-ix:bar)|(?x-mi:baz)/

Ohne Argumente wird /(?!)/ zurückgegeben.

Regexp.union # => /(?!)/

Wenn ein regulärer Ausdruck ein Capture enthält, ist das Verhalten undefiniert.

Öffentliche Instanzmethoden

regexp == object → true or false

Gibt true zurück, wenn object ein weiterer Regexp ist, dessen Muster, Flags und Kodierung mit self übereinstimmen, andernfalls false.

/foo/ == Regexp.new('foo')                          # => true
/foo/ == /foo/i                                     # => false
/foo/ == Regexp.new('food')                         # => false
/foo/ == Regexp.new("abc".force_encoding("euc-jp")) # => false

Alias für: eql?

regexp === string → true or false

Source

static VALUE
rb_reg_eqq(VALUE re, VALUE str)
{
    long start;

    str = reg_operand(str, FALSE);
    if (NIL_P(str)) {
        rb_backref_set(Qnil);
        return Qfalse;
    }
    start = rb_reg_search(re, str, 0, 0);
    return RBOOL(start >= 0);
}

Gibt true zurück, wenn self eine Übereinstimmung in string findet.

/^[a-z]*$/ === 'HELLO' # => false
/^[A-Z]*$/ === 'HELLO' # => true

Diese Methode wird in case-Anweisungen aufgerufen.

s = 'HELLO'
case s
when /\A[a-z]*\z/; print "Lower case\n"
when /\A[A-Z]*\z/; print "Upper case\n"
else               print "Mixed case\n"
end # => "Upper case"

regexp =~ string → integer or nil

Source

VALUE
rb_reg_match(VALUE re, VALUE str)
{
    long pos = reg_match_pos(re, &str, 0, NULL);
    if (pos < 0) return Qnil;
    pos = rb_str_sublen(str, pos);
    return LONG2FIX(pos);
}

Gibt den ganzzahligen Index (in Zeichen) der ersten Übereinstimmung für self und string zurück oder nil, wenn keine vorhanden ist. Setzt außerdem die globalen Variablen des regulären Ausdrucks.

/at/ =~ 'input data' # => 7
$~                   # => #<MatchData "at">
/ax/ =~ 'input data' # => nil
$~                   # => nil

Weist benannte Captures lokalen Variablen mit denselben Namen zu, wenn und nur wenn self

ein regulärer Ausdruck-Literal ist; siehe Regexp Literale.
keine Interpolationen enthält; siehe Regexp-Interpolation.
links vom Ausdruck steht.

Beispiel

/(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/ =~ '  x = y  '
p lhs # => "x"
p rhs # => "y"

Weist nil zu, wenn keine Übereinstimmung erzielt wird.

/(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/ =~ '  x = '
p lhs # => nil
p rhs # => nil

Es erfolgen keine Zuweisungen lokaler Variablen, wenn self kein regulärer Ausdruck-Literal ist.

r = /(?<foo>\w+)\s*=\s*(?<foo>\w+)/
r =~ '  x = y  '
p foo # Undefined local variable
p bar # Undefined local variable

Die Zuweisung erfolgt nicht, wenn der reguläre Ausdruck nicht links steht.

'  x = y  ' =~ /(?<foo>\w+)\s*=\s*(?<foo>\w+)/
p foo, foo # Undefined local variables

Eine Regexp-Interpolation, #{}, deaktiviert ebenfalls die Zuweisung.

r = /(?<foo>\w+)/
/(?<foo>\w+)\s*=\s*#{r}/ =~ 'x = y'
p foo # Undefined local variable

~ rxp → integer or nil

Source

VALUE
rb_reg_match2(VALUE re)
{
    long start;
    VALUE line = rb_lastline_get();

    if (!RB_TYPE_P(line, T_STRING)) {
        rb_backref_set(Qnil);
        return Qnil;
    }

    start = rb_reg_search(re, line, 0, 0);
    if (start < 0) {
        return Qnil;
    }
    start = rb_str_sublen(line, start);
    return LONG2FIX(start);
}

Entspricht rxp =~ $_

$_ = "input data"
~ /at/ # => 7

as_json (*)

Source

# File ext/json/lib/json/add/regexp.rb, line 28
def as_json(*)
  {
    JSON.create_id => self.class.name,
    'o'            => options,
    's'            => source,
  }
end

Die Methoden Regexp#as_json und Regexp.json_create können verwendet werden, um ein Regexp-Objekt zu serialisieren und zu deserialisieren; siehe Marshal.

Die Methode Regexp#as_json serialisiert self und gibt einen 2-elementigen Hash zurück, der self darstellt.

require 'json/add/regexp'
x = /foo/.as_json
# => {"json_class"=>"Regexp", "o"=>0, "s"=>"foo"}

Die Methode JSON.create deserialisiert einen solchen Hash und gibt ein Regexp-Objekt zurück.

Regexp.json_create(x) # => /foo/

casefold?→ true or false

Source

static VALUE
rb_reg_casefold_p(VALUE re)
{
    rb_reg_check(re);
    return RBOOL(RREGEXP_PTR(re)->options & ONIG_OPTION_IGNORECASE);
}

Gibt true zurück, wenn das Flag zur Ignorierung der Groß- und Kleinschreibung in self gesetzt ist, andernfalls false.

/a/.casefold?           # => false
/a/i.casefold?          # => true
/(?i:a)/.casefold?      # => false

encoding → encoding

Source

VALUE
rb_obj_encoding(VALUE obj)
{
    int idx = rb_enc_get_index(obj);
    if (idx < 0) {
        rb_raise(rb_eTypeError, "unknown encoding");
    }
    return rb_enc_from_encoding_index(idx & ENC_INDEX_MASK);
}

Gibt ein Encoding-Objekt zurück, das die Kodierung von self darstellt; siehe Kodierungen.

Verwandt: siehe Abfragen.

eql?

Source

VALUE
rb_reg_equal(VALUE re1, VALUE re2)
{
    if (re1 == re2) return Qtrue;
    if (!RB_TYPE_P(re2, T_REGEXP)) return Qfalse;
    rb_reg_check(re1); rb_reg_check(re2);
    if (FL_TEST(re1, KCODE_FIXED) != FL_TEST(re2, KCODE_FIXED)) return Qfalse;
    if (RREGEXP_PTR(re1)->options != RREGEXP_PTR(re2)->options) return Qfalse;
    if (RREGEXP_SRC_LEN(re1) != RREGEXP_SRC_LEN(re2)) return Qfalse;
    if (ENCODING_GET(re1) != ENCODING_GET(re2)) return Qfalse;
    return RBOOL(memcmp(RREGEXP_SRC_PTR(re1), RREGEXP_SRC_PTR(re2), RREGEXP_SRC_LEN(re1)) == 0);
}

Auch als == aliasisiert.

fixed_encoding? → true or false

Source

static VALUE
rb_reg_fixed_encoding_p(VALUE re)
{
    return RBOOL(FL_TEST(re, KCODE_FIXED));
}

Gibt false zurück, wenn self auf eine Zeichenkette mit einer beliebigen ASCII-kompatiblen Kodierung anwendbar ist; andernfalls gibt true zurück.

r = /a/                                          # => /a/
r.fixed_encoding?                               # => false
r.match?("\u{6666} a")                          # => true
r.match?("\xa1\xa2 a".force_encoding("euc-jp")) # => true
r.match?("abc".force_encoding("euc-jp"))        # => true

r = /a/u                                        # => /a/
r.fixed_encoding?                               # => true
r.match?("\u{6666} a")                          # => true
r.match?("\xa1\xa2".force_encoding("euc-jp"))   # Raises exception.
r.match?("abc".force_encoding("euc-jp"))        # => true

r = /\u{6666}/                                  # => /\u{6666}/
r.fixed_encoding?                               # => true
r.encoding                                      # => #<Encoding:UTF-8>
r.match?("\u{6666} a")                          # => true
r.match?("\xa1\xa2".force_encoding("euc-jp"))   # Raises exception.
r.match?("abc".force_encoding("euc-jp"))        # => false

hash → integer

Source

VALUE
rb_reg_hash(VALUE re)
{
    st_index_t hashval = reg_hash(re);
    return ST2FIX(hashval);
}

Gibt den ganzzahligen Hash-Wert für self zurück.

Verwandt: Object#hash.

inspect → String

Source

static VALUE
rb_reg_inspect(VALUE re)
{
    if (!RREGEXP_PTR(re) || !RREGEXP_SRC(re) || !RREGEXP_SRC_PTR(re)) {
        return rb_any_to_s(re);
    }
    return rb_reg_desc(re);
}

Gibt eine gut formatierte Zeichenkettenrepräsentation von self zurück.

/ab+c/ix.inspect # => "/ab+c/ix"

Verwandt: Regexp#to_s.

match(string, offset = 0) → matchdata or nil

match(string, offset = 0) {|matchdata| ... } → object

Source

static VALUE
rb_reg_match_m(int argc, VALUE *argv, VALUE re)
{
    VALUE result = Qnil, str, initpos;
    long pos;

    if (rb_scan_args(argc, argv, "11", &str, &initpos) == 2) {
        pos = NUM2LONG(initpos);
    }
    else {
        pos = 0;
    }

    pos = reg_match_pos(re, &str, pos, &result);
    if (pos < 0) {
        rb_backref_set(Qnil);
        return Qnil;
    }
    rb_match_busy(result);
    if (!NIL_P(result) && rb_block_given_p()) {
        return rb_yield(result);
    }
    return result;
}

Ohne Block wird das MatchData-Objekt zurückgegeben, das die Übereinstimmung beschreibt, falls vorhanden, oder nil, falls keine; die Suche beginnt an der angegebenen Zeichenposition offset in string.

/abra/.match('abracadabra')      # => #<MatchData "abra">
/abra/.match('abracadabra', 4)   # => #<MatchData "abra">
/abra/.match('abracadabra', 8)   # => nil
/abra/.match('abracadabra', 800) # => nil

string = "\u{5d0 5d1 5e8 5d0}cadabra"
/abra/.match(string, 7)          #=> #<MatchData "abra">
/abra/.match(string, 8)          #=> nil
/abra/.match(string.b, 8)        #=> #<MatchData "abra">

Mit einem Block wird der Block aufgerufen, wenn und nur wenn eine Übereinstimmung gefunden wird; der Wert des Blocks wird zurückgegeben.

/abra/.match('abracadabra') {|matchdata| p matchdata }
# => #<MatchData "abra">
/abra/.match('abracadabra', 4) {|matchdata| p matchdata }
# => #<MatchData "abra">
/abra/.match('abracadabra', 8) {|matchdata| p matchdata }
# => nil
/abra/.match('abracadabra', 8) {|marchdata| fail 'Cannot happen' }
# => nil

Ausgabe (aus den beiden ersten obigen Blöcken)

#<MatchData "abra">
#<MatchData "abra">

 /(.)(.)(.)/.match("abc")[2] # => "b"
 /(.)(.)/.match("abc", 1)[2] # => "c"

match?(string) → true or false

match?(string, offset = 0) → true or false

Source

static VALUE
rb_reg_match_m_p(int argc, VALUE *argv, VALUE re)
{
    long pos = rb_check_arity(argc, 1, 2) > 1 ? NUM2LONG(argv[1]) : 0;
    return rb_reg_match_p(re, argv[0], pos);
}

Gibt true oder false zurück, um anzugeben, ob der reguläre Ausdruck übereinstimmt oder nicht, ohne $~ und andere verwandte Variablen zu aktualisieren. Wenn der zweite Parameter vorhanden ist, gibt er die Position in der Zeichenkette an, an der die Suche beginnen soll.

/R.../.match?("Ruby")    # => true
/R.../.match?("Ruby", 1) # => false
/P.../.match?("Ruby")    # => false
$&                       # => nil

named_captures → hash

Source

static VALUE
rb_reg_named_captures(VALUE re)
{
    regex_t *reg = (rb_reg_check(re), RREGEXP_PTR(re));
    VALUE hash = rb_hash_new_with_size(onig_number_of_names(reg));
    onig_foreach_name(reg, reg_named_captures_iter, (void*)hash);
    return hash;
}

Gibt einen Hash zurück, der benannte Captures von self darstellt (siehe Benannte Captures).

Jeder Schlüssel ist der Name einer benannten Capture.
Jeder Wert ist ein Array von ganzzahligen Indizes für diese benannte Capture.

Beispiele

/(?<foo>.)(?<bar>.)/.named_captures # => {"foo"=>[1], "bar"=>[2]}
/(?<foo>.)(?<foo>.)/.named_captures # => {"foo"=>[1, 2]}
/(.)(.)/.named_captures             # => {}

names → array_of_names

Source

static VALUE
rb_reg_names(VALUE re)
{
    VALUE ary;
    rb_reg_check(re);
    ary = rb_ary_new_capa(onig_number_of_names(RREGEXP_PTR(re)));
    onig_foreach_name(RREGEXP_PTR(re), reg_names_iter, (void*)ary);
    return ary;
}

Gibt ein Array von Namen von Captures zurück (siehe Benannte Captures).

/(?<foo>.)(?<bar>.)(?<baz>.)/.names # => ["foo", "bar", "baz"]
/(?<foo>.)(?<foo>.)/.names          # => ["foo"]
/(.)(.)/.names                      # => []

options → integer

Source

static VALUE
rb_reg_options_m(VALUE re)
{
    int options = rb_reg_options(re);
    return INT2NUM(options);
}

Gibt eine Ganzzahl zurück, deren Bits die in self gesetzten Optionen anzeigen.

Die Optionsbits sind

Regexp::IGNORECASE # => 1
Regexp::EXTENDED   # => 2
Regexp::MULTILINE  # => 4

Beispiele

/foo/.options    # => 0
/foo/i.options   # => 1
/foo/x.options   # => 2
/foo/m.options   # => 4
/foo/mix.options # => 7

Beachten Sie, dass zusätzliche Bits in der zurückgegebenen Ganzzahl gesetzt sein können; diese werden intern in self verwaltet, werden ignoriert, wenn sie an Regexp.new übergeben werden, und können vom Aufrufer ignoriert werden.

Gibt den Satz von Bits zurück, die den beim Erstellen dieses regulären Ausdrucks verwendeten Optionen entsprechen (siehe Regexp::new für Details). Beachten Sie, dass zusätzliche Bits in den zurückgegebenen Optionen gesetzt sein können: diese werden intern vom regulären Ausdruckscode verwendet. Diese zusätzlichen Bits werden ignoriert, wenn die Optionen an Regexp::new übergeben werden.

r = /\xa1\xa2/e                 # => /\xa1\xa2/
r.source                        # => "\\xa1\\xa2"
r.options                       # => 16
Regexp.new(r.source, r.options) # => /\xa1\xa2/

source → string

Source

static VALUE
rb_reg_source(VALUE re)
{
    VALUE str;

    rb_reg_check(re);
    str = rb_str_dup(RREGEXP_SRC(re));
    return str;
}

Gibt die ursprüngliche Zeichenkette von self zurück.

/ab+c/ix.source # => "ab+c"

Regexp-Escape-Sequenzen bleiben erhalten.

/\x20\+/.source  # => "\\x20\\+"

Lexer-Escape-Zeichen bleiben nicht erhalten.

/\//.source  # => "/"

timeout → float or nil

Source

static VALUE
rb_reg_timeout_get(VALUE re)
{
    rb_reg_check(re);
    double d = hrtime2double(RREGEXP_PTR(re)->timelimit);
    if (d == 0.0) return Qnil;
    return DBL2NUM(d);
}

Gibt das Timeoutintervall für den Abgleich von Regexp in Sekunden zurück. nil bedeutet keine Standard-Timeoutkonfiguration.

Diese Konfiguration ist pro Objekt. Die durch Regexp.timeout= gesetzte globale Konfiguration wird ignoriert, wenn eine pro Objekt-Konfiguration gesetzt ist.

re = Regexp.new("^a*b?a*$", timeout: 1)
re.timeout               #=> 1.0
re =~ "a" * 100000 + "x" #=> regexp match timeout (RuntimeError)

to_json (*args)

Source

# File ext/json/lib/json/add/regexp.rb, line 45
def to_json(*args)
  as_json.to_json(*args)
end

Gibt einen JSON-String zurück, der self repräsentiert

require 'json/add/regexp'
puts /foo/.to_json

Ausgabe

{"json_class":"Regexp","o":0,"s":"foo"}

to_s → String

Source

static VALUE
rb_reg_to_s(VALUE re)
{
    return rb_reg_str_with_term(re, '/');
}

Gibt eine Zeichenkette zurück, die die Optionen und die Zeichenkette von self zeigt.

r0 = /ab+c/ix
s0 = r0.to_s # => "(?ix-m:ab+c)"

Die zurückgegebene Zeichenkette kann als Argument für Regexp.new oder als interpolierter Text für eine Regexp-Interpolation verwendet werden.

r1 = Regexp.new(s0) # => /(?ix-m:ab+c)/
r2 = /#{s0}/        # => /(?ix-m:ab+c)/

Beachten Sie, dass r1 und r2 nicht gleich r0 sind, da ihre ursprünglichen Zeichenketten unterschiedlich sind.

r0 == r1  # => false
r0.source # => "ab+c"
r1.source # => "(?ix-m:ab+c)"

Verwandt: Regexp#inspect.