Sed

Achtung dieser Artikel ist noch in Arbeit und dient vorläufig nur als Vorlage. Dieser Beitrag zu Linux oder der Abschnitt ist in Bearbeitung. Weitere Informationen findest du hier. Der Ersteller arbeitet an dem Beitrag oder Abschnitt und entsorgt den Wartungsbaustein spätestens 3 Tage nach der letzten Bearbeitung. Änderungen außer Rechtschreibkorrekturen ohne Absprache mit dem Urspungsautor sind möglichst zu vermeiden, solange dieser Baustein noch innerhalb der genannten Frist aktiviert ist.

Robi 14:03, 4. Okt. 2008 (UTC) 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 ließt die Standardeingabe, (oder wenn angegeben eine oder mehrer 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 mitgegeben, 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äre Ausdrücke auf und umfasst nur wenige Befehle. Alle Befehle und Schlüsselworte bestehen nur aus einem einzigem Zeichen, entweder Buchstabe oder Sonderzeichen. Nahe Verwande von sed sind er 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 desshalb 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 öfter und intensiver mit sed beschäftigt, wird durchaus schnell bemerken, wie hilfreich diese kryptische Spache 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 einig 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ück gegriffen.

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 einsetzten, 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 zB:

• Umwandlung von Textausgaben in bestimmte andere Formate oder zurück (zB: Text nach HTML oder HTML nach Text);
• Extrahieren bestimmter Abschnitte aus Texten, oder bestimmte Textformatierungen
• das Ändern oder Korrigieren von Kleinigkeiten über vielen HTML-Dateien oder an vielen Quell-Code-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 oder vielen Dateien oder zur automatischen Bearbeitung von zB. 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 zB Perl oder Phyton ausweichen.

das Funktionsprinzip

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

Beim Aufruf von sed werden die Regeln zum Ändern des Textes mit beim Programmaufruf ü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. (Achtung ist in awk anders) Die Ausgabe erfolgt auf der Standardausgabe und kann von hier mit den normalen Umleitungen an ander Befehle übergeben, oder in eine Datei geleitet werden. Die Eingangsdateien werden also nicht geändert.

sed hat einen Textbuffer den sogenannten Musterspeicher, dieser ist beim Starten des Programmes leer. In diesen Musterspeicher wird die erste Zeile der Eingangsdatei geladen. Jetzt werden die Regeln auf diese 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 eingeben dass die 2. Zeile gelöscht 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 Programmes 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-Programmes 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

Neben dem Musterspeicher gibt es noch einen 2. Textbuffer, den sogenannten Haltespeicher. Auch dieser ist beim Start des Programmes leer. In ihm könnte man jetzt zB den Inhalt des Musterspeichers kopieren und den Inhalt dort aufbewahren bis er zu einem späteren Zeitpunkt benötigt wird, und wieder in den Musterspeicher laden. Hierfür gibt es einige sed Kommandos mit denen die Daten zwischen diesen Textbuffern ausgetauscht werden zB. (Musterspeicher durch Haltespeicher ersetzen; Haltespeicher durch Musterspeicher ersetzen; Inhalt von Halte- und Musterspeicher tauschen; Inhalt von Musterspeicher an den Haltespeicher anhängen usw.) Im Haltespeicher selbst kann nichts abgefragt oder gar verändert werden.

Was geht jetzt mit dem Musterspeicher?
Einige Funktionen mehr, zB. (Musterspeicher löschen, die nächste Zeile einlesen, die nächste Zeile hinten hinzufügen, in 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; einzelne Zeichen durch ein anderes 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, 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 Ausdürcken 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 ja zB auch "eine bestimmte Stelle suchen und dort NICHTS gegen einen Text ersetzen". So lassen sich damit alle typischen Arbeiten an einem Text simulieren : Einfügen; Überschreiben; Löschen; Verschieben; Erweitern; usw. Aber wie gesagt: alles immer jeweils nur in dem Text, der momentan im Musterspeicher steht.

Beim Schreiben eines sed-Programmes muss das Problem sehr genau analysiert werden, in kleinste Einzelschritte zerlegt, entsprechend der Möglichkeiten von sed ein logischer Lösungsweg gefunden werden und dieser dann in lauter kleinen Einzelschritten zu einem fertigen sed-Programm aneinandergereiht werden. Und genau in dieser Herausforderung liegt wohl auch oftmals der Reiz auch einmal ein größeres Probleme mit sed anzugehen.
Das Ganze erinnert sehr an Assembler-Programmierung, und nicht ganz unbegründet. Die meisten Einzelschritte die wir bei sed aneinanderreihen, sind in ihrer Funktion nicht unähnlich der Operationen, die in einer CPU auf Registerebene auch ausgeführt werden können. Der Unterschied ist nur, die CPU arbeitet mit Registern einer definierten Bit Breite und sed arbeiten mit einem Textbuffer in dem sich eine beliebige Anzahl von Textzeichen befinden.

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 verbreiteste Weg durch einen Rechner war immernoch, 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 Logig, das gesammte 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 mussen 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 das dem Script mitgegebenen wurde, 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 = iinsert
• 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 zB 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 (zB 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 zB $-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 10 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 vor 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 '/^[[:space:]]*#/d'       # Zeilen deren erstes Zeichen (außer Space und Tabulator) "#" ist, löschen
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 an sich sind schon eine kleine Wissenschaft für sich, da aber bei sed noch zusätzlich 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 zB alle fehlerfreien Zeilen zu suchen die einen Zeitstring YYYY-MM-DD entsprechen wie ihn zB auch date +%F liefert, müssten man mit sed wie folgt adressieren. Hier mal gleich der Konsolausdruck. ;-)

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\)\|\([1-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 zB:

• 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-Befehle

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 zu allen SED-Implementierung kompatibel
m			betrifft Interpretation von ^ und $ ; nicht kompatibel
x			nicht kompatibel ; nur bei ssed im Perlmodus
s			nicht kompatibel ; nur bei ssed im Perlmodus

es sind auch mehr als nur ein einzelnes Flag möglich, soweit die Kombination einen Sinn ergibt. zB

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

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

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