ACHTUNG. Das ist ein Archiv des alten forum.ruby-portal.de. Die aktuelle Mailingliste gibt es auf lists.ruby-lang.org/pipermail/ruby-de.

NOTICE. This is a ready-only copy of the old forum.ruby-portal.de. You can find the current mailing list at lists.ruby-lang.org/pipermail/ruby-de.

Die Programmiersprache Ruby

Blog|

Forum|

Wiki  


Alle Zeiten sind UTC + 1 Stunde [ Sommerzeit ]

Ein neues Thema erstellen Auf das Thema antworten  [ 38 Beiträge ]  Gehe zu Seite 1, 2, 3  Nächste
Autor Nachricht
 Betreff des Beitrags: k<name+n> [=>Ruby-Mine] [erledigt]
BeitragVerfasst: 26 Jan 2009, 16:09 
Offline
Interpreter

Registriert: 15 Mär 2005, 19:26
Beiträge: 6142
Wohnort: Karlsruhe
Moin, moin!

Obwohl ich ursprünglich den Anstoss für diese Konstruktion gab (siehe Reguläre Ausdrücke, Teil 5: Benannte Gruppen, Palindrome, Taschenrechner und Klammergebirge. unter Palindrome), habe ich immer noch grosse Probleme damit, wirklich sinnvolle Anwendungen zu finden.

Der Text zu der Konstruktion in http://www.geocities.jp/kosako3/oniguruma/doc/RE.txt ist auch nicht besonders umfangreich und liefert nur zwei Beispiele, wovon eins mein Palindrom-Beispiel ist...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
  back reference with nest level

level: 0, 1, 2, ...

\k<n+level> (n >= 1)
\k<n-level> (n >= 1)
\k'n+level' (n >= 1)
\k'n-level' (n >= 1)

\k<name+level>
\k<name-level>
\k'name+level'
\k'name-level'

Destinate relative nest level from back reference position.

ex 1.

/\A(?<a>|.|(?:(?<b>.)\g<a>\k<b+0>))\z/.match("reer")

ex 2.

r = Regexp.compile(<<'__REGEXP__'.strip, Regexp::EXTENDED)
(?<element> \g<stag> \g<content>* \g<etag> ){0}
(?<stag> < \g<name> \s* > ){0}
(?<name> [a-zA-Z_:]+ ){0}
(?<content> [^<&]+ (\g<element> | [^<&]+)* ){0}
(?<etag> </ \k<name+1> >){0}
\g<element>
__REGEXP__

p r.match('<foo>f<bar>bbb</bar>f</foo>').captures

Nachdem ich in den Beispielen zur PickAxe3 bisher auch nichts zu dem Thema gefunden habe (wer die schon existierende pdf-Ausgabe besitzt, kann dazu vielleicht etwas mehr sagen), starte ich diesen Thread mit der Hoffnung, dass sich hier Beispiele ansammeln.

Da mir zuerst einmal nicht so klar war, wie das mit den verschiedenen Levels funktioniert, habe ich einfach mal ein bisschen experimentiert...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
p 'abaxcx'.match(/(?<b>(?<c>.)\g<a>){0}
(?<a>a
\g<b>|c\k<c-1>){0}
^
\g<a>$/x
)
# => #<MatchData "abaxcx" b:"baxcx" c:"x" a:"abaxcx">

p 'abaxcx'.match(/(?<c>.){0}
(?<b>
\g<c>\g<a>){0}
(?<a>a
\g<b>|c\k<c-0>){0}
^
\g<a>$/x
)
# => #<MatchData "abaxcx" c:"x" b:"baxcx" a:"abaxcx">
# Aufruffolge:
# <a>a<b><c>b</c><a>a<b><c>x</c><a>c\k<c-0></a></b></a></b></a>

p 'ayaxcy'.match(/(?<b>(?<c>.)\g<a>){0}
(?<a>a
\g<b>|c\k<c-3>){0}
^
\g<a>$/x
)
# => #<MatchData "ayaxcy" b:"yaxcy" c:"x" a:"ayaxcy">

p 'ayaxcy'.match(/(?<c>.){0}
(?<b>
\g<c>\g<a>){0}
(?<a>a
\g<b>|c\k<c-2>){0}
^
\g<a>$/x
)
# => #<MatchData "ayaxcy" c:"x" b:"yaxcy" a:"ayaxcy">

p '(y1)(x2)[y3]'.match(/(?<c>[a-z]){0}
(?<b>
\g<c>[0-9]){0}
(?<a>
\(\g<b>\)\g<a>|\[\k<c-0>[0-9]\]){0}
^
\g<a>$/x
)
# => #<MatchData "(y1)(x2)[y3]" c:"x" b:"x2" a:"(y1)(x2)[y3]">

p '(y1)(x2)[y3]'.match(/(?<c>[a-z]){0}
(?<b>
\g<c>[0-9]\)\g<a>){0}
(?<a>
\(\g<b>|\[\k<c-2>[0-9]\]){0}
^
\g<a>$/x
)
# => #<MatchData "(y1)(x2)[y3]" c:"x" b:"y1)(x2)[y3]" a:"(y1)(x2)[y3]">

p '(y1)(x2)[x3]'.match(/(?<c>[a-z]){0}
(?<b>
\g<c>[0-9]\)\g<a>){0}
(?<a>
\(\g<b>|\[\k<c-0>[0-9]\]){0}
^
\g<a>$/x
)
# => #<MatchData "(y1)(x2)[x3]" c:"x" b:"y1)(x2)[x3]" a:"(y1)(x2)[x3]">
..., wobei ich, ehrlich gesagt, die Level-Angabe erst nach experimentellen Korrekturen hinbekam.

Abgesehen davon sind das auch nicht wirklich Beispiele, nach denen die Welt schreit :?

Ich werde in den nächsten Tagen mal versuchen ein paar Beispiele zu finden, die das Verständnis zur Level-Angabe etwas verbessern. Vielleicht kommen dabei ja auch ein paar echte Anwendungen heraus.

Hat jemand von Euch da schon mehr gemacht?

_________________
WoNáDo.set_state!(:retired)


Zuletzt geändert von WoNáDo am 09 Feb 2009, 18:30, insgesamt 5-mal geändert.

Nach oben
 Profil  
 
 Betreff des Beitrags:
BeitragVerfasst: 29 Jan 2009, 11:37 
Offline
Interpreter

Registriert: 15 Mär 2005, 19:26
Beiträge: 6142
Wohnort: Karlsruhe
:( Hat sich bisher wirklich niemand näher damit beschäftigt - schade.

Ich werde dann mal versuchen das mit den Level-Bezügen irgendwie genauer zu beschreiben, weil es durchaus verwirrend sein kann (finde ich jedenfalls).

@cypher: Steht in der PFD-PickAxe3 irgendwas darüber?

_________________
WoNáDo.set_state!(:retired)


Nach oben
 Profil  
 
 Betreff des Beitrags:
BeitragVerfasst: 29 Jan 2009, 12:40 
Offline
Interpreter
Benutzeravatar

Registriert: 05 Jun 2005, 01:54
Beiträge: 3225
In der Pickaxe werden sie (nur?) zum Palindrom-Matchen verwendet. 3 Beispiele hab ich dazu gefunden:

1
2
3
# 4-character palindrome matcher
"abab" =~ /(.)(.)\k<-1>\k<-2>/ # => nil
"abba" =~ /(.)(.)\k<-1>\k<-2>/ # => 0
Das 3. Beispiel ist das Oniguruma-Beispiel, mit folgender Notiz:
Programming Ruby 1.9 hat geschrieben:
The notation


\k<some_letter+0>
means that the letter matched at the end of the inner palindrome will be the same letter that was at the start of it.

_________________


1
2
3
alias L lambda
p L{|y|L{|f|y[L{|x|f[f][x]}]}[L{|f|y[L{|x|f[f][x]}]}]}[L{|z|L{|l|l.empty?? 0:1+z[l.drop(1)]}}][%w<a b c d e f g h i j>]
#=>10


Nuclear Powered Soup | Nuclear Powered Blog


Nach oben
 Profil  
 
 Betreff des Beitrags:
BeitragVerfasst: 29 Jan 2009, 17:32 
Offline
Interpreter

Registriert: 15 Mär 2005, 19:26
Beiträge: 6142
Wohnort: Karlsruhe
cypher hat geschrieben:


1
2
3
# 4-character palindrome matcher
"abab" =~ /(.)(.)\k<-1>\k<-2>/ # => nil
"abba" =~ /(.)(.)\k<-1>\k<-2>/ # => 0

Das ist ein anderes Konstrukt. Es bezieht sich rückwärts relativ auf die einfangende Gruppe. Ich meine das andere, welches sich auf den Call-Level durch \g bezieht.

Sieht aber so aus, als wenn ich mir da mal die Frage zur Antwort einfallen lassen muss...

PS: Leider sind die beiden semantisch völlig unterschiedlichen Konstruktionen syntaktisch sehr ähnlich. Das obige PickAxe-Beispiel bezieht sich auf...
Oniguruma-Doc hat geschrieben:
8. Back reference

\n back reference by group number (n >= 1)
\k<n> back reference by group number (n >= 1)
\k'n' back reference by group number (n >= 1)
\k<-n> back reference by relative group number (n >= 1)
\k'-n' back reference by relative group number (n >= 1)
\k<name> back reference by group name
\k'name' back reference by group name


nochnPS:
cypher hat geschrieben:
Programming Ruby 1.9 hat geschrieben:
The notation


\k<some_letter+0>
means that the letter matched at the end of the inner palindrome will be the same letter that was at the start of it.

...ich glaube wirklich, dass wir da eine etwas genauere Erklärung hinbekommen.

_________________
WoNáDo.set_state!(:retired)


Nach oben
 Profil  
 
 Betreff des Beitrags:
BeitragVerfasst: 29 Jan 2009, 20:49 
Offline
Interpreter

Registriert: 15 Mär 2005, 19:26
Beiträge: 6142
Wohnort: Karlsruhe
Ich beende diesen Thread mal, weil ich gerade angefangen habe, mir über Reguläre Ausdrücke, Teil 7: Variablen in aufgerufenen Untermustern finden für Ruby-Mine Gedanken zu machen (der Titel muss noch besser werden).

Da das doch recht umfangreich wird, passt es besser dorthin als hier in Threads.

Dauert aber noch ein paar Tage, wobei ich hoffe, relativ kurz nach Erscheinen der offiziellen 1.9.1er Release was zu haben.

_________________
WoNáDo.set_state!(:retired)


Nach oben
 Profil  
 
 Betreff des Beitrags:
BeitragVerfasst: 01 Feb 2009, 13:54 
Offline
Interpreter

Registriert: 15 Mär 2005, 19:26
Beiträge: 6142
Wohnort: Karlsruhe
Ich habe ein kleines Illustrationsproblem. Ich möchte mittels ganz einfacher Ascii-Mittel den Ablauf für die Beispiele beschreiben. Irgendwelche echten grafischen Hilfsmittel will ich nicht verwenden.

Ich habe mir dafür eine kleine Beschreibungssprache überlegt, am Beispiel...

1
2
3
4
5
6
7
8
9
Text:   (     y 1 )   (     x 2 )   [ x     3 ]

4: > . <
3: > . < > c . < > . c:3+1 . . <
2: > c . < > . b . a <
1: > . b . a <
0: a

Step: a b c d e f g h i j k l m n o p q r s t
..., welches zu...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
p '(y1)(x2)[x3]'.match(/(?<c>       # Definition Untermuster <c>
[a-z] # Erkenne Kleinbuchstaben
){0} # Ende Untermuster <c>

(?<b> # Definition Untermuster <b>
\g<c> # Aufruf von Untermuster <c>
[0-9] # Erkenne Ziffer
){0} # Ende Untermuster <b>

(?<a> # Definition Untermuster <a>
\( # Erkenne "Klammer auf"
\g<b> # Aufruf von Untermuster <b>
\) # Erkenne "Klammer zu"
\g<a> # Aufruf von Untermuster <a>
| # Oder
\[ # Erkenne "Eckige Klammer auf"
# ******************************************
\k<c+1> # Erkenne von Untermuster <c> ein
# Aufrufniveau hoeher gefundenen
# String
# ******************************************
[0-9] # Erkenne Ziffer
\] # Erkenne "Eckige Klammer zu"
){0} # Ende Untermuster <a>

# Hauptmuster
\A # Erkenne Stringanfang
\g<a> # Aufruf von Untermuster <a>
\z # Erkenne Stringanfang
/x
) # Musterende
# Ergebnis:
# => #<MatchData "(y1)(x2)[x3]" c:"x" b:"x2" a:"(y1)(x2)[x3]">
gehört, gezeigt.

Links steht als Nummer gefolgt von einem Doppelpunkt das Aufrufniveau, unten (im Beispiel "a" bis "t") die Reihenfolge der Ausführung, oben das in einem Ausführungsschritt gegebenenfalls erkannte Zeichen und dazwischen das, was die RegEx-Maschine tut.

Hier bedeutet ein Punkt, dass das oben stehende Zeichen erkannt wird und ein einzelner Buchstabe, dass der so bezeichnete Block mittels "\g" aufgerufen wird. Die über dem Buchstaben stehende öffnende spitze Klammer kennzeichnet den Beginn der Blockausführung, eine schliessende spitze Klammer das Ende mit Rückkehr auf das nächst niedrigere Niveau. Um Platz in der Darstellungsbreite zu sparen (das soll ja nach Ruby-Mine), geht es direkt unter der schliessenden spitzen Klammer weiter, die ja auch keine explizite Aktion darstellt.

Eine Besonderheit ist die Konstruktion: "Buchstabe", "Doppelpunkt", "Zahl", "Plus/Minus" und "Zahl", die sich auf die relative Blockniveau-Referenz bezieht (im Beispiel "c:3+1" auf "\k<c+1>"). Dabei ist die erste Ziffer das aktuelle Niveau in dem diese Referenz ausgeführt wird. Wenn man die Addition/Subtraktion ausführt erhält man das gesuchte Niveau.

Nun meine Frage:

Kennt jemand von Euch eine allgemein bekannte Notation die ich dafür benutzen kann, die aber auch kompakt und textuell (Ascii) darstellbar ist :?:

Mir wäre es lieber so etwas zu benutzen anstatt eine eigene unvollkommene erfinden zu müssen.

_________________
WoNáDo.set_state!(:retired)


Nach oben
 Profil  
 
 Betreff des Beitrags:
BeitragVerfasst: 01 Feb 2009, 16:10 
Offline
Hacker

Registriert: 24 Nov 2008, 14:56
Beiträge: 475
ähm... ein bild sagt mehr als 1000 worte... aus dem was du dort ascii like aufgeschrieben hast werd ich keinen meter schlau und erinnert mich eher an brainfuck. also wenn das beispiele sein sollen, dann wären einfache beispiele doch etwas sinnvoller oder meinst du nicht?

ich muss allerdings gestehen, das ich noch nie ein fan von regex war, sie mir in einigen situationen aber sicher weitergeholfen hätten...

gruß,
tom.


Nach oben
 Profil  
 
 Betreff des Beitrags:
BeitragVerfasst: 01 Feb 2009, 19:13 
Offline
Interpreter

Registriert: 15 Mär 2005, 19:26
Beiträge: 6142
Wohnort: Karlsruhe
case hat geschrieben:
...also wenn das beispiele sein sollen, dann wären einfache beispiele doch etwas sinnvoller oder meinst du nicht?

Das sind schon die einfachen Beispiele für diese Konstruktion in Oniguruma. Einfachere sind nur noch die aus dem RegEx-Dokument der Oniguruma-Seite (habe ich oben im Thread aufgeführt). Diese gestatten es aber nicht durch einfache Modifikation die Bedeutung der Konstruktion \k<var+/-n> für unterschiedliche Werte von n und unterschiedliche Vorzeichen zu erklären.

...aber...

Diese Konstruktion, wie auch \g<var>, gehört mit Sicherheit zu den gewagtesten Elementen von Oniguruma - mit echten regulären Ausdrücken hat das nun überhaupt nichts mehr zu tun.

Beschreiben will ich das auch in erster Linie deshalb, weil diese Konstruktionen in Ruby ab 1.9.1 zur Verfügung stehen, es aber offensichtlich keine erklärende Beschreibung mit Beispielen dafür gibt (auch nicht in der neuen PickAxe3).

Aber zur Beruhigung - im demnächst in Ruby-Mine erscheinenden Artikel wird diese Grafik, wie auch drei weitere, sehr ausführlich erklärt.

Mir geht es bei der Frage darum, ob jemand, der mit den Konstruktionen \k<var+/-n> und \g<var> schon etwas anfangen kann eine bessere Ablaufsübersichtsbeschreibung (A27g) kennt.

case hat geschrieben:
ich muss allerdings gestehen, das ich noch nie ein fan von regex war, sie mir in einigen situationen aber sicher weitergeholfen hätten...

Dieser geplante Artikel, wie auch zwei weitere, die damit zusammenhängen, macht Sinn, wenn man den Friedl gut kennt, sed/awk/Perl in diesem Zusammenhang nutzen kann und die anderen Teile meiner RegEx-Ruby-Mine-Artikel verstanden hat.

Um reguläre Ausdrücke in normalen Anwendungen zu benutzen, sind diese Konstruktionen nicht nötig. Ich benutze all diese Sachen in erster Linie für ad hoc-Anwendungen, also den Ruby-Einsatz als Swiss-Knife. Das sind dann write-only-Programme der Kategorie Zehnzeiler, die man nach ein/zwei Anwendungen nicht mehr benötigt, weil man sie sich schnell wieder zusammenstricken kann.

_________________
WoNáDo.set_state!(:retired)


Nach oben
 Profil  
 
 Betreff des Beitrags:
BeitragVerfasst: 01 Feb 2009, 19:21 
Offline
Interpreter
Benutzeravatar

Registriert: 21 Mai 2007, 11:30
Beiträge: 1283
Wohnort: Thüringen
Ich habe von regulären Ausdrücken nur rudimentäres Wissen. Mir ist aber aufgefallen, dass man mit diesen benannten Gruppen rekursive reguläre Ausdrücke schreiben kann.
Das ist natürlich ziemlich witzig, weil man damit theoretisch auch reguläre Ausdrücke für XML schreiben kann. Oder sehe ich das falsch?

Hier mal ein etwas primitives Beispiel welches natürlich kein richtiges XML darstellt:


1
2
3
4
5
reg = /\A
(?<knoten>
\<(?<typ>\w+)\>\g<knoten>+\<\/\k<typ>\> | \w+
)
\Z/x


Nachteil: \k wird nur einmal belegt. Man müsste also eine fest definierte Anzahl an Knotentypen haben und diese in den fest regexp einbauen.


Nach oben
 Profil  
 
 Betreff des Beitrags:
BeitragVerfasst: 01 Feb 2009, 19:43 
Offline
Interpreter

Registriert: 15 Mär 2005, 19:26
Beiträge: 6142
Wohnort: Karlsruhe
Schau Dir mal das Beispiel aus der Oniguruma-Dok an (oben im ersten Beitrag). Das geht so in diese Richtung.

Mit der Rekursion und auch mit Fallen, die sich durch die von cypher angesprochene statische Relativaddressierung entschärfen lassen, beschäftigt sich der erste Teil des gerade im Schreiben begriffenen Artikels.

Wegen der Rekursion nur noch mal das Paradebeispiel überhaupt (aus den alten Ruby-Mine-Artikeln. Einfach mal kopieren und laufen lassen...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# encoding: Windows-1252
pattern = / (?<e>\g<t>\+\g<e>|\g<t>-\g<e>|\g<t>){0}
(?<t>|
\g<f>\*\g<t>|\g<f>\/\g<t>|\g<f>){0}
(?<f>[-+]?
\g<id>|\(\g<e>\)){0}
(?<id>
\g<n>|\g<v>){0}
(?<n>[a-zA-Z_]
\w*){0}
(?<v>
\d+(\.\d+)?){0}
^((?<var>
\g<n>)=)?(?<expr>\g<e>)$
/x


vars = Hash.new(0)
basbind = binding

# print 'input> ' # nur bei interaktiver Benutzung sinnvoll
while (!(inp = DATA.gets).chomp.match(/^quit$/i))
if (md = inp.chomp.gsub(/\s+/,'').match(pattern))
expr = md[:expr].gsub(/([a-zA-Z_]\w*)/, 'vars["\1"]')
erg = eval(expr, basbind)
vars[md[:var]] = erg if md[:var]
puts "#{inp.chomp}, Ergebnis> #{(md[:var])?(md[:var]+'='):''}#{erg}"
else
puts "+++++ Inkorrekte Eingabe: '#{inp.chomp}'"
end
# print 'input> ' # nur bei interaktiver Benutzung sinnvoll
end
puts '***** Variablen *****'
vars.keys.sort.each{|v|puts "#{v}=#{vars[v]}"}
puts '******* Ende ********'
__END__
30+12
a = 30 + 12
b = 2*a
c = -(a*a+5)
d = (6+5*a)*c
quit

_________________
WoNáDo.set_state!(:retired)


Nach oben
 Profil  
 
 Betreff des Beitrags:
BeitragVerfasst: 01 Feb 2009, 19:55 
Offline
Interpreter
Benutzeravatar

Registriert: 21 Mai 2007, 11:30
Beiträge: 1283
Wohnort: Thüringen
Ich blicke in dem regulären Ausdruck zwar nicht durch (*g*), glaube aber zu verstehen worauf der Code hinausläuft.

Ist es mit Oniguruma also möglich z.B. die Syntax eines ganzen Rubyprogramms über einen regulären Ausdruck zu validieren?


Nach oben
 Profil  
 
 Betreff des Beitrags:
BeitragVerfasst: 01 Feb 2009, 20:12 
Offline
Interpreter

Registriert: 15 Mär 2005, 19:26
Beiträge: 6142
Wohnort: Karlsruhe
Kai hat geschrieben:
Ist es mit Oniguruma also möglich z.B. die Syntax eines ganzen Rubyprogramms über einen regulären Ausdruck zu validieren?

Im Prinzip ja, aber...

Die von mir angegebene Grammatik ist nicht ganz sauber, weil ich ja Linksrekursivität vermeiden muss. Das spielt in diesem Fall, vor allem weil die arithmetischen Ausdrücke ja nicht ausgewertet werden, keine Rolle.

Nun kann man ja aber wohl eine Grammatik mit Linksrekursion in eine ohne so etwas umwandeln (siehe Drachenbuch o.Ä), also müsste es möglich sein die rein syntaktischen Elemente darzustellen. Jede semantische Analyse entfällt dabei aber.

Ob das aber mit Ruby's Spezialitäten geht (man denke nur an die Neuerung, dass ein Zeilenende nicht das Ende eine Methodenkette ist, wenn die nächste Zeile mit einem Punkt beginnt), wage ich zu bezweifeln.

Sinnvoll ist so etwas wohl kaum.

Für Beispiele der Preisklasse der arithmetischen Ausdrückenkönnte ich mir aber echte Anwendungen vorstellen, wenn Ruby anstelle von Javascript Client-seitig laufen würde. Dann der Inhalt eines Eingabefeldes vor Absendung an den Server auf einfache Art und Weise geprüft werden.

Kai hat geschrieben:
Ich blicke in dem regulären Ausdruck zwar nicht durch...

Schau Dir mal den Artikel in Ruby-Mine an - das ist eigentlich ganz einfach, nur halt eine sehr kompakte Notation.

_________________
WoNáDo.set_state!(:retired)


Nach oben
 Profil  
 
 Betreff des Beitrags:
BeitragVerfasst: 02 Feb 2009, 13:17 
Offline
Metaprogrammierer

Registriert: 03 Feb 2008, 15:36
Beiträge: 682
Wohnort: Aachen, NRW
aiaia...also ich blick da ja mal überhaupt garnicht mehr durch o_O
bislang hab ich mich immer auf ganz einfache Ausdrücke beschränkt.
Ich glaub die Regex-Artikelserie in der Mine muss ich nochmal mit viel Aufmerksamkeit durchlesen =D

_________________
-


Nach oben
 Profil  
 
 Betreff des Beitrags:
BeitragVerfasst: 06 Feb 2009, 02:10 
Offline
Interpreter

Registriert: 15 Mär 2005, 19:26
Beiträge: 6142
Wohnort: Karlsruhe
cypher hat geschrieben:
In der Pickaxe werden sie (nur?) zum Palindrom-Matchen verwendet. 3 Beispiele hab ich dazu gefunden:

1
2
3
# 4-character palindrome matcher
"abab" =~ /(.)(.)\k<-1>\k<-2>/ # => nil
"abba" =~ /(.)(.)\k<-1>\k<-2>/ # => 0

Weiss eigentlich jemand, seit wann diese Art statischer Relativbezüge in Oniguruma existiert?

In älterer Oniguruma-Doc habe ich sie noch nicht, dabei helfen sie wirklich dabei ein Problem zu lösen (Erklärungen kommen im ersten Ruby-Mine-Beitrag, weil zu lang).

_________________
WoNáDo.set_state!(:retired)


Nach oben
 Profil  
 
 Betreff des Beitrags:
BeitragVerfasst: 06 Feb 2009, 14:01 
Offline
Interpreter

Registriert: 15 Mär 2005, 19:26
Beiträge: 6142
Wohnort: Karlsruhe
WoNáDo hat geschrieben:
Weiss eigentlich jemand, seit wann diese Art statischer Relativbezüge in Oniguruma existiert?

Habe es jetzt selber gefunden - die wurden ganz unauffällig in Oniguruma 5.9.1 eingeführt.
HISTORY_5X.txt hat geschrieben:
2007/12/22: Version 5.9.1
...
2007/08/02: [spec] add backref by number.

Eigentlich wollte ich ja nur einen Ruby-Mine-Beitrag wegen der dynamischen Relativbezüge schreiben, wobei mir immer noch richtig wichtige Anwendungen fehlen. Dank cypher bin ich aber jetzt überhaupt erst auf diese statische Art Relativbezüge gestossen - die wirklich ungeheuer viel bringen.

Dadurch ist es jetzt wirklich möglich problemlos Bibliotheken für reguläre Ausdrücke zu schreiben, und diese dann ganz einfach an beliebiger Stelle und beliebig oft mittels #{...} zu benutzen - man muss dann in solchen Fällen halt nur auf benannte Gruppen verzichten, was aber eher problemlos ist.

Die Benutzung von \k<-n> und \g<-n> erinnert mich ein wenig an längst vergangene Assembler-Programmierzeiten mit Relativsprüngen...

_________________
WoNáDo.set_state!(:retired)


Nach oben
 Profil  
 
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  [ 38 Beiträge ]  Gehe zu Seite 1, 2, 3  Nächste

Alle Zeiten sind UTC + 1 Stunde [ Sommerzeit ]


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 1 Gast


Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.

Suche nach: