= Diese Seite =
http://tinyurl.com/afra-2014-10-10-vortrag -->
http://www.guckes.net/vortraege/workshop.2014-10-10.afra.vim_regex.txt
http://www.guckes.net/vortraege/workshop.2014-10-10.afra.vim_regex.txt.html (bunt)
https://guckes.titanpad.com/33 Feedback während des Vortrags bitte hier reinschreiben

Latest change: Fr Okt 10 07:10:00 CEST 2014

= Event =

2014-10-10 Fr 20-22h @AFRA  "Muster in Vim"
der Gebrauch von Mustern im Texteditor Vim

Sven Guckes
mailto:workshop_vim_regex@guckes.net
crypto: 1024R/57F77F09 8000R/0185391B

kommentare, korrekturen und verbesserungen sind immer willkommen!
feedback with comments, corrections, and ideas are always welcome!

= Ort =

AFRA - rauchfreier hackerspace @afra_berlin
http://hackerspaces.org/wiki/AFRA
Herzbergstr. 55, 10365 Berlin
http://osm.org/go/0MbHkiUy-
http://osm.org/go/0MbHkiVqp--
"Herzbergstr/Siegfriedstr"
Tram M8+21+37, Bus 256+N56
240, N50 "Siegfriedstr/Josef-Orlopp-Str"

Übersicht zu den Vorträgen in der AFRA:
http://afra.in-berlin.de/dokuwiki/doku.php?id=vortraege

= Inhalt =

Ziel: Die Sprache der Muster (regulären Ausdrücke)
anhand von Beispielen im Editor Vim erlernen.

= Beschreibung =

(abstract)

Muster erlauben eine effiziente Beschreibung von Daten/Texten,
die oftmals zur Suche und bei der Ersetzung verwendet werden.
Wir schauen uns grundlegende Beispiele anhand des
Texteditors Vim (Vi IMproved) an, die aber auch
in vielen andere Tools zur Anwendung kommen.
Die Verwendung der Kommandos ":global" und ":substitute"
spielen hierbei eine spezielle Rolle.

= Einleitung =

1988: "Seminar zur Bildverarbeitung"
Minix.. shell,compiler.. Email.. elm -> vi.
1990: Usenet comp.editors  Nov1991 "vi imitation"
      webseite zu vim an der uni (fu-berlin.de)
      vim.org: Creation Date: 1997-09-15T04:00:00Z
      features: undo+redo, split windows, syntax coloring,
      folding, plugins, lua+perl+python+ruby, tabs..
2014: vim-7.4: improved regex parser.

Diese Probleme kommen immer wieder vor:

* Suchen:
** Wie findet man ein Satzende?
* Suchen+Ersetzen:
** Wie fügt man Text vor/nach einem Wort ein?
** Wie ändert man Worte mit kleinem Initial zum einem großen Initial?
** Wie erkennt man falsch geschriebenen Worte?
** Wie vertauscht man zwei aufeinanderfolgende Worte?

Erkennung/Verifizierung von:
* Emailadressen
* Internetadressen

Erkenntnis:
Wir suchen keine Einzelfälle, sondern
nach einer Menge von Fällen - einem *Muster*!

= Muster / RE =

Wir benutzen Zeichen mit spezieller Bedeutung,
um nicht nur nach einem möglichen Treffer zu suchen,
sondern nach einer *Menge* von möglichen Treffern.
Eine solchen Suchanfrage verwendet ein *Muster*.

Ein technischer Begriff für die *Sprache* dieser *Muster*
ist "regulärer Ausdruck" (regular expression, regex, RE).

Man unterscheidet im wesentlichen diese Typen:
BRE = Basic    Regular Expressions
ERE = Extended Regular Expressions

Erstmal grundlegende Muster anschauen.
Es gibt nämlich viel zu viele davon.
-> "Mastering Regular Expressions" (MRE)

= Suchen =

Gesucht wird im Text jeweils zeilenweise, dh die Datenmenge
wird durch Zeilenenden (End of Line, EOL) unterteilt.

Die Suche ist *zeilenorientiert*.
Die Treffer einer Suche sind
daher *Teil* einer Zeile.

Es gibt im wesentlichen drei unterschiedliche Zeilenenden:

    Macintosh:  CTRL-M          [0x0d]
  DOS/Windows:  CTRL-M + CTRL-J [0x0d 0x0a]
         Unix:           CTRL-J      [0x0a]

Gute Programme kennen alle drei,
dh  Erkennung  (beim Einlesen)
und Verwendung (beim Speichern).

see also:
    :help fileformat

== Zeilenanfang (BOL) und Zeilenende (EOL) ==

Zeichen zur Darstellung und Verwendung
des Zeilenanfangs bzw Zeilenendes:

    ^       Begin of Line (BOL)
    $       End   of Line (EOL)

Verwendung von ^ und $ als "Anker":

    ^foo    "foo" am Anfang der Zeile
    bar$    "bar" am Ende   der Zeile

Spezielle Kombination:
    ^foo$   Zeilen, die *nur* "foo" enthalten
    ^$      BOL direkt gefolgt von EOL -> "leere Zeile"

= Vim Highlight Search =

Exkurs:
Um Treffer besser zu sehen, gibt es die
Hervorhebung mittels "highlight search":

Anzeige der gefundenen Treffer:
    :set hls

Option umschalten (an/aus) (aka "toggle"):
    :set hls!

Umschaltbefehl auf ",h" legen:
    :map ,h :set hls!

= Wortanfang + Wortende =

Manche Suchworte sind in längeren Worten enthalten.
Sie sind daher als Treffer nicht immer relevant.
Bei der Suche kann man aber einen Wortanfang
bzw ein Wortende mit angeben:

  \<    Wortanfang
  \>    Wortende

   \   "bar" am Wortende

Die Kommandos * bzw # suchen nach dem *aktuellen* Wort -
(dem "Wort unter dem Cursor") vorwärts bzw rückwärts:

    \

trifft also nicht auf worte wie "teilwort" oder "wortzusatz".

see also:
  :help star

== Offset ==

Nach einer Suche wird der Cursor am Anfang des Treffer plaziert.
Für weitere Operationen ist es jedoch oftmals sinnvoll, den Cursor
vor bzw nach dem Beginn oder Ende des Treffer zu plazieren.
Ein entsprechender "Offset" kann bei der Suche angegeben werden:

see also:
    :help 27.3

Offset by Character:
Setzen des Cursors am *Ende* des Musters
mitsamt eines "search offset":

    /foo/b+23   Beginn des Treffers plus  23 Zeichen
    /foo/e-42   Ende   des Treffers minus 42 Zeichen

Offset by Line:
Findet die nächste Zeile mit "wort" darin -
und geht dann drei Zeilen weiter:
    /wort/3

= Punkt =

Das Zeichen "Punkt" steht für ein "beliebiges Zeichen".

    /a.c    findet "abc", "aXc", "a c", "a.c" ...
    /^..#   findet '#' nach zwei beliebigen Zeichen am Zeilenanfang
    /.      Zeile mit (mind) einem Zeichen -> nicht-leere Zeile

und wenn man wirklich mal nach einem Punkt sucht?
Dann muss man die besondere Bedeutung des Zeichens
durch Voranstellen eines Backslash (\) aufheben:

    /Ende\.     sucht das Wort "Ende", gefolgt von einem Punkt.

== Wiederholungen ==
:help 27.4

"Ungezählte" Wiederholungen:
    Muster:     Treffer:
    /a*         {}  a aa aaa aaaa  ...
    /[ab]*      {}  a b  aa ab ba bb  aaa aab aba abb ...
    /\(ab\)*    {}  ab abab ababab abababab ...
    /ab\+           ab abb abbb abbbb ...

Hierbei steht "{}" für die "leere Menge" bzw für das "leere Wort".

Spezifische Anzahl von Wiederholungen:
    /ab\{3,5}   abbb abbbb abbbbb

Oft übersehen:
Bei der Verwendung von '*' zählt immer
auch die 0-fache, dh die nicht-Wiederholung.
Darum paßt oftmals auch die leere Menge.

Beispiel:

    /^a*

Dieses Muster paßt auf *jede* Zeile, da
jede Zeile am Anfang auch NULL 'a' hat.

VORSICHT!

    /foo.*bar

"foo" gefolgt von "irgendwas" und "bar".
das "irgendwas" wird maximal ausgefüllt, dh
der Treffer endet hierbei beim *zweiten* "bar".

    foo blah bar blah bar

(Verifikation mittels "highlight search".)
Die Suche ist "greedy" (gierig, gefräßig).
Kein Bug, sondern ein Feature! (Vereinbarung)

== Mengen / Sets ==

    :help 27.6
    -> Character Range

Range: Bereich, Wertebereich, Wertemenge, hier: Zeichenmenge.

Menge:
    /[abcdefghijklmnopqrstuvwxyz]
    /[bcdfghjklmnpqrstvwxyz]  Konsonanten
    /[a-z]                  Buchstabe (engl)
    /[a-zäöüß]              Buchstabe (deu)
    /[0123456789abcdef]     Hexzeichen
    /[0-9a-f]               Hexzeichen mit ranges
    /\h                     Hexzeichen als Zeichenklasse

Komplementärmenge:
    /[^a-z]

Vorsicht!
Die Komplementärmenge ist vielleicht größer als angenommen.
Ein "[^aeiou]" ist *nicht* das Alphabet ohne die Vokale, sondern
*alle* Zeichen ausser den Vokalen, also (256-5)=251 Zeichen.

Erkennung von URLs:
"protokollname gefolgt von nicht-Leerzeichen"
    (finger|ftp|http|news|telnet)://[^ >"]*

Beispiele:
            
    

[natürlich gibt es hierbei keine Erkennung von gültigen
 Hostnames, Portnummern, Verzeichnissen und Dateinamen.]

Vordefinierte Mengen:
    \a      Alphabet            Buchstabe
    \d      Digit               Ziffer
    \s      Whitespace          "Weisses Zeichen" (space or tab)

    \l      lowercase alpha     kleiner Buchstabe
    \u      uppercase alpha     grosser Buchstabe

== Zeichenklassen ==
(skip?)
    :help 27.7
    "Character classes"

    \f  file name   character
    \i  identifier  character
    \k  keyword     character
    \p  printable   character

== Alternativen ==

(skip?)
    :help 27.5
    "Branches"

    /foo\|bar
    /eins\|zwei\|drei

== Zeilenenden ==
    :help 27.8
    -> "Matching a line break"

Vim kann auch Muster auffinden, die ein Zeilenende *enthalten*,
dh das Ende des Treffers kann auch auf der nächsten Zeile sein.

= PAUSE =

* Input + Output
* Lüften

mal ins textpad schauen..

= Beispiele =

so.. endlich Beispiele!

== Zeit HH:MM ==

Muster: [0-9][0-9]:[0-9][0-9]h
Muster: \d\d:\d\dh
aber:   42:67h ist dann ebenfalls eine gültige Zeitangabe. :-(

besser:
Muster: [012][0-9]:[0-5][0-9]h
aber:   29:59h ist ebenfalls gültig.

besser: Stunden nur von 00 bis 23:
Muster: ([01][0-9]|2[0-3])\(:[0-5][0-9]\)*

besser: Trenner ist Punkt oder Doppelpunkt,
        mit Angabe von "am", "pm" oder 'h':
Muster: ([01]\?[0-9]|2[0-3])\([.:][0-5][0-9]\)\?(am|pm|h)\?

== Datum ==

Muster:     YYYY-MM-DD
Beispiele:  1967-04-06
            1999-12-31
            2000-01-01
            2014-10-10

Muster:     \d\d\d\d-\d\d-\d\d
Kritik:     vieeel zu allgemein. ;)

Muster:     \(19\|20\)[0-9][0-9]-\(0[0-9]\|1[012]\)-\([012][0-9]\|3[01]\)
Muster:     \(19\|20\)\d\d-\(0\d\|1[012]\)-\([012]\d\|3[01]\)
Kritik:     YYYY-02-30 ist auch ein gültiges Datum.

== Emailadresse ==

Regeln:     Adresse ist UNabhängig von GROSS/kleinschreibung ("case").
Username    darf enthalten: Minus+Plus, Unterstriche, Ziffern und Punkte.
Hostname    darf enthalten: Minus+Plus, Unterstriche, Ziffern - aber keine Punkte.
TLD         (Top Level Domain) mindestens zwei bis maximal vier Buchstaben.
Muster:     [-_.+a-z0-9]\+@\([-a-z0-9].\)\+.[a-z]\{2,4\}

Alternative: TLDs aufzählen (ca 250).  homework. ;-)
    edu gov mil | com net org | biz info name | asia eu us |
    arpa biz com info name net org pro |
    aero asia cat coop edu gob int jobs mil mobi museum post tel travel xxx
    berlin linux onion
    localdomain

obsolete: bitnet uccp; cs dd su yu (->sr+me) zr (->cd)
see also: http://de.wikipedia.org/wiki/Top-Level-Domain

== Internetadresse ==

eine IPv4 Adresse:
Aufbau:  N.N.N.N
.. wobei N eine Zahl aus acht Bits ist, dh Dezimalwerte von 0 bis 255.
Die Zahlen von 0 bis 99 bestehen also aus zwei Ziffern - mit
einer zusätzlichen Eins davor werde daraus Wert von 100 bis 199.
Die Werte von 200 bis 255 kann man einteilen
in die Bereiche 200 bis 249, sowie 251 bis 255.
die zahlen sind heweils gefolt von eine Punkt -
nur der letzte Wert hat keinen Punkt am Ende:

Muster:
    \(\(1\?[0-9]\?[0-9]\|2[0-4][0-9]\|25[0-5]\)\.\)\{3}
      \(1\?[0-9]\?[0-9]\|2[0-4][0-9]\|25[0-5]\)

Beispiele:
    127.0.0.1
    10.10.10.10
    42.23.23.5
    192.168.1.1
    192.109.42.123
    telnet 130.133.1.10 13

Hausaufgabe:
* Welcher Service steckt hinter dem Port #13?
* Entwickle ein Muster für IPv6 Adressen:
  http://de.wikipedia.org/wiki/IPv6#Adressnotation
  http://tools.ietf.org/html/rfc4291
  ::1

== Wörter ==

Worte bestehen aus Buchstaben.
In der Sprache der REs werden sie hier mit "\w" notiert.
Man kann hierbei an "wortteile" denken.
Die Notation eines Komplementärzeichens
wird üblichreweise mit dem zugehörigen
Großbuchstaben bezeichnet, dh "\W".

Worte sind daher Sequenzen von Wortteilen,
mit einer Mindestlänge von 1.  Darum wird hierbei
das Wiederholungszeichen "\+" verwendet:

    \w\+            Wort
    \W\+            Nicht-Wort

see also:
    :help pattern-multi-items

= Suchen+Ersetzen =

Anwendung von Mustern bei "Suchen+Ersetzen".

Löschen des Leerraumes (whitespace) am Ende aller Zeilen:
    :%s/\s\+$//

Binden des Kommandos an die Kombination ",9":
    :map ,9  :%s/\s\+$//

Achtung:
Hierbei gibt es keinen simulierter Abschluß der Eingabe.
Das Akzeptieren/Ausführen mit ENTER/RETURN - oder ein
Abbrechen mit CTRL-C bzw ESC obliegt dann dem Benutzer.  feature!

Hinzufügen von "foo" am Anfang der (aktuellen) Zeile:
    :s/^/foo/

Hinzufügen von "foo" am Ende   der (aktuellen) Zeile:
    :s/$/foo/

Erweiterung auf "alle Zeilen" durch Angabe mit '%':

Text löschen durch Ersatz durch Nichts:
    :%s/blah//

Text einfügen durch Ersatz mit mehr:
    :%s/eins/eins und zwei/

Erhalten des Treffers mittels '&':
    :%s/foo/bar&/   -> barfoo
    :%s/foo/&bar/   -> foobar
    :%s/foo/&&/     -> foofoo

Substituieren mit dem Kommando ":s":
Grundeinstellung: Nur Substitution des *ersten* Treffers.
Danach Wechsel zur nächsten Zeile.
Daher gibt es auch die folgende "flags":
    c   "confirmation"  Bestätigung     Frage bei jedem Treffer nochmal nach
    g   "global"        "ganze Zeile"   Suche nach allen weiteren Treffer in der Zeile

= :Global =

Das "global" (:g) Kommando führt ein Kommando aus
in allen "treffenden Zeilen", dh Zeilen,
welche das gegeben Muster *enthalten*.

Die Syntax des Kommandos:

  :help :g
  :[range]g[lobal]/{pattern}/[cmd]
   Execute the Ex command [cmd] (default ":p") on the
   lines within [range] where {pattern} matches.

Das entsprechende Kommando "g!" für NICHT-treffende Zeilen:

  :help :g!
  :[range]g[lobal]!/{pattern}/[cmd]
   Execute the Ex command [cmd] (default ":p") on the
   lines within [range] where {pattern} does NOT match.

Ist keine "range" angegeben, so werden "alle Zeilen" angenommen.
(NB: bei "vi" gibt es nur "alle zeilen".)

Muster:  :g/foo/p   alle zeilen, die "foo" *enthalten*

Für "pattern" und "muster" schreiben wir
auch "RE" für "regular expression".

Ausgabe alle nicht-leeren Zeilen:
    :g!/^$/
    :g!/./

Ausgabe aller kommentierten Zeilen:
    :g/^#/

== g/RE/p ==

und weil ":g/RE/p" so praktisch zur Ausgabe aller treffenden
Zeilen ist, wurde es zu einem eigenen UNIX Kommando - "grep".

= :Global + cmd =

Anwendung des ":global" Kommandos in Verbindung mit
weiteren Kommandos der Kommandozeile (nu,d,co,mo,ya):
  :g/RE/p         print   drucke      Treffer anzeigen
  :g/RE/nu        number  nummer      Treffer anzeigen mit Zeilennummer
  :g/RE/d         delete  lösche      Treffer löschen
  :g/RE/j         join    verbinde    Trefferzeile mit folgender Zeile verbinden
  :g/RE/co $      copy    kopiere     Treffer ans Pufferende kopieren
  :g/RE/mo $      move    verschiebe  Treffer ans Pufferende verschieben
  :g/RE/ya a      yank    kopiere     Treffer ins Register 'a' (überschreibt!)
  :g/RE/ya A      yank    kopiere     Treffer ins Register 'a' (fügt an)

Bei Verwendung des *kleinen* Buchstabens überschreibt ein erneuter Treffer
jeweils den Inhalt des Registers; der letzte Treffer "gewinnt" also
und ist damit der alleinige Inhalt des Registers nach dem Ablauf.

Bei Verwendung des *grossen* Buchstabens wird jeder Treffer an das
Register *angehängt*, dh alle Treffer werden im Register aufgesammelt.
Für den Fall, daß das Register vor dem Kommando schon Daten enthält,
sollte man den Inhalt löschen.

Löschen aller leeren Zeilen:
    :g/^$/d

TALK...
    :g/^$/,/./-j

Die Kommandos auf der "(internen) Kommandozeile"
sind die Kommandos des unterliegenden Editors "ed".

Ausblick:
Vortrag in der AFRA am 2014-12-05
von Martin Neitzel über "ed":
"Ed is the standard text editor."
http://www.gnu.org/fun/jokes/ed-msg.html

= :g! =

Anwendung auf alle Nicht-Treffer mittels ":g!" oder ":v":

Loeschen all Zeilen, die "foo" *nicht* enthalten.
Muster: :g!/foo/d

Loeschen aller Zeilen, die *nicht* mindestens
ein beliebiges Zeichen enthalten:
Muster: :v/./d
.. also ein Löschen aller *leeren* Zeilen.

= global+subst =

":g"+":s"

Die spezielle Kombination der Kommandos ":global" und
":subst" erlaubt Änderungen in Abhängigkeit von Treffern:

Auskommentieren der Debug Zeilen, dh jene,
die eine Ausgabe mittels "echo" erzeugen:
Muster:   :g/echo/s/^/#

Änderungen nur in kommentierten Zeilen:
Muster:   :g/^\s*#/s:foo:bar:

== Spezial ==

Ein recht spezieller Fall:
Substitution bei überlappenden Mustern:

         a.*c
      v-------v
Text: aaabbbcccddd
         ^-------^
            b.*d

Lösung: Verbindung aus ":global" und ":subst":
    :g/b.*d/s/a.*c/XXX/

= Gedanke =

ein paar Gedanken zwischendurch:
wie viele Texteditoren erlauben die Verwendung von REs?
wie viele Texteditoren haben eine Art ":global" Kommando?

wie löst man diese Aufgaben in anderen Texteditoren?:

(1) Suche Zeilen mit zwei Datumsangaben (yyyy-mm-dd) - und vertausche sie.
(2) Schränke den Suchbereich ein auf die erste
    leere Zeile bis zur Zeile mit "EOF".
(3) Schränke die Substitution ein
    auf nur kommentierte Zeilen.

= Ausblick =

Muster kann man auch bei diesen Programmen verwenden (Auswahl):

  Programm  Beschreibung
  agrep     search a file for a string or regular expression,
              with approximate matching capabilities
  awk       pattern scanning and text processing language (dawk, gawk, mawk, nawk)
  bash      GNU Bourne-Again SHell (-> Pathname Expansion)
  ed        ed is the standard editor!  http://www.gnu.org/fun/jokes/ed-msg.html
  gawk      pattern scanning and processing language
  grep      print lines matching a pattern (finde Suchmuster in Dateien)
  less      "opposite of more" (text pager)
  mutt      The Mutt Mail User Agent (colorize folder index and messages)
  perl      Practical Extraction and Report Language
  sed       stream editor for filtering and transforming text

Genau genommen erlauben alle guten Editoren, Shells,
und Programmiersprachen die Verwendung von Mustern. :-)

Übrigens:
Die Einfärbung dieses Textes wird mithilfe von Mustern gemacht:
http://www.guckes.net/Setup/sven.vim (my Syntax File for Vim)

Ergebnis:
http://www.guckes.net/vortraege/workshop.2014-10-10.afra.vim_regex.txt.html (bunt)

= ENDE =

Soweit als Einstieg.
Danke für's Zuhören!

bei Interesse gerne weitere Vorträge+Workshops.

Bitte auch selber was herzeigen. Kurzvorträge.
Austausch ist wichtig. "Sharing is caring."
Insbesondere bezüglich Erfahrung+Wissen.

ab hier "Kür":

= Digraph Input =

(kleiner Exkurs)

Es gibt tausende von Zeichen, die auf den einfachen
Tastaturen mit nur wenig mehr als hundert Tasten
nicht alle direkt unterkommen können.
Zur Eingabe der "speziellen zeichen" bietet Vim
daher zwei weiteren Eingabemethoden:
die Eingabe über die Zeichennummer ("digit input")
und über Zeichenkombinationen von zwei Zeichen -
den "Digraph Input":

Eingabe per ASCII Nummer ("digit input"):
   :help i_CTRL-V
         i_CTRL-V 233 -> é

Eingabe per zeichenkombination ("Digraph Kommando"):
   :help i_CTRL-K
         i_CTRL-K  a : -> ä
         i_CTRL-K  E u -> €

Alternative:
Die Eingabe der Zeichenkombination mittels "Überschreiben"
des ersten Zeichens per "backspace" (CTRL-H):

    s CTRL-H s -> ß

Diese Eingabemethode geht aber nur, wenn
die Option "digraph" angeschaltet wird:
    :set digraph
    :help 'digraph'

übersicht der Digraph Kombinationen:
    :dig

== Übungen ==

Hier noch ein paar Übungen mit Vim:

Vorbereitung:
    :edit http://www.guckes.net/vortraege/workshop.2014-10-10.afra.vim_regex.txt
    :set hls

Suchanfragen:
    /^=.*=$
    /http:.*
    /:help

    :g/Muster
    :g//nu

    :/^= Links/,$d

= MOAR? =

weitere UNIX tools, die REs verwenden:

== grep ==

Ausgabe nicht der gesamten treffenden Zeilen,
sondern nur der Treffer selbst ("only"):
  $ grep -o 'http:[^ ]' $file

Treffer in Farbe anzeigen:
  $ grep --color=always ...

Einstellung der Farben ->
  "man grep" /GREP_COLORS

== mmv ==

Umbenennung von Dateien -
Leerzeichen zu Unterstrichen:

  $ mmv '* *' '#1_#2'

== rename ==

"rename" renames the filenames supplied according to the rule
specified as the first argument.  The perlexpr argument is a
Perl expression which is expected to modify the $_ string
in Perl for at least some of the filenames specified.

delete/strip the extension ",bak":
  $ rename 's/\.bak$//' *.bak

translate uppercase names to lower:
  $ rename 'y/A-Z/a-z/' *

changing spaces to underscores:
  $ rename 's/ /_/g'   '* *'

= Shells =

Anwendung von Mustern in Shells, insb für "filename globbing".

zsh: inline expansion with TAB
    $ ls -l ~/.??*

zitieren quoting -> metacharacters + escape characters

== zmv ==

    $ zmv '* *' '$f:gs/ /_'

= Homework =

Die eingebaute Hilfe von Vim zum Thema:

   :help usr_27.txt
   "Search commands and patterns"

Das Handbuch/Manual über Reguläre Ausdrücke
("regular expressions", kurz: "regex"):

  $ man 7 regex

weitere Manuals:

  $ man -k regex
  DateTime::Format::Builder::Parser::Regex (3pm) - Regex based date parsing
  Inline::C::ParseRegExp (3pm) - The New and Improved Inline::C Parser
  re_comp (3)          - BSD regex functions
  re_exec (3)          - BSD regex functions
  regcomp (3)          - POSIX regex functions
  regerror (3)         - POSIX regex functions
  regex (3)            - POSIX regex functions
  regex (7)            - POSIX.2 regular expressions
  regexec (3)          - POSIX regex functions
  regfree (3)          - POSIX regex functions
  Tie::Hash::NamedCapture (3perl) - Named regexp capture buffers
  XML::LibXML::RegExp (3pm) - XML::LibXML::RegExp - interface to libxml2 regular expressions
  XML::RegExp (3pm)    - Regular expressions for XML tokens

= Glossar =

TODO

sets (mengen) (bracket expression)
classes

negation        Verneinung -> Komplementärmenge
greediness      Begehrlichkeit, Gierigkeit, Gefräßigkeit

atoms           Atome (unteilbare Einheit)
pieces          Stücke
branches        Zweige, Verzweigungen

repetitions     Wiederholungen
groups          Gruppen

"escaping with backslash" aka "quoting"
the dot aka "anychar"

= Links =

"Regulärer Ausdruck"
http://de.wikipedia.org/wiki/Regul%C3%A4rer_Ausdruck

"Perl Compatible Regular Expressions"
http://de.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions
http://de.wikipedia.org/wiki/PCRE

"Jeffrey Friedl's Mastering Regular Expressions"
http://regex.info/

"Pattern (Java 2 Platform SE v1.4.2) - regex"
http://java.sun.com/j2se/1.4.2/docs/api/java/util/regex/Pattern.html

"Regex for URLs"
http://www.foad.org/~abigail/Perl/url2.html

"C-SLang documentation (regex, too)"
http://www.macroexpressions.com/doc/snob/snobre.htm

"FoxyProxy - Filtern von Suchanfragen über einen Proxy"
http://foxyproxy.mozdev.org/quickstart.html

"Regular Expression Tutorial and Reference"
http://www.regular-expressions.info/
One of the most comprehensive, free regular expression tutorials on the net.

"RegexAdvice.com"
http://regexadvice.com/
Forums and blogs dedicated to regular expressions.

"Regular Expression Library"
http://www.regexlib.com/
Currently contains over 1000 expressions from contributors around the world.

"Using Regular Expressions"
http://etext.lib.virginia.edu/services/helpsheets/unix/regex.html
Brief introduction to regular expressions

"Regular Expression Cheat Sheet"
http://regexlib.com/cheatsheet.aspx
A one page printable reference for regular expressions

"Regular expressions"
http://rudd-o.com/projects/wp-search-replace/wp-search-replace-regexptut/
a short tutorial A five-minute tutorial on how to learn the most useful regular expressions

"A List of Regex Topics"
http://wiki.castlecops.com/A_list_of_Regex_topics
Wiki with various topics about regular expressions.

"Mastering Regular Expressions"
http://www.regex.info/
Official website for Jeffrey Friedl's book.

"Regenechsen"
http://www.regenechsen.de/phpwcms/index.php?regex_englisch
Beginners regular expression tutorial with exercises.  (auch auf Deutsch)

"How to Find or Validate an Email Address"
http://www.regular-expressions.info/email.html

"Examples of Regular Expressions"
https://support.google.com/a/answer/1371417?hl=en

"Reguläre Ausdrücke"
http://de.selfhtml.org/perl/sprache/regexpr.htm

"Reguläre Ausdrücke"
http://de.wikipedia.org/wiki/Regul%C3%A4rer_Ausdruck
"Ken Thompson nutzte diese Notation in den 1960ern,
 um qed (eine Vorgängerversion des Unix-Editors ed)
 zu bauen und später das Werkzeug grep zu schreiben."

"Vim - Search and Replace"
http://vim.wikia.com/wiki/Search_and_replace

"Vim Regex"
http://vimregex.com/

"Best of Vim Tips"
old: http://rayninfo.co.uk/vimtips.html
new: http://zzapper.co.uk/vimtips.html

= Books =

Jahr ISBN-13            Titel                             Autoren
2001 978-0-7357-1001-6  "vi Improved - VIM"               Steve Oualline
1997 978-1565922570     "Mastering Regular Expressions"   Jeffrey Friedl
2006 978-0596528126     "Mastering Regular Expressions"   Jeffrey Friedl
2008 978-0-596-52983-3  "Learning the vi and Vim Editors" Arnold Robbins, Linda Lamb + Elbert Hannah
2008 978-3-8266-1781-2  "vim 7 GE-PACKT: vi improved"     Reinhard Wobst
2010 978-1-84951-050-9  "Hacking Vim 7.2"                 Kim Schulz
2011 978-3-8266-8190-8  "vim 7.3 GE-PACKT"                Reinhard Wobst
2011 978-3897213210     "vi und Vim - kurz & gut"         Arnold Robbins
2012 978-1-934356-98-2  "Practical Vim..."                Drew Neil