Sed

SED - eine kleine Einführung und Übersicht über ein mächtiges UNIX-Werkzeug

Was ist sed und was kann sed ?

sed (Stream-EDitor) ist ein universelles Textbearbeitungstool und auf jedem UNIX- und Linux-System zu finden. Ein Texteditor im gewöhnlichen Sinn, ist ein Programm mit dem wir mittels Tastatur einen Text erstellen oder ändern können, und genau das ist sed nicht.

Der Stream-Editor liest die Standardeingabe, (oder wenn angegeben eine oder mehrere Dateien) ein, ändert diesen Text nach einem "programmiertem Rezept" welches wir ihm beim Aufruf mitgeben ab, und gibt den so geänderten Text auf der Standardausgabe (oder umgeleitet auch als Datei) wieder aus. Es handelt sich also um einen universell programmierbaren Text-Bearbeitungs-Filter, mit dem wir nicht interaktiv arbeiten, sondern dem wir beim Programmaufruf Regeln mitgeben, nach denen ein Text zu ändern ist.

sed wurde 1973/74 von Lee E. McMahon entwickelt. Es ist eine interpretierende Scriptsprache mit sehr begrenzten Funktionsmöglichkeiten und speziell für die Bearbeitung von Text ausgelegt. Sie baut direkt auf Regulären Ausdrücken auf und umfasst nur wenige Befehle. Alle Befehle und Schlüsselworte bestehen nur aus einem einzigem Zeichen, entweder Buchstabe oder Sonderzeichen. Nahe Verwandte von sed sind der Zeileneditor ed (der zwar noch auf den meisten Systemen installiert ist, aber doch stark in die Jahre gekommen ist und kaum noch Verwendung findet) und der klassische UNIX Standard-Editor vi.

sed erlaubt eine sehr kompakte Programmierung. Für einen Ungübten sehen kleine Programme auf den ersten Blick oftmals wie eine zufällige Folge von Buchstaben und Sonderzeichen aus, Der Anteil der Sonderzeichen kann in einer einzelnen Zeile bisweilen erschreckend hoch werden. Folgendes kleines Beispiel zeigt eine etwas längere typischen Befehlszeile.

 sed 's/ //g;s/\(^.*\),\(.*$\)/\2,\1/;s/\(^.*\),\(.*,\)\(.*$\)/\1 \3 \2/;s/,/ /g'

Diese Zeile hat durchaus einen Sinn und eine Funktion, sie wurde auch nicht boshafter Weise extra kompliziert geschrieben, sondern das ist normale SED-Sprache. Eine solche Befehlszeile wird man sich natürlich nicht merken können und kaum buchstabieren können, ja man kann sie kaum fehlerfrei abschreiben, eventuelle Fehler durch fehlerhafte Schreibweise oder auch logische Fehler sind deshalb auch sehr schwer zu erkennen und zu beseitigen. Das war auch einer der Gründe für die Entstehung von awk

Die auf dem ersten Blick sehr ungewöhnliche Schreibweise wird bei etwas Beschäftigung mit sed schon durchsichtiger, und wer sich öfter und intensiver mit sed beschäftigt, wird durchaus schnell bemerken, wie hilfreich diese kryptische Sprache ist. Für manch einen ist es sogar eine Art Kult geworden und sie haben zur Übung, Demonstration oder aus Spaß mit sed die brauchbarsten und die unmöglichsten Dinge, sogar kleine Spiele mit sed programmiert. In diesem SED Script Archiv sind einige solcher Programme zu finden. Weitere sed-scripte und weitere Spiele gibt es auf einer der wichtigsten SED-Seiten (Web-Seiten geschrieben übrigens mit ? : natürlich mit sed ;-)))

Heute gibt es eine Vielzahl von sed Implementierungen für die unterschiedlichsten Betriebssysteme die zT die eine oder andere Erweiterung unterstützen oder nicht. Unterschiede gibt es vor allem im Umfeld der Regulären Ausdrücke, da es dort einige Spezifikationen gibt, die sich in Details unterscheiden. Unter Linux haben wir ein sehr leistungsfähiges GNUsed das einige Erweiterungen beinhaltet, die nicht unbedingt portabel zu anderen Sed-Versionen sind.

Für was benötigen wir sed heute ?

Mit sed lassen sich kleinere Probleme schnell und effektiv lösen. Solche sed-Programme sind meist Einzeiler und werden nicht nur innerhalb von Scripten und der Shell benutzt, sondern durchaus auch einmal aus anderen Programmen oder Programmiersprachen heraus. Auch dort wird hin und wieder einmal auf eine Shellfunktion mit sed-Befehlszeile zurückgegriffen.

Für Randprobleme besonders bei Ein- und Ausgabe oder bei Konvertierung von Textdateien ist sed oftmals ein sehr hilfreiches Tool. Darüber hinaus kann man sed überall dort einsetzen, wo häufig und regelmäßig immer die selben oder ähnliche Dinge erledigt werden sollen, oder wo viele Textdateien nach einem ganz bestimmten Muster verändert werden sollen. Beispiele hierfür sind z.B:

• Umwandlung von Textausgaben in bestimmte andere Formate oder zurück (z.B: Text nach HTML oder HTML nach Text);
• Extrahieren bestimmter Abschnitte aus Texten, oder bestimmte Textformatierungen
• das Ändern oder Korrigieren von Kleinigkeiten über viele HTML-Dateien oder an vielen Quellcode-Dateien

Überall dort wo der Aufwand für manuelle Änderung am Text ansteigt, wird sed interessant. Mit dem Stream Editor lassen sich eine Vielzahl von Standardkommandos von UNIX simulieren. Auch diese Standardkommandos haben alle ihre Ausnahmen und Problemfälle, und auch dort kann man hin und wieder einmal sed als die Lösung für solche Problemfälle finden.

Wer gezielt im WWW sucht, wird eine ganze Reihe von kleinen hilfreichen Anwendungen und Tricks rund um sed finden, Für viele Dinge, wie gezieltes Suchen, Extrahieren oder Änderungen in umfangreichen Texten, in vielen Dateien oder zur automatischen Bearbeitung von z.B. Konfigurationsdateien, wird man wohl auch morgen noch gerne auf sed zurückgreifen. Wenn moderne Programmiersprachen zu groß und mächtig oder unangemessen für winzige Probleme sind, oder wenn auf einige größere Standard-Tools auf Klein- und Minimalsystemen mal verzeichtet werden muss, dann ist eventuell sed als die kleine elegante Lösung die beste Option.

Für viele kleine Dinge ist sed durchaus gut geeignet, besonders wenn es sich kurz und knapp auf einer Zeile programmieren läßt, für viele Dinge insbesondere bei listenähnlichen Texten ist awk (wenn auch etwas langsamer bei der Arbeit) aber dennoch meist besser geeignet. Man sollte sed auch nicht dort einsetzen, wo die normalen Standard-Tools oder Programme das gewünschte Ergebnis mit vertretbaren Aufwand selbst liefern können, diese sind schneller und oftmals auch genauer. Bei größeren und komplizierten Probleme wird man freiwillig und gerne auf eine höhere Programmiersprache wie z.B. Perl oder Phyton ausweichen.

das Funktionsprinzip

Das Prinzip von sed ist recht simpel, aber man muss es sich genau verinnerlichen, sonst bekommt man schnell Verständnisprobleme beim Schreiben oder Interpretieren von sed-Programmen.

Beim Aufruf von sed werden die Regeln zum Ändern des Textes beim Programmaufruf mit übergeben. Wird keine Datei angegeben, dann nimmt sed den Standardeingabekanal als Eingangsdatei, wird eine Datei angegeben, dann diese. Werden mehrere Dateien angegeben, dann werden die Dateien der Reihe nach bearbeitet, und zwar werden die Dateien aneinander gereiht, der Zeilenzähler wird also bei einer neuen Datei nicht wieder zurückgesetzt. Die Ausgabe erfolgt auf der Standardausgabe und kann von hier mit den normalen Umleitungen auch an andere Befehle übergeben werden, oder in eine Datei umgeleitet werden. Die Eingangsdateien werden also nicht geändert.

sed hat einen Textbuffer den sogenannten Musterspeicher, dieser ist beim Starten des Programms leer. In diesen Musterspeicher wird die erste Zeile der Eingangsdatei geladen. Jetzt werden die Regeln auf diesen Musterspeicher angewendet und diese Zeile damit entsprechend geändert oder auch nicht. Sind alle Regeln abgearbeitet, dann wird der Inhalt des jetzt geänderten Musterspeichers nach stdout ausgegeben. Der Musterspeicher wird gelöscht und die nächste Zeile geladen, usw bis alle Zeilen der Eingabe verarbeitet sind. Beim Laden der neuen Zeile wird jeweils der interne Zeilenzähler um eins erhöht. Diesen Zeilenzähler können wir auch im sed-Program abfragen und auswerten.

Das Grundverhalten, dass sed jede bearbeitete Zeile selbstständig ausgibt bevor die nächste Zeile geladen wird, können wir mit einer Option beim Start von sed verhindern. Dann müssen wir jedoch innerhalb der Regeln festlegen, was sed denn ausgeben soll, wir müssen also "Print-Befehle" benutzen. Die Option bei Aufruf von sed dazu ist "-n".

Angenommen wir wollen aus einem Text die 2. Zeile löschen, dann müssen wir ohne Benutzung der Option -n die Regel nur so angeben, dass die 2. Zeile gelöscht oder übersprungen wird. Verwenden wir jedoch die Option -n so müssen wir ersteinmal dafür sorgen, dass wir alle Zeilen ausgeben und nur die 2. Zeile entweder bei der Ausgabe überspringen oder erst löschen bevor wir den dann leeren Buffer ausgeben.
Das sind oftmals fast gegensätzliche Ansatzweisen für den gesamten Programmablauf, und innerhalb des Programms benötigen wir dabei oftmals gegensätzliche Befehle oder Optionen. Welche Option für welche Aufgabe jeweils besser geeignet ist, müssen wir beim Erstellen eines sed-Programms von Aufgabe zu Aufgabe selbst entscheiden. In der Anfangszeit, bei den ersten Programmierversuchen, wird es öfter passieren, dass entweder Zeilen doppelt vorkommen, oder gar keine oder nur unvollständige Ausgaben kommen, nicht selten Option -n ;-))

was beinhaltet sed und was kann man damit machen

Neben dem Musterspeicher gibt es noch einen 2. Textbuffer, den sogenannten Haltespeicher. Auch dieser ist beim Start des Programms leer. In ihm könnte man jetzt z.B. den Inhalt des Musterspeichers kopieren und den Inhalt dort solange aufbewahren, bis er zu einem späteren Zeitpunkt benötigt wird, und dann wieder in den Musterspeicher laden. Hierfür gibt es einige sed Kommandos mit denen die Daten zwischen diesen beiden Textbuffern ausgetauscht werden also:

• Musterspeicher durch Haltespeicher ersetzen
• Haltespeicher durch Musterspeicher ersetzen
• Inhalt von Halte- und Musterspeicher tauschen
• Inhalt von Musterspeicher an den Haltespeicher anhängen
• Inhalt von Haltespeicher an den Musterspeicher anhängen

Im Haltespeicher selbst kann aber nichts abgefragt oder gar verändert werden. Er dient nur zum Zwischenspeichern.

Und was geht jetzt mit dem Musterspeicher?
Einige Funktionen mehr, denn hier kann auch der Inhalt geändert werden, und von hier aus werden auch die Ausgaben gemacht z.B.:

• Musterspeicher löschen
• die nächste Zeile einlesen
• die nächste Zeile hinten hinzufügen
• Musterspeicher nach stdout ausgeben
• Inhalte mit dem Haltespeicher austauschen
• den Musterspeicher leeren dafür aber einen im Programm enthaltenen Text ausgeben
• oder diesen Text vor dem Inhalt oder erst nach dem Inhalt des aktuellen Musterspeichers ausgeben
• den Musterspeicher in eine Datei schreiben
• Programmsprung je nach dem ob bestimmte Befehle den Musterspeicher geändert haben oder nicht
• einzelne Zeichen durch andere Zeichen ersetzen (ähnlich dem Befehl tr)
• und das Wichtigste, innerhalb des Musterspeichers suchen und ersetzen

Variablen ?

außer dem Haltespeicher und der Variable in der sed automatisch die Eingabezeilen zählt, die wir aber nicht selbst ändern können, gibt es nichts

Schleifen ?

gibt es auch keine, aber es gibt 2 Sprungbefehle, ähnlich wie GOTO-Befehle und natürlich einen vorzeitigen Programmabbruch

Wenn man jetzt noch die Kommentar-Möglichkeit und Befehlsgruppierung hinzuzählt hat man sed schon sogut wie komplett erklärt.

wie kann man damit Probleme lösen

Nun kann man sich ja fragen, wie man mit so einer spartanischen Ausstattung und einem minimalem Befehlssatz überhaupt größere und komplexe Probleme lösen könnte?

Der Befehl, der den Hauptteil der Arbeit innerhalb von sed leistet, ist oben nur als "suchen und ersetzen" angegeben. Dieser s-Befehl ist in der Kombination mit Regulären Ausdrücken sehr mächtig, (weiter unten, spezielles Kapitel). Er bietet wesentlich mehr Möglichkeiten als nur einzelne Worte auszutauschen, so wie man das von gleichnamigen Funktionen aus Text-Bearbeitungs-Programmen kennt. Suchen und ersetzen umfasst hier z.B. auch "eine bestimmte Stelle suchen und dort NICHTS gegen einen Text ersetzen". Unterstützt wird das Ganze durch Reguläre Ausdrücke. So lassen sich mit dem s-Befehl alle typischen Arbeiten an einem Text simulieren, z.B.: Einfügen; Überschreiben; Löschen; Verschieben; Erweitern; usw.
Aber wie gesagt: alles immer jeweils nur in dem Text, der momentan im Musterspeicher steht.

Ein kleines Problem ergibt wohl auch in sed-Programmierung nur 1 , 2 oder einige wenige Befehle, und ist mit etwas Übung schnell zu entwerfen. Beim Entwickeln von Lösungen zu komplexen Problemen mit sed muss das Problem sehr genau analysiert werden, in kleinste Einzelschritte zerlegt, entsprechend der begrenzten Möglichkeiten von sed ein logischer Lösungsweg gefunden werden und dieser dann in Einzelschritten zu einem fertigen sed-Programm aneinandergereiht werden. Die vielen Annehmlichkeiten moderner Programmiersprachen gibt es bei sed nicht, hier muss man gelegentlich auch mal einen Lösungsweg von ganz unten und nur mit purer Logik selbst neu erfinden. Und genau in dieser Herausforderung liegt wohl auch oftmals der Reiz dennoch einmal selbst ein größeres Problem mit sed anzugehen.
Das Ganze erinnert etwas an Assembler-Programmierung, und das nicht ganz unbegründet. Die Mehrzahl der Befehle von sed, sind in ihrer Funktion sehr elementar und nicht unähnlich den Operationen die in einer CPU auf Registerebene ausgeführt werden. Der Unterschied ist: die CPU arbeitet mit Registern einer definierten Bit Breite und sed arbeitet mit einem Textbuffer in dem sich eine beliebige Anzahl von Textzeichen befinden. Bei den Akkumulator Befehlen (also den Befehlen mit denen wir z.B.. Vergleichen und Ändern können) haben wir bei der CPU allerdings nur die vergleichsweise einfache Bit-Logik, in sed gibt es dort universelle und komplexe Reguläre Ausdrücke die auf Buchstaben, Sonderzeichen, Wörter und ganze Texte angewendet werden.

Und warum der Stream-Editor so funktioniert und nicht anders, wird deutlich wenn man sich noch einmal vor Augen führt, wann dieser Stream-Editor entwickelt wurde.
1973 da hatten die Rechner Hauptspeicher von typisch 16-64KB Größe, Speichermedien von wenigen MB waren riesige Massenspeicher, UNIX und die Grundzüge der Programmiersprache C waren gerade erst geboren, bzw wurden gerade von Assembler Programmierung auf C portiert und komplett überarbeitet (Geschichte von Unix).
Terminals gab es zwar, aber der verbreitetste Weg durch einen Rechner war immer noch, von der Lochkarte oder einem Magnetband über den Rechner auf den Drucker. Alles was vorher kam war sehr viel Assembler-Programmierung, erste brauchbare universelle Betriebssysteme wie Multics und nackte Logik, das gesamte Umfeld war ein Tummelplatz von genialen Wissenschaftlern.
Wenn wir also heute immer noch mit dem Stream Editor arbeiten, dann muss in ihm wohl eine geniale Idee verbaut sein.

der Aufruf und die Optionen von sed

die Optionen

Eine Option -n steuert direkt die innere Abarbeitung und wurde oben schon besprochen. Weitere wichtige Optionen sind -e und -f

sed -e REGEL

hinter der Option steht unmittelbar die Regeln für die Bearbeitung. Sind in der REGEL Leer- oder Sonderzeichen enthalten dann müssen wir sie vor der Interpretation der Shell durch Hochkomma schützen werden ( also sogut wie immer ;-))). Die Option -e REGEL kann auch mehrfach bei einem Aufruf angegeben werden, und auch in Kombination mit der folgenden Option benutzt werden. ( Die Option -e ist nicht zwingend erforderlich, sed interpretiert automatisch das erste Zeichen das nicht eindeutig einer Option zugeordnet werden kann, als der Begin einer Regel. Man sollte sich dennoch angewöhnen die Optionen sauber auszuschreiben)

sed -f REGELDATEI

Die Regel oder mehrere Regeln stehen in einer separaten Datei, die beim Start mit der Option -f an sed übergeben wird. Auch diese Option kann in der Befehlszeile mehrfach vorkommen (auch in Kombination mit obriger Option), es werden dann der Reihe nach alle Regeln auf die zu bearbeitende Datei angewendet.

weitere Optionen sind abhängig von der speziellen sed-Implementierung 

diese könnten spezielle Steuerungsoptionen für den Umgang der Eingabedateien beinhalten, oder auch die Interpretation der Regulären Ausdrücke beeinflussen. Diese Optionen sind nicht zwingend kompatibel zu anderen sed-Implementierungen, und werden auch nur in Einzelfällen benötigt.

der Aufruf

Nachfolgend ein paar Beispiele wie sed-Programme auf der Konsole oder aus einem Script heraus aufgerufen werden können

 BEFEHL | sed -e 'REGEL' > AUSGABEDATEI
 
 sed  -n -e 'REGEL' EINGABEDATEI > AUSGABEDATEI
 
 BEFEHL | sed -f REGELDATEI | BEFEHL
 
 sed -e 'REGEL1' -f REGELDATEI -e 'REGEL2' <EINGABEDATEI >AUSGABEDATEI
 
 VARIABLE=`BEFEHL | sed -e 'REGEL1' | sed -ne 'REGEL2' | BEFEHL ` 

Oftmals lassen sich die Regeln für ein sed-Programm aus bestimmten Regelgründen nicht in eine Zeile schreiben.

sed -ne '
        BEFEHL1\
            Optionen zum BEFEHL1\
            weitere Optionen
        ; BEFEHL2 ; BEFEHL3\
             Optionen zum BEFEHL3
        ; BEFEHL4 ; BEFEHL5
 '

sed-Programm als Script

sed Programme lassen sich auch als eigenständige Script schreiben. Dazu wird der Programmtext in eine Datei geschrieben. An den Begin der Datei wird die Magic Line (shebang)

#!/usr/bin/sed -f 

(eventuell noch zusätzlich die Option -n) gesetzt.
Die Datei erhält Ausführungsrechte. Jetzt kann sie wie andere Scripte auch, direkt mit ihrem Namen ausgeführt werden.

Übergabe von Shell-Variablen an Sed-Programme

sed selbst kann nicht auf Variablen der Shell zurückgreifen und kennt auch keine eigenen Variablen, es kennt nur seinen Programmtext. Also muss bei Bedarf der Programmtext beim Aufruf von sed entprechend der Shellvariablen angepasst werden. In Shellscripten findet man sehr oft einen kleinen Trick.

Die Quotierung des Befehlstext, der den Befehlstext vor der Interpretation der Shell schützen soll, ist an einigen Stellen unterbrochen. An diesen Stellen stehen dann $Shellvariable. Beim Aufruf des sed-Kommandos sieht die Shell diese Variablen und ersetzt sie im Programmtext durch den Wert der Shellvariable. Somit hat man eine sehr elegante Steuerung der Funktion des sed-Scriptes durch Variable der Shell

#!/bin/bash

sed -n '
'/$1/' !{
 	#no match - put the current line in the hold buffer
	x
	# delete the old one, which is 
	# now in the pattern buffer
	d
}'

Die genaue Funktion die sed ausführen soll, soll uns hier erst einmal nicht interessieren, gemeint ist hier die unterbrochen Quotierung

'/$1/'!{

die roten Hochkommas lassen die Shell /$1/ sehen und damit wird die Shell beim Aufruf von sed an dieser Stelle anstatt $1 den Wert des ersten Arguments des Scriptes einsetzen. Wir haben hier also über die Optionen beim Aufruf des Shellscript direkten Einfluss auf die Funktionsweise von sed

Nutzung von sed in Here-Dokuments's

Eine weitere häufig benutzte Aufrufmöglichkeit von sed innerhalb von Shell-Scripten ist das Here Document Auch hier wird oftmals mit der oben gezeigten Methode auf Shellvariablen zurückgegriffen. Die Eingabefile die sed verarbeitet, ist dabei der Inhalt des Here-Dokumentes. folgendes Beispiel soll das verdeutlichen.

#!/bin/bash
KASSE=129.32
WAEHRUNG="EURO"
MITARBEITER="Hr. Maier"

sed -e 's/XXXX/'$KASSE'/g;s/YYYY/'"$WAEHRUNG"'/g;s/ZZZZ/'"$MITARBEITER"'/g' <<EOF
Der Bargeldbestand von XXXX YYYY wurde heute festgestellt
verantwortlich ist wie immer ZZZZ
EOF

hier wird auf 3 Shellvariablen zugegriffen die beim Aufruf durch deren Werte ersetzt werden. Die Ausgabe ist dann der Inhalt des Here-Dokumentes und die Platzhalter XXXX ; YYYY ; ZZZZ werden durch sed dann durch diese Werte ersetzt, die sed beim Kommandoaufruf von der Shell in den sed-Programmtext eingefügt bekommt.

Der Bargeldbestand von 129.32 EURO wurde heute festgestellt
verantwortlich ist wie immer Hr. Maier

die Befehle

Wie oben schon angedeutet gibt es nicht übermäßig viele Befehle. Die Befehle bestehen alle aus nur einem einzigem Zeichen, meist ein Buchstabe den man auch leicht als Kürzel für den Befehl interpretieren kann. (damit hat man wenigstens eine Gedankenstütze)

• p = print
• l = list
• i = insert
• a = apend
• usw

zu einigen Befehlen gehören noch Optionen, und zu den meisten Befehlen können Adressen angegeben werden.

Adressierung der Befehle

Unter Adressen versteht man das Auswahlkriterium der Zeilen, auf denen der Befehl Anwendung finden soll. Die Adressenmöglichkeiten der einzelnen Befehle ist unterschiedlich, nicht alle Befehle können z.B. mit 2 Adressen versehen werden, manche kann man gar nicht mit Adressen versehen. Adressen können, müssen aber nicht angegeben sein. Die Adresse steht vor dem Befehl. Ein Negationszeichen ! zwischen der Adresse und dem Befehl negiert die Adresse, ( also "alle Anderen außer den adressierten Zeilen" treffen zu )

• Ist keine Adresse angegeben, dann wird dieser Befehl auf alle Zeilen der Eingabedatei ausgeführt
• gibt es eine Adresse, dann wird dieser Befehl nur auf solche Zeilen ausgeführt, die zu dieser Adresse passen
• viele haben 2 Adressen in der Schreibweise Adresse1,Adresse2 Hier handelt es sich um ein von Adresse1 bis zur Adresse2
• (GNU)sed unter Linux erlaubt noch einiges mehr was aber nicht portable zu anderen sed-Implentationen ist (z.B. 3~4 würde bedeuten ab Zeile 3 jede 4.Zeile)

Die Adressierungsmöglichkeiten unterliegen folgenden Regeln

• Eine Adresse kann eine Zahl sein, diese bedeutet die entsprechende Zeilennummer der Eingabedatei
• Eine Adresse kann ein Regulären Ausdruck sein /regex/ entspricht alle Zeilen auf die dieser Reguläre Ausdruck passt, ( hierbei ist es möglich aber selten gebräuchlich auch \%regex\% zu schreiben, wobei % ein beliebiges Zeichen ist)
• zwei Adressen Zahl1,Zahl2 enspricht von Zeilennummer Zahl1 bis Zeilennummer Zahl2 bezogen auf die Eingangsdatei
• /regex1/,/regex2/ bedeutet vom der Zeile die regex1 erfüllt bis zur Zeile die regex2 erfüllt
• Kominationen von Zahl,/regex/ und /regex/,Zahl sind möglich
• anstatt einer Zahl das Zeichen $ bedeutet die letzte Zeile
• Zeilenberechnungen mit Zeilennummern wie z.B. $-10 (als Adresse für die letzten 10 Zeilen gemeint) geht nicht
• Die Adressierung kann für eine Gruppe von Befehlen erfolgen wenn die Befehle in { } eingeschlossen sind und durch ; voneinander getrennt werden. Die Adresse steht vor der öffnenden Klammer. Achtung: } muss dabei auf einer Zeile am Zeilenanfang stehen, dass heißt es dürfen davor nur Leer oder Tabulatorzeichen stehen
• Das Zeichen ! zwischen der Adresse und dem Befehl negiert die Adresse, also alle Zeilen die nicht auf die Adresse zutreffen.

Beispiele für Adressierung

einfache Beispiel in Kombination mit den Befehlen print und delete und der Einfluss der Option -n

sed -ne '1,10p'          # Zeilen 1 bis 10 ausgeben
sed -e  '1,10p'          # Zeilen 1 bis 10 doppelt restlichen Zeilen einfach ausgeben
sed -e  '2d'             # 2. Zeile löschen
sed -e  '2,10!d'         # Zeilen 2 bis 10 ausgeben
sed -ne '2,10p'          # Zeilen 2 bis 10 ausgeben
sed -e  '10,$p'          # Zeilen 1 bis 9 einfach und alle anderen Zeilen doppelt ausgeben
sed -ne  '$p'            # letzte Zeile ausgeben

sed -e  '/Text/d'        # Alle Zeilen die nicht "Text" enthalten, ausgeben
sed -e  '/Text/!d'       # Alle Zeilen die "Text" enthalten, ausgeben
sed -ne '/Text/,$!p'     # Alle Zeilen bevor eine Zeile mit "Text" kommt, ausgeben
sed -ne '/Begin/,/END/p' # Alle Zeilen von "Begin" bis "END" ausgeben (wird "END" nicht gefunden bis Schluss)
                         # Kommt nach einem "END" wieder ein "Begin" dann von dort aus wieder ausgeben 

hier jetzt mal ein paar Beispiele zur Verwendung von Charakter Klassen und ähnlichen Neuerungen die in GNU-sed unter anderem also auf Linux funktionieren, aber nicht 100% portabel sind

sed -ne '/^[[:alnum:]]/!p' # Ausgabe alle Zeilen die nicht mit einem Buchstaben oder Zahl beginnen
sed -ne '3~2p'             # Ab der 3.Zeile jede 2.Zeile ausgeben (also ungerade Zeilen ab Zeile 3 )
sed -ne '5,/Text/p'        # Ab der 5.Zeile bis zu einer Zeile mit "Text" ausgeben
sed -ne '3,+7p'            # Die 3.Zeile und die 7 folgenden Zeilen ausgeben
sed -ne '/Begin/,+2p'      # Die Zeilen die "Begin" enthalten und jeweils die nächsten 2 Zeilen ausgeben

Bisher wurden nur sehr einfache Reguläre Ausdrücke verwendet, aber da geht natürlich einiges mehr

sed -ne '/^[EBH]/p'               # alle Zeilen die mit "E","B" oder "H" beginnen ausgeben
sed -e  '/^$/d'                   # alle leeren Zeilen löschen
sed -ne '/^[^#].*/p'              # jede Zeile ausgeben, die mit einem anderem Zeichen als "#" beginnt
sed -ne '/^[[:space:]]*#/d'       # Zeilen deren erstes Zeichen (außer Space und Tabulator) "#" ist, löschen
sed -ne '/^.\{64\}/p'             # Alle Zeilen die mindestens 64 Zeichen lang sind, ausgeben
sed -ne '/[[:digit:]]\{1,3\}\.[[:digit:]]\{1,3\}\.[[:digit:]]\{1,3\}\.[[:digit:]]\{1,3\}/p'
                                  # druckt jede Zeile in der eine IP-Adresse enthalten sein könnte

und man merkt sehr schnell, dass es mit Regulären Ausdrücken hier schon langsam unübersichlich wird. Reguläre Ausdrücke sind schon eine kleine Wissenschaft für sich, da aber bei sed noch zusätzliche Sonderzeichen und auch noch weitere Regeln dazukommen, also bestimmte Zeichen noch zusätzlich entweder entwertet oder aktiviert werden müssen, kann man hier das Chaos durchaus noch etwas perfektionieren.

Um z.B. alle fehlerfreien Zeilen zu suchen, die einen Zeitstring YYYY-MM-DD entsprechen wie ihn z.B. auch date +%F liefert, könnte man mit sed wie folgt adressieren. Es wir hier desshalb so komplex, da die Monate nicht alle 31 Tage haben und es auch noch in bestimmten Jahren ein 29. Februar gibt. All dieses muss geprüft werden wenn man Fehlerhafte Zeitstings ermitteln will. Hier mal gleich der Konsolausdruck. ;-)

zuerst werden ein paar Zeilen mit korrekten und falschen Zeitstings in eine Datei ausgegeben.
Anschließend wird diese Datei dann mit sed und der entsprechenden Regex durchsucht, und nur korrekte Zeilen ausgegeben
unten sind dann die korrekten Zeilen in der Ausgabe zu sehen.

LINUX: # cat test1
2008-10-02
2008-03-19
2007-09-01
2006-07-28
2008-10-05
2007-13-01
2006-06-31
2008-30-02
2005-02-29
2006-11-31
2008-00-02
2004-02-29
LINUX: # sed -ne '/[1-9][0-9][0-9][0-9]-\(\(0[1-9]\|1[0-2]\)-\([01][1-9]\|10\|2[0-8]\)\|\(0[13-9]\|1[0-2]\)-\(29\|30\)\|\(0[13578]\|1[02]\)-31\)\|\([0-9][0-9]\(0[48]\|[2468][048]\|[13579][26]\)\|\(0[48]\|[2468][048]\|[13579][26]\)00\)-02-29/p' test1
2008-10-02
2008-03-19
2007-09-01
2006-07-28
2008-10-05
2004-02-29
LINUX: #   

Und damit fängt es langsam an Spaß zu machen, aber wir wollen hier bei sed bleiben. Für komplizierte Reguläre Ausdrücke gibt es auch Tools und jede Menge gute Seiten im WWW.

ein paar Regeln zu Regulären Ausdrücken in sed

Nur mal so als Gedankenstütze zum nachlesen beim nächsten Problem mit sed und Regulären Ausdrücken mal hier einige Regeln
sed verwendet "Basic Regular Expressions" einige Unterschiede zu den "Erweiterten Regulären Ausdrücken" sind z.B.:

• Die Quantifikatoren "|", "+" und "?" sind normale Zeichen (GNU-sed wie es in Linux enthalten ist, kennt jedoch diese Operatoren, wenn sie durch einen vorangestellten Backslash "escaped" werden)

• die Klammern "{" "}" "(" und ")" sind normale Zeichen und müssen mit Backslashes "escaped" (aktiviert) werden, also als "\{" ; "\}" ; "\(" und "\)"geschrieben werden.

• die Zeichen, die durch "\(" und "\)" eingeschlossen werden, können später mit "\1" usw. (max "\9" ) dereferenziert werden

• "^" ist ein normales Zeichen, wenn es nicht am Beginn eines Ausdrucks, oder eines Klammerausdrucks steht

• "$" ist ein normales Zeichen, wenn es nicht am Ende eines Ausdrucks oder eines Klammerausdrucks steht

• "*" ist am Beginn eines Ausdrucks oder eines Klammerausdrucks ein normales Zeichen

der s-Befehl

Der mit Abstand wichtigste Befehl in sed, der Befehl "s///". Alle anderen Befehle sind nur das Beiwerk. Wer sich schon einmal etwas intensiver mit vi oder VIM beschäftigt hat, wird diesem Befehl vielleicht schon einmal benutzt haben. Die prinzipelle Funktion dieses Befehles ist schnell mit "suchen und ersetzen" erklärt. Die Schreibweise:

[ADRESSE]s/SUCHMUSTER/ERSETZUNG/[FLAG]

• ADRESSE ist der optionale Ausdruck wie er oben schon beschrieben ist, fehlt er, wird der Befehl auf alle Zeilen angewendet
• FLAG steuert die Eigenschaften des Befehls und ist ebenfalls optional, Übersicht der möglichen Flags; ist kein Flag angegeben, gilt 1 ; welches dann bedeutet, es wird nur der erste gefundene Ausdruck der auf das Suchmuster passt, ersetzt.
• s ist der Befehlsname selbst
• SUCHMUSTER ist ein Regulärer Ausdruck nach dem gesucht wird
• ERSETZUNG enthält den Text, der den Teil des Orginaltextes ersetzt, der durch das Suchmuster gefunden wird.
• Als Abrenzung der einzelnen Optionen sind 3 "/" Begrenzer zu setzen. (Bei Bedarf darf hier auch statt "/" jedes andere Zeichen verwendet werden, es gilt das Zeichen als Trennzeichen, dass unmittelbar auf s folgt. Diese Option sollte jedoch mit Sorgfalt verwendet werden, da es ein späteres Interpretieren eines komplizierten Befehls durchaus auch erschweren kann)

In einer der häufigsten und einfachsten Anwendungsbereiche könnte ein kompletter Befehl jetzt so aussehen.

sed -e 's/Strauch/Baum/g'

Erläuterung

* es gibt keine Adresse, also wird der s-Befehl auf jede Zeile angewendet

* Reguläre Suchausdruck lautet in diesem Beispiel einfach "Strauch"

* Der Ersetzungtext ist "Baum"

* als Flag wird "global" verwendet, es werden also alle gefundenen Stellen pro Zeile ersetzt.

* da sed ohne die Option -n gestartet wurde erfolgt eine automatische Ausgabe.

Damit würde in einer Datei jedes Vorkommens der Buchstabenkombination "Strauch" durch "Baum" ersetzt, also nicht nur das Wort Strauch selbst, sonder z.B. würde aus dem Wort "Strauchdieb" das Wort "Baumdieb"

Der Befehl wird jetzt desshalb so mächtig, da Reguläre Ausdrücke nicht nur Buchstabenkombinationen kennen, sondern man damit jede nur erdenkliche Zeichenkombination universell in logischer Form eindeutig beschreiben kann, man Zeilenanfang und Zeilenende bestimmen kann, mit Zeichengruppen, Zeichenklassen, Alternativen, Wiederholungszeichen, und gruppierten Ausdrücken arbeiten kann.

die Bedeutung der Flags

Mit den Flags kann die Funktion des s-Befehls gesteuert werden. Ist kein Flag angegeben gilt 1 ; also nur Ersetzung des ersten Vorkommens des gefunden Strings

Bedeutung der Flags beim s-Befehl

Flag	Bedeutung	Beispiel	Bemerkung
N	N=Zahl (1 < 512) ; das N'te Vorkommen	s/AB/CD/2	wird N nicht angegeben dann erste Vorkommen
g	global ; alle Vorkommen	s/AB/CD/g	es werden alle Vorkommen ersetzt
p	print ; Ausgabe bei Ersetzung	s/AB/CD/p	wurde eine Ersetzung vorgenommen wird der Buffer an stdout ausgegeben
w DATEI	write DATEI bei Ersetzung	s/AB/CD/w FILE	bei Ersetzung Ausgabe des Buffers in die angegebene Datei
i	case-insensitive ; Groß-Kleinschreibung ignorieren	s/AB/CD/i	ist nicht kompatibel zu allen SED-Implementierungen
m			betrifft Interpretation von ^ und $ ; nicht kompatibel
x			nicht kompatibel ; nur bei ssed im Perlmodus
s			nicht kompatibel ; nur bei ssed im Perlmodus

es ist auch mehr als nur ein einzelnes Flag möglich, soweit die Kombination einen Sinn ergibt. z.B.

LINUX: # echo "abcabcabc" | sed -ne 's/AB/CD/2ip'
abcCDcabc
LINUX: # 

kleine Befehlsbeispiele zum Suchen und Ersetzten

sed -e 's/blau\|lila/rot/2'     # Das 2.Vorkommen je Zeile von "blau" oder "lila" wird durch "rot" ersetzt

sed -e '/^$/!s/^/#/ '           # bei alle nichtleeren Zeilen am Zeilenanfang "#" einfügen

sed -e 's/#.*$//'               # von einem Zeichen "#" bis zum Zeilenende alles löschen

sed 's/^[ \t]*//;s/[ \t]*$//'   # entferne alle Leerzeichen und Tabulatoren am Anfang und Ende der Zeilen

sed -e 's/Michael[^a]/Herr &/'  # ersetze "Michael" durch "Herr Michael" jedoch nicht wenn hinter "Michael" ein "a" folgt.

sed -e 's/[Cc]olor/[b]&[\/b]/g' # jedes "Color" und "color" in "[b]Color[/b]" oder "[b]color[/b]" änderen

date +%F | sed -e 's/\([0-9]\{4\}\)-\([0-9]\{2\}\)-\([0-9]\{2\}\)/heute ist der \3.\2. \1/'
                                #das Datumsformat YYYY-MM-DD umwandeln zu "heute ist der DD.MM. YYYY"

Besonderheiten der Beispiele

1. Beispiel: es wird eine Oderverknüpfung benutzt | muss dabei entwertet werden also \|
2. Beispiel: Verwendung der Sonderzeichen ^ für Zeilenanfang und $ für Zeilenende
3. Beispiel: #.*$ bedeutet Zeichen # anschließend müssen 0 oder beliebig viele beliebige Zeichen (.*) stehen, bis Zeilenende ($) ; alles wird durch NICHTS ersetzt (//)
4. Beispiel: [ \t] an dieser Stelle entweder ein Leerzeichen oder ein Tabulator, das "*" darf sich 0 bis beliebig oft wiederholen. Hier wurden 2 Sedbefehle durch ";" getrennt, beide werden hintereinander auf alle Zeilen ausgeführt.
5. Beispiel: [^a] das "a" ist durch "^" negiert, das Bedeutet (nicht "a") an dieser Stelle, das "&" im Ersetzungsfeld bedeutet an dieser Stelle der gesamte mit dem Muster gefundene String einsetzen.
6. Beispiel: Im Ersetzungsfeld steht wieder "&" der "/" im Ersetzungstext musste entwertet werden "\/"
7. Beispiel: Hier haben wir zum einem "\{ \}" mit der geschweiften Klammer läßt sich festlegen wie oft sich der vorhergehende Ausdruck oder Zeichen wiederholen soll, hier z.B. [0-9]\{4\} bedeutet genau 4 Mal eine Ziffer 0 bis 9, weiterhin haben wir "\( \)" das ist eine Gruppierung (ähnlich einer Variable) mit "\1" bis "\9" kann sie im Ersetzungsfeld verwenden können. der Inhalt ist der jeweilige mit der entsprechende Klammer gefundene Text, in diesem Beispiel haben wir 3 solche Gruppen und wir geben sie in umgegehrter Reihenfolge wieder aus "\3 \2 \1"

Befehlsübersicht

Übersicht der Befehle und Schlüsselworte

Kommando	Addr	stdin	stdout	Muster Speicher	Halte Speicher	Erklärung
;	-	-	-	-	-	Trennzeichen zwischen einzelner Befehle
!	-	-	-	-	-	Negationszeichen vor Befehl (Steht zwischen Adresse und Befehl und kehrt die Adresse ins Gegenteil)
{ }	2	-	-	-	-	umschließt einen Block, der mehrere Kommandos beinhalten kann, diese müssen durch ; getrennt werden
#	-	-	-	-	-	Kommentar, alle nachfolgenden Zeichen bis Newline werden nicht als Programmcode interpretiert
: MARKE	-	-	-	-	-	definiert das Sprungziel MARKE Siehe Kommandos b oder t
=	2	-	X	-	-	gibt die aktuelle ZeilenNr der Eingabedatei auf separater Zeile aus
a	1	-	X	-	-	gibt die nachfolgenden Text nach der Ausgabe des Buffers aus
b MARKE	2	-	-	-	-	Sprungbefehl zur MARKE bzw. zum Ende des Scripts
c	2	-	X	X	-	Musterspeicher bzw Bereich löschen und stattdessen nachfolgenden Text ausgeben
d	2	-	-	X	-	Musterspeicher löschen
D	2	-	-	X	-	Musterspeicher bis zum Zeichen „newline“ löschen
g	2	-	-	X	-	Musterspeicher wird durch den Inhalt des Haltespeicher ersetzt.
G	2	-	-	X	-	Haltespeicher wird an den Inhalt des Musterspeicher angefügt
h	2	-	-	-	X	Haltespeicher wird durch den Inhalt des Musterspeicher ersetzt
H	2	-	-	-	X	Musterspeicher wird an den Inhalt des Haltespeicher angefügt
i	1	-	X	-	-	gibt die nachfolgenden Text vor der Ausgabe des Buffers aus
l	1	-	X	-	-	Musterspeicher ausgegeben. ("C-Notation" unbekannte Zeichen in Oktalformat)
n	2	X	?	X	-	je nach Option -n wird der Buffer ausgegeben oder nicht, neue Zeile laden
N	2	X	-	X	-	Nächste Zeile an Inhalt des Musterspeichers angefügen
p	2	-	X	-	-	Musterspeicher ausgegeben.
P	2	-	X	-	-	Musterspeicher bis zum nächsten „newline“-Zeichen ausgeben.
q	1	-	-	-	-	sed Beenden, bei nicht gesetzter Option -n wird Musterspeicher ausgegeben
r FILE	1	-	X	-	-	Inhalt einer angegebenen FILE wird eingelesen und ausgegeben.
s/regex/rpl/flg	2	-	-	X	-	Ersetzt regex durch rpl. Null oder mehrere flg wirken steuernd ein
t MARKE	2	-	-	-	-	bedingter Sprungbefehl zur MARKE abhängig von vorheriger s oder y Kommandos
w FILE	2	-	X	-	-	Schreibt Musterspeicher in FILE
x	2	-	-	X	X	Inhalt von Muster- und Haltespeicher vertauschen
y/src/rpc/flg	2	-	-	X	-	Ersetzt jedes Zeichen im pattern buffer welches in src vorkommt durch das entsprechenden Zeichen in rpc

kleine sed Programme am praktischen Beispiel erklärt

Auf unseren Rechnern in vielen Standard-Scripten sind hunderte von kleinen und kleinsten sed-Befehlen eingebettet. Größere und komplizierter sed-Befehle, sind dabei sehr selten. Es sind fast alles nur sehr einfache Befehle, die sollten mit dem bisschen Wissen hier aus diesem Artikel und ein wenig Verständnis für Reguläre Ausdrücke sicherlich schnell zu durchschauen sein, auch wenn sie eventuell auf dem ersten Blick sehr kompliziert aussehen. Machen wir doch die Probe aufs Exempel:

Beispiel 1

gefunden in /etc/rc.d/rpmconfigcheck

sed -e 's/^/    /' < $configcheckfile

• einfacher s-Befehl, Eingabedatei ist der Variable configcheckfile gespeichert
• "^" Zeilenanfang wird durch einige Leerzeichen ersetzt, also weiter nichts wie einrücken von Text.

Beispiel 2

gefunden in /etc/rc.d/smbfs

mountpoint=$( echo "$mountpoint"|sed "s/\/*$//")

• es wird die Variable mountpoint (in der scheinbar Text steht) mit echo ausgegeben, durch sed gefiltert und die Ausgabe wieder in der Variable mountpoint gespeichert
• "s/\/*$//" Trennzeichen ist "/" das haben wir aber 4 Mal ;-) , Beim näheren Hinsehen ist das 2 "/" mit "\" entwertet
• damit lautet unsere Suchmaske ohne Quotierung "/*$" und das ist schlichtweg als das letztes Zeichen vor Zeilenende (eventuelle auch mehrfach vorhanden) "/" (Quantoren)

gemeint

• ersetzt wird mit NICHTS, also macht der Befehl nichts weiter als eventuelle "/" am Ende des Variableinhaltes abzuschneiden

Beispiel 3

gefunden in /etc/rc.d/fbset

mode=`echo $FBSET_PARAMS | sed -e 's/^-[^ ]*//' -e 's/ -[^ ]*//g'`

• auch hier wird der Inhalt einer Variable durch sed gefiltert und das Ergebnis in einer anderen Variable gespeichert
• sed hat hier 2 Regeln wie wir an 2 mal -e und der Quotierung schnell herauslesen.
• die erste Regel ist ein s-Befehl, Suchmuster ist "^-[^ ]*" bedeutet Am Zeilenanfang "^" ein "-" und dann "[^ ]*" also alles andere nur kein Leerzeichen und das sooft es will. Ersetzt wird durch NICHTS, also schneidet die erste Regel am Zeilenanfang alles was mit einem Strich anfängt bis zum ersten Leerzeichen weg.
• die zweite Regel auch ein s-Befehl, macht fast das selbe, nur nicht vom Zeilenanfang an, sondern das Zeichen vor dem ersten Strich muss ein Leerzeichen sein, dann wird auch bis zum nächsten Leerzeichen nach dem Strich alles gelöscht.
• der 2. Befehl arbeitet global, das heist es werden alle " -irgendwas" gelöscht.
• In Summe macht der gesamte sed-Befehl also nichts anderes, als alle Optionen mit beginnendem "-" aus dem Variabelinhalt zu beseitigen.

Beispiel 4

gefunden in /etc/rc.d/network

RL=`sed -n 's=^id:\(.\):initdefault.*$=\1=p' /etc/inittab`

• der Inhalt von /etc/inittab wird durch sed gefiltert und in der Variable RL abgelegt.
• es ist ein s-Befehl -n, also keine automatische Ausgabe,
• Dieses Mal ist das Begrenzungszeichen "=" da es unmittelbar nach dem "s" kommt, der Befehl hat also hier die Struktur s=== und nicht wie bisher gewohnt s///
• als Flag haben wir ein "p", also sollte sed hier eine Ersetzung vornehmen, wird danach automatisch ausgegeben, ansonsten nichts ausgeben
• Suchmuster: am Anfang "id:" dann kommt irgend ein Zeichen das mit "\( \)" gruppiert ist, und dann geht es weiter mit ":initdefault" und anschließen alle Zeichen bis Zeilenende.
• Ersetzt wird also die gesammte Zeile von Anfang bis Ende aber nur durch Inhalt von "\1" also dem was vom Muster in der \( \) Klammer gefunden wird (Rückwärtsreferenz).
• Ein Blick in die /etc/inittab, zeigt, da steht an dieser Stelle der Standardrunlevel (also normalerweisee 2 3 oder 5) und genau das ist das mögliche Ergebniss des ganzen Befehles.

Beispiel 5

gefunden in /etc/rc.d/xdm

/etc/X11/xdm/SuSEconfig.xdm | \
sed 's+\(.*\)+/etc/init.d/xdm: \1+g' | \
         /bin/logger

• nicht dadurch stören lassen, dass hier ein Befehl über mehrere Zeilen geschrieben wurde, Die Zeilen enden mit "\" das bedeutet der Zeilensprung ist auskommentiert, den sieht die bash beim starten der Befehle nicht.
• es wird ein Script /etc/X11/xdm/SuSEconfig.xdm ausgeführt und die Ausgabe durch sed mit einem s-Befehl gefiltert, diese Ausgabe wird dem Programm /bin/logger übergeben.
• der s-Befehl hat hier die Struktur s+++ da ein "+" unmittelbar dem "s" folgt.
• eine Adressierung gibt es nicht, also alle Zeilen werden bearbeitet.
• die Suchmaske ist \(.*\) und bedeutet soviel wie gruppiert \( \) wird "Alles" (beliebiges Zeichen, 0 mal oder beliebig oft)
• ersetzt wird es durch "/etc/init.d/xdm: \1" , wobei \1 durch die gefundene Gruppe, also der ganzen ursprünglichen Zeile, ersetzt wird.
• das Flag "g" ist hier eigentlich nicht nötig, da es ja nur eine einzigen Treffer pro Zeile geben kann.
• Der Sed-Befehl macht also nichts weiter, als an den Anfang jeder Zeile "/etc/init.d/xdm: " einzufügen.

Beispiel 6

gefunden in /usr/bin/texi2dvi4a2ps

BEFEHL | sed -n 's/^.*\[\(.*\)version \(....\)-\(..\)-\(..\).*$/txiformat=\1 txiversion="\2\3\4"/p'

• der BEFEHL dessen Ausgabe hier gefiltert wird soll uns mal nicht stören.
• sed wird mit "-n" gestartet, also keine automatische Ausgabe jeder Zeile
• der s-Befehl hat keine Adresse und normale Struktur s/// , Flag ist "p" bedeutet also gibt es eine Ersetzung dann wird diese ausgegeben, ansonsten wird nichts ausgegeben.
• Suchmuster ist ^.*\[\(.*\)version \(....\)-\(..\)-\(..\).*$ ; gesucht wird vom Zeilenbegnin nach einer eckigen Klammer "\[" ; dann kommt irgendetwas oder nichts ".*" , das wird wiedermal gruppiert \( \), die Gruppe endet vor der Zeichenfolge "version "; Anschließend wird nach Zeichen im Format "XXXX-XX-XX" gesucht und irgendwas oder nichts kann bis Zeilenende kommen.
• von dem XXXX-XX-XX Format werden 3 weitere Gruppen gebildet, wir haben also insgesamt 4 Gruppierungen im Suchmuster definiert.
• ersetzt wird die gesamte Zeile durch "txiformat=\1 txiversion="\2\3\4" die \1 \2 \3 \4 wird durch die Gruppen ersetzt.
• der sed-Befehl formatiert also eine "Versionszeile" neu, und gibt sie aus, Andere Zeilen erzeugen keine Ausgabe.

Beispiel 7 (für Fortgeschrittene)

gefunden in /usr/bin/autoconf

echo X/"$0" |
   sed '/^.*\/\([^/][^/]*\)\/*$/{
           s//\1/
           q
         }
         /^X\/\(\/\/\)$/{
           s//\1/
           q
         }
         /^X\/\(\/\).*/{
           s//\1/
           q
         }
         s/.*/./; q'

• hier wird "X/" vor "$0" (also der aufgerufene Name des Scriptes) mit echo ausgegeben und an sed übergeben.

Analyse der Struktur

• der sed-Befehl geht über mehrere Zeilen und scheint aus mehreren Befehlen zu bestehen, also verallgemeinern wir ihn erst mal, in dem wir die sed-Befehle extrahieren und die Regulären Ausdrücke wegblenden.

/ADRESSE1/{
          s///
          q
         }
/ADRESSE2/{
          s///
          q
         }
/ADRESSE3/{
          s///
          q
          }
          s ; q

• Den sed-Befehl "q" hatten wir bisher noch nicht, das ist der Abbruchbefehl von sed. Dort wird also das Programm vorzeitig beendet, vorher wird bei fehlender Option -n noch die Ausgabe des Musterspeichers veranlaßt.
• die Bedeutung, die "{ }" hier hat, ist auch neu für uns. Die Befehle die in dieser Klammer stehen gehören alle zur selben Adresse, (die Befehle müssen aber durch ; oder \n getrennt werden)
• Also haben wir 3 Adressen die beim Zutreffen jeweils einen s-Befehl ausführen und dann sed beenden. und wenn keine dieser Adressen zutreffen sollte, den s-Befehl am Ende des Programms, der dann ausgeführt wird.

Schauen wir uns zuerst die s-Befehle an

• die ersten 3 s-Befehle sind gleich "s//\1/" das ist auch neu für uns. Der Suchstring, den gibt es gar nicht, da die // unmittelbar hintereinander stehen, dennoch greifen wir auf die Gruppe "\1" beim Ersetzen zu ?

würden wir diesen Befehl auf der Konsole versuchen, sed 's//\1/' käme eine Fehlermedung, "fehlender Suchstring"

sed nimmt hier für den fehlenden Suchstrings den selben Regulären Ausdruck wie in der Adresse, also mit der Adresse zusammen funktioniert der Befehl, ohne Adresse oder Adresse aus Zeilennummer funktioniert er nicht.

• der letzte s-Befehl ist einfach "s/.*/./" ersetzt alles oder nichts durch einen einzigen Punk

Analyse der Adressen

• ADRESSE1: ^.*\/\([^/][^/]*\)\/*$ wir haben jetzt schon etwas Übung mit entwerteten Zeichen und Regulären Ausdrücken desshalb gleich mal die Zusammenfassung.

gesucht und gruppiert wird "ein mindestens 2 Zeichen langes Wort" Wortbegrenzer ist "/" gefunden wird die ganze Zeile.

Achtung: hier "^.*\/" treffen wir auf ein Phänomen der Regulären Ausdrücke, das auch neu für uns ist. gieriges Verhalten (Greediness of RegEx)

gesucht wird am Zeilenanfang "irgendwas oder nichts bis ein "/" kommt"

ist in der Shellvariable eine oder mehrere "/" (also das Programm mit dem Path aufgerufen,) dann wird hier als "irgendwas" der längst mögliche String gefunden

durch das Greediness wird bei dieser Adresse hier gefunden und gruppiert der "Scriptname ohne den Path"

dieser wird dann auch nach dem s-Befehl ausgegeben, und das sed-Programm beendet.

• ADRESSE2 "^X\/\(\/\/\)$" kommt also nur zum Zug wenn ADRESSE1 nicht zutrifft.

sie sucht nach "X///" und gruppiert die letzten beiden "/"

der s-Befehl würde also "//" ausgeben und sich beenden.

• ADRESSE3 "^X\/\(\/\).*" (nur wenn sowohl Adresse1 und Adresse2 nicht zutreffen) funktioniert ähnlich wie ADRESSE2 nur sucht sie nur nach einem "/" weniger würde auch fündig werden bei vielen aneinandergereihten "/" und gibt nur ein "/" aus

• Treffen keine der 3 Adressen zu, z.B. weil "$0" leer sein sollte, dann wird der letzte s-Befehl ausgeführt, der nur einen Punkt ausgibt.

Da ist noch ein kleiner Trick im Script versteckt

Damit bei einer Leeren "$0" das sed-Programm überhaupt arbeiten kann, wird als Trick

echo X/"$0"

benutzt. Das vorangestellte "X/" wird beim Ersetzten innerhalb von sed jedesmal wieder entfernt, aber es sichert bei leeren $0 eine ordnungsgemäße Funktion des Programms.

Das Ergebnis des gesamten sed-Programms

Das Ergebniss des gesamten sed-Scriptes ist also abhängig vom Inhalt der Shell Variable $0 und ist entweder der "Scriptname ohne Path" ; "//" ; "/" oder "."

---

weiterführende Links

• An Introduction and Tutorial
• sed-Tutorium-de
• THE SED FAQ
• Hilfreiche Tools für Sed-Programmierung
• GNU sed user's manual

---

zurück zu UNIX-Werkzeuge