Sed

Aus Linupedia.org
Wechseln zu: Navigation, Suche
Höhe=24px
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 bekommt man schnell Verständnissprobleme 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 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 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 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 und was kann man damit machen

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 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 ist 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 zB:

  • 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 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 hier zB 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 zB: 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 Logig selbst neu erfinden. Und genau in dieser Herausforderung liegt wohl auch oftmals der Reiz dennoch einmal selbst ein größeres Probleme mit sed anzugehen.
Das Ganze erinnert etwas an Assembler-Programmierung, und nicht ganz unbegründet. Die Mehrzahl der Befehle von sed, sind in ihrer Funktion sehr elementar und 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. Bei den Akkumulator Befehlen (also den Befehlen mit denen wir zB. Vergleichen und Ändern können) haben wir bei der CPU allerdings nur die vergleichsweise einfache Bit-Logig, 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 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 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 = 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 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 zB alle fehlerfreien Zeilen zu suchen, die einen Zeitstring YYYY-MM-DD entsprechen wie ihn zB auch date +%F liefert, müsste 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-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 "Stauch" durch "Baum" ersetzt, also nicht nur das Wort Strauch selbst, sonder zB 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-Implementierung
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: # 


einfache Befehlsbeispiele

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 Beispiel erklärt

weiterführende Links




zurück zu UNIX-Werkzeuge