# Reguläre Ausdrücke vereinfachen



## armitage (4. Mrz 2007)

Hallo. 

Gibt es eine Möglichkeit (Bibliothek, Tool) Java-Regex-Ausdrücke zu vereinfachen? (Also die Anzahl der Operatoren auf die Konkatenation, |, *, (,), epsilon zu reduzieren.) Theoretisch geht es ja mit jedem regulären Ausdruck.

Danke im Voraus.


----------



## Wildcard (4. Mrz 2007)

Wenn du die anderen Sachen nicht brauchst, dann benutz sie nicht  ???:L


----------



## armitage (4. Mrz 2007)

Bitte, wenn du nichts zum Thema zu sagen hast, brauchst du auch nicht zu antworten. Ich glaube, ich habe die Problemmstellung klar beschrieben. 

Bitte antwortet nur, wenn ihr wißt, was ihr schreibt.

Danke


----------



## Roar (4. Mrz 2007)

das geht natürlich nicht, wieso sollte auch.
wenn du die anderen sachen nicht brauchst, benutz sie nicht 
oder pars deinen ausdruck selbst.


----------



## Wildcard (4. Mrz 2007)

armitage hat gesagt.:
			
		

> Bitte antwortet nur, wenn ihr wißt, was ihr schreibt.


Ich weiß idR was ich schreibe, also maul hier nicht rum.
Ich sehe keinen Grund eine Lib zu schreiben die nichts anderes tut als den Sprachumfang von Regulären Ausdrücken zu verringern, daher ist stark zu bezweifeln das etwas derartiges existiert, insbesondere da die API dadurch nicht vereinfacht wird.
Da anscheinend die Nichtverwendung der restlichen sprachlichen Mittel für dich aus Gründen die du uns nicht nennen willst nicht in Frage kommt, so wird dir wohl die neu Implementierung der RegEx Lib oder eine Wrapper Klasse die automatisch maskiert nicht erspart bleiben.


----------



## armitage (4. Mrz 2007)

Wieso sollte das nicht gehen ???  ???:L 

a{5} = aaaaa

a? = a|epsilon

[a-c] = ((a|b)|c)

usw. 

Natürlich geht das!!!  ???:L 

Ich frage auch nicht, ob es geht, sondern ob es eine Bibliothek gibt, die es erledigt.


----------



## armitage (4. Mrz 2007)

Niemand mault hier rum. Lies meine Frage und deine erste Antwort. Die sagt gar nichts aus und hilft kein bisschen. Ich habe natürlich meine Gründe, wieso ich mit einfachen REGEX arbeiten will. Sie sind leichter zu parsen und man kann leichter formale Aussagen über sie treffen. 

Mittlerweile habe ich, glaube ich, gefunden, was ich brauche. Apache Regex bietet simple Syntax von regulären Ausdrücken. 

Aber trotzdem Danke.


----------



## Wildcard (4. Mrz 2007)

Apache Regexp hat beinahe den gleichen Sprachumfang wie das SUN Paket  :roll:


----------



## Guest (4. Mrz 2007)

@Wildcard
:autsch: Geht's noch?


----------



## Wildcard (4. Mrz 2007)

Beide sind *weit* davon deine Forderung zu erfüllen:


> Anzahl der Operatoren auf die Konkatenation, |, *, (,), epsilon zu reduzieren.



Apache:

```
Characters

    unicodeChar   Matches any identical unicode character
    \                    Used to quote a meta-character (like '*')
    \\                   Matches a single '\' character
    \0nnn                Matches a given octal character
    \xhh                 Matches a given 8-bit hexadecimal character
    \\uhhhh              Matches a given 16-bit hexadecimal character
    \t                   Matches an ASCII tab character
    \n                   Matches an ASCII newline character
    \r                   Matches an ASCII return character
    \f                   Matches an ASCII form feed character


  Character Classes

    [abc]                Simple character class
    [a-zA-Z]             Character class with ranges
    [^abc]               Negated character class
 

NOTE: Incomplete ranges will be interpreted as "starts from zero" or "ends with last character".
I.e. [-a] is the same as [\\u0000-a], and [a-] is the same as [a-\\uFFFF], [-] means "all characters".

  Standard POSIX Character Classes

    [:alnum:]            Alphanumeric characters.
    [:alpha:]            Alphabetic characters.
    [:blank:]            Space and tab characters.
    [:cntrl:]            Control characters.
    [:digit:]            Numeric characters.
    [:graph:]            Characters that are printable and are also visible.
                         (A space is printable, but not visible, while an
                         `a' is both.)
    [:lower:]            Lower-case alphabetic characters.
    [:print:]            Printable characters (characters that are not
                         control characters.)
    [:punct:]            Punctuation characters (characters that are not letter,
                         digits, control characters, or space characters).
    [:space:]            Space characters (such as space, tab, and formfeed,
                         to name a few).
    [:upper:]            Upper-case alphabetic characters.
    [:xdigit:]           Characters that are hexadecimal digits.


  Non-standard POSIX-style Character Classes

    [:javastart:]        Start of a Java identifier
    [:javapart:]         Part of a Java identifier


  Predefined Classes

    .         Matches any character other than newline
    \w        Matches a "word" character (alphanumeric plus "_")
    \W        Matches a non-word character
    \s        Matches a whitespace character
    \S        Matches a non-whitespace character
    \d        Matches a digit character
    \D        Matches a non-digit character


  Boundary Matchers

    ^         Matches only at the beginning of a line
    $         Matches only at the end of a line
    \b        Matches only at a word boundary
    \B        Matches only at a non-word boundary


  Greedy Closures

    A*        Matches A 0 or more times (greedy)
    A+        Matches A 1 or more times (greedy)
    A?        Matches A 1 or 0 times (greedy)
    A{n}      Matches A exactly n times (greedy)
    A{n,}     Matches A at least n times (greedy)
    A{n,m}    Matches A at least n but not more than m times (greedy)


  Reluctant Closures

    A*?       Matches A 0 or more times (reluctant)
    A+?       Matches A 1 or more times (reluctant)
    A??       Matches A 0 or 1 times (reluctant)


  Logical Operators

    AB        Matches A followed by B
    A|B       Matches either A or B
    (A)       Used for subexpression grouping
   (?:A)      Used for subexpression clustering (just like grouping but
              no backrefs)


  Backreferences

    \1    Backreference to 1st parenthesized subexpression
    \2    Backreference to 2nd parenthesized subexpression
    \3    Backreference to 3rd parenthesized subexpression
    \4    Backreference to 4th parenthesized subexpression
    \5    Backreference to 5th parenthesized subexpression
    \6    Backreference to 6th parenthesized subexpression
    \7    Backreference to 7th parenthesized subexpression
    \8    Backreference to 8th parenthesized subexpression
    \9    Backreference to 9th parenthesized subexpression
```

SUN:

```
x  	The character x
\\ 	The backslash character
\0n 	The character with octal value 0n (0 <= n <= 7)
\0nn 	The character with octal value 0nn (0 <= n <= 7)
\0mnn 	The character with octal value 0mnn (0 <= m <= 3, 0 <= n <= 7)
\xhh 	The character with hexadecimal value 0xhh
\uhhhh 	The character with hexadecimal value 0xhhhh
\t 	The tab character ('\u0009')
\n 	The newline (line feed) character ('\u000A')
\r 	The carriage-return character ('\u000D')
\f 	The form-feed character ('\u000C')
\a 	The alert (bell) character ('\u0007')
\e 	The escape character ('\u001B')
\cx 	The control character corresponding to x
 
Character classes
[abc] 	a, b, or c (simple class)
[^abc] 	Any character except a, b, or c (negation)
[a-zA-Z] 	a through z or A through Z, inclusive (range)
[a-d[m-p]] 	a through d, or m through p: [a-dm-p] (union)
[a-z&&[def]] 	d, e, or f (intersection)
[a-z&&[^bc]] 	a through z, except for b and c: [ad-z] (subtraction)
[a-z&&[^m-p]] 	a through z, and not m through p: [a-lq-z](subtraction)
 
Predefined character classes
. 	Any character (may or may not match line terminators)
\d 	A digit: [0-9]
\D 	A non-digit: [^0-9]
\s 	A whitespace character: [ \t\n\x0B\f\r]
\S 	A non-whitespace character: [^\s]
\w 	A word character: [a-zA-Z_0-9]
\W 	A non-word character: [^\w]
 
POSIX character classes (US-ASCII only)
\p{Lower} 	A lower-case alphabetic character: [a-z]
\p{Upper} 	An upper-case alphabetic character:[A-Z]
\p{ASCII} 	All ASCII:[\x00-\x7F]
\p{Alpha} 	An alphabetic character:[\p{Lower}\p{Upper}]
\p{Digit} 	A decimal digit: [0-9]
\p{Alnum} 	An alphanumeric character:[\p{Alpha}\p{Digit}]
\p{Punct} 	Punctuation: One of !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Graph} 	A visible character: [\p{Alnum}\p{Punct}]
\p{Print} 	A printable character: [\p{Graph}\x20]
\p{Blank} 	A space or a tab: [ \t]
\p{Cntrl} 	A control character: [\x00-\x1F\x7F]
\p{XDigit} 	A hexadecimal digit: [0-9a-fA-F]
\p{Space} 	A whitespace character: [ \t\n\x0B\f\r]
 
java.lang.Character classes (simple java character type)
\p{javaLowerCase} 	Equivalent to java.lang.Character.isLowerCase()
\p{javaUpperCase} 	Equivalent to java.lang.Character.isUpperCase()
\p{javaWhitespace} 	Equivalent to java.lang.Character.isWhitespace()
\p{javaMirrored} 	Equivalent to java.lang.Character.isMirrored()
 
Classes for Unicode blocks and categories
\p{InGreek} 	A character in the Greek block (simple block)
\p{Lu} 	An uppercase letter (simple category)
\p{Sc} 	A currency symbol
\P{InGreek} 	Any character except one in the Greek block (negation)
[\p{L}&&[^\p{Lu}]]  	Any letter except an uppercase letter (subtraction)
 
Boundary matchers
^ 	The beginning of a line
$ 	The end of a line
\b 	A word boundary
\B 	A non-word boundary
\A 	The beginning of the input
\G 	The end of the previous match
\Z 	The end of the input but for the final terminator, if any
\z 	The end of the input
 
Greedy quantifiers
X? 	X, once or not at all
X* 	X, zero or more times
X+ 	X, one or more times
X{n} 	X, exactly n times
X{n,} 	X, at least n times
X{n,m} 	X, at least n but not more than m times
 
Reluctant quantifiers
X?? 	X, once or not at all
X*? 	X, zero or more times
X+? 	X, one or more times
X{n}? 	X, exactly n times
X{n,}? 	X, at least n times
X{n,m}? 	X, at least n but not more than m times
 
Possessive quantifiers
X?+ 	X, once or not at all
X*+ 	X, zero or more times
X++ 	X, one or more times
X{n}+ 	X, exactly n times
X{n,}+ 	X, at least n times
X{n,m}+ 	X, at least n but not more than m times
 
Logical operators
XY 	X followed by Y
X|Y 	Either X or Y
(X) 	X, as a capturing group
 
Back references
\n 	Whatever the nth capturing group matched
 
Quotation
\ 	Nothing, but quotes the following character
\Q 	Nothing, but quotes all characters until \E
\E 	Nothing, but ends quoting started by \Q
 
Special constructs (non-capturing)
(?:X) 	X, as a non-capturing group
(?idmsux-idmsux)  	Nothing, but turns match flags on - off
(?idmsux-idmsux:X)   	X, as a non-capturing group with the given flags on - off
(?=X) 	X, via zero-width positive lookahead
(?!X) 	X, via zero-width negative lookahead
(?<=X) 	X, via zero-width positive lookbehind
(?<!X) 	X, via zero-width negative lookbehind
(?>X) 	X, as an independent, non-capturing group
```
 :roll:


----------



## thomator (5. Mrz 2007)

> @Wildcard
> Geht's noch?


Da ich mal davon ausgehe, dass Gast = armitage:
Du maulst nicht nur, Du bist wahrscheinlich auch mit nem ICE durch die Kinderstube gerast.
So, das musste jetzt sein...


----------



## Lim_Dul (5. Mrz 2007)

Edit: Hab Unfug geschrieben, sorry


----------



## thomator (5. Mrz 2007)

Mir ging es auch in keiner Weise um den Inhalt der Posts, sondern um die Art und Weise. Der Ton macht halt die Musik...


----------



## Wildcard (5. Mrz 2007)

thomator hat gesagt.:
			
		

> Mir ging es auch in keiner Weise um den Inhalt der Posts, sondern um die Art und Weise. Der Ton macht halt die Musik...


#
Kann ich nur zustimmen. Aber wie das eben so läuft hat armitage das nächste mal einen neuen Nick und bekommt wie jeder andere geholfen.  :?


----------



## thomator (5. Mrz 2007)

Jupp, leider...


----------



## armitage (5. Mrz 2007)

@Thomator

Ich brauche meinen Nick nicht zu ändern, um meine Meinung zu sagen. Für sowas habe ich echt keine Zeit. "Gast" war jemand anderes.

@Wildcard

Leider hast du vermutlich Recht mit Apache Regex. Ich habe irgendwo gelesen, dass diese Bibliothek sowas wie eine Umwandlung der allgemeinen regulären Ausdrücke in die mit der einfachen Syntax unzterstützt. Stimmt aber scheinbar nicht. da muss ich wohl selber parsen.


----------



## besucher via google (15. Okt 2009)

ich bin hier zufällig per google-suche vorbeigekommen

dafür dass die moderatoren die gestellte frage nicht verstehen, machen sie ganz schön weit den mund auf

der fragesteller suchte nach einem tool das regex-ausdrücke umformt
also z.b. wenn ich einen komplizierten regex-ausdruck habe, den ich in eine maschine geben will, die für regex-ausdrücke nur einen beschränkten Sprachumfang versteht
solche umformungen sind möglich, jemand der in seinem studium theoretische informatik hatte weiß das

aber die moderatoren hier verstehen nur bahnhof und glauben, der fragesteller sucht eine java-bibliothek für reguläre ausdrücke mit reduziertem sprachumfang
es wirft kein gutes licht auf dieses forum, dass moderatoren hier offensichtlich nicht in der lage sind sich eine eigene unfähigkeit einzugestehen

wer mir antworten will, kann das auf Benutzer Diskussion:Nequmodiva ? Uncyclopedia tun


----------



## Spacerat (15. Okt 2009)

besucher via google hat gesagt.:


> ich bin hier zufällig per google-suche vorbeigekommen
> 
> dafür dass die moderatoren die gestellte frage nicht verstehen, machen sie ganz schön weit den mund auf
> 
> ...


...Zumindest kennen unsere Moderatoren den Unterschied zwischen Umformen und Reduzieren und der Fragesteller hat nach einer Lib gesucht die Sun-Regex auf das wesenliche reduziert. Wildcards Antwort ist deswegen durchaus berechtigt.
@Wildcard: ähh... heisst das nicht "...und wird wie jeder andere geholfen? :lol:


----------



## Wildcard (15. Okt 2009)

Sehen wir von der fachlichen Seite dieses Threads mal völlig ab, dann bleibt noch immer die Tatsache bestehen das der Thread gute 2,5 Jahre alt ist und zu dieser Zeit war ich hier noch nicht mal Moderator.
Ach, und ich hatte übrigens meine Vorlesungen in theoretischer Informatik...


----------



## 0x7F800000 (16. Okt 2009)

armitage hat gesagt.:


> (Also die Anzahl der Operatoren auf die Konkatenation, |, *, (,), epsilon zu reduzieren.) Theoretisch geht es ja mit jedem regulären Ausdruck.





> solche umformungen sind möglich, jemand der in seinem studium theoretische informatik hatte weiß das


Ich hatte theoretische Informatik im Studium, und ich kann dir 100% garantieren, dass es _nicht_ geht. Praktisch würde es schon an den ersten zwei Gründen scheitern. Theoretisch geht es auch nicht, wie das dritte Beispiel zeigt: 

*1) *Stell dir mal vor, du verwendest 2-3 mal [c][^a]+[/c] in deinem Regex. Dann ist dein regex schonmal tausende von zeichen lang, denn da müssen alle Chars und alle maskierten Symbole mit einem "oder" verknüpft rein, bis auf das [c]a[/c].

*2)* Ausdrücke wie [c]x{1,10000}[/c] können sich exponentiell zur länge des ursprünglichen Regex aufblähen.

*3)*Sowas wie [c]\1[/c] kann prinzipiell nicht durch einen echten *Reg*ex ausgedrückt werden, weil DEA's immer nur begrenzten "Speicherplatz" zur Verfügung haben, d.h. immer nur endlich viele Zustände annehmen können.

Also: nein, es gibt definitiv keine Bibliothek, die "java-regex" in "klassische regex" übersetzt. Das ist nicht machbar. Da musst du wohl spezielle regex-klasse "für Forschungszwecke" schreiben :noe:

edit: wtf, 2007'er Thread?? Langeweile?


----------

