Sed: Unterschied zwischen den Versionen

Aus Linupedia.org
Wechseln zu: Navigation, Suche
(erste umfangreiche Bearbeitung)
 
K (kleine Änderungen, damit sollte der Artikel wieder für ein paar Jahre okay sein)
 
(19 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
{{UnderConstruction}}[[Benutzer:Robi|Robi]] 14:03, 4. Okt. 2008 (UTC)
 
 
SED  - eine kleine Einführung und Übersicht über ein mächtiges UNIX-Werkzeug
 
SED  - eine kleine Einführung und Übersicht über ein mächtiges UNIX-Werkzeug
  
Zeile 6: Zeile 5:
 
== Was ist sed und was kann sed ? ==
 
== Was ist sed und was kann sed ? ==
  
[http://linux.die.net/man/1/sed sed] ('''S'''tream-'''ED'''itor) 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. <br>
+
[http://linux.die.net/man/1/sed sed] ('''S'''tream-'''ED'''itor) 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 Textbearbeitungsfilter, 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 [http://senseis.xmp.net/?McMahon Lee E. McMahon] entwickelt. Es ist eine interpretierende Scriptsprache mit sehr begrenzten Funktionsmöglichkeiten. Sie baut direkt auf [[Reguläre Ausdrücke]] auf und umfasst nur wenig ( kleiner 30) Befehle, welche alle nur aus einem einzigem Zeichen als Befehls- oder Funktionsname bestehen. Nahe Verwande von '''sed''' sind er Zeileneditor [http://linux.die.net/man/1/ed ed] und der klassische UNIX Standard-Editor [[VIM]]. SED erlaubt eine sehr kompakte aber effektive Programierung. 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.  
+
 
 +
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 [https://en.wikipedia.org/wiki/Lee_E._McMahon 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|Regulären Ausdrücken]] auf und umfasst nur wenige [[#Befehlsübersicht|Befehle]]. Alle Befehle und Schlüsselworte bestehen nur aus einem einzigem Zeichen, entweder Buchstabe oder Sonderzeichen. Nahe Verwandte von '''sed''' sind der Zeileneditor [http://linux.die.net/man/1/ed 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 '''[[VIM|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'
 
   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 ist normale SED Sprache.
+
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 sind sehr schwer zu erkennen und zu beseitigen. Das war auch einer der Gründe für die Entstehung von [[awk]]  
+
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 [http://sed.sourceforge.net/grabbag/scripts/ SED Script Archiv] sind einige solcher Programme zu finden. Weitere [http://sed.sourceforge.net/#scripts sed-scripte] und weitere [http://sed.sourceforge.net/#gamez Spiele ] gibt es auf  [http://sed.sourceforge.net/ einer der wichtigsten SED-Seiten] (Web-Seiten geschrieben übrigens mit ? : [http://sed.sourceforge.net/local/scripts/sedindex2html.sed.html natürlich mit sed] ;-)))
  
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 programmiert. In diesem [http://sed.sourceforge.net/grabbag/scripts/ SED Script Archiv] sind einige solcher Programme zu finden. Weitere [http://sed.sourceforge.net/#scripts sed-scripte] und weitere [http://sed.sourceforge.net/#gamez Spiele ] gibt es auf  [http://sed.sourceforge.net/ einer der wichtigsten SED-Seiten] ( Geschrieben übrigens mit ? : [http://sed.sourceforge.net/local/scripts/sedindex2html.sed.html natürlich mit sed] ;-)))
 
  
Heute gibt es eine Vielzahl von [http://sed.sourceforge.net/sedfaq2.html#s2.2 '''sed''' Versionen für die unterschiedlichsten Betriebssysteme} die zT die eine oder andere Erweiterung unterstützen oder nicht. Unterschiede gibt es vor allem im Umfeld der [http://de.wikipedia.org/wiki/Regul%C3%A4re_Ausdr%C3%BCcke Regulären Ausdrücke], da es dort einig Spezifikationen gibt, die sich in Details unterscheiden. Unter Linux haben wir ein sehr leistungsfähiges [http://www.gnu.org/software/sed/manual/ sed] das einige Erweiterungen beinhaltet die nicht unbedingt portabel zu anderen Sed-Versionen sind.
+
Heute gibt es eine Vielzahl von [http://sed.sourceforge.net/sedfaq2.html#s2.2 '''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 [http://de.wikipedia.org/wiki/Regul%C3%A4re_Ausdr%C3%BCcke Regulären Ausdrücke], da es dort einige Spezifikationen gibt, die sich in Details unterscheiden. Unter Linux haben wir ein sehr leistungsfähiges [http://www.gnu.org/software/sed/manual/ GNUsed] das einige Erweiterungen beinhaltet, die nicht unbedingt portabel zu anderen Sed-Versionen sind.
  
  
Zeile 23: Zeile 30:
 
=== Für was benötigen wir sed heute ? ===
 
=== 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 Programmiersprachen, wie Java oder Perl heraus, wird man hin und wieder einmal auf eine Shellfunktion mit sed-Befehlszeile zurück greifen. Für Randprobleme besonders bei Ein- und Ausgabe oder bei Konvertierung von Textdateien ist '''sed''' oftmals ein sehr hilfreiches Tool. <br>
+
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.
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 die Umwandlung von Textausgaben in bestimmte andere Formate zB HTML, 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 [http://sed.sourceforge.net/local/docs/emulating_unix.txt Standardkommandos von UNIX simulieren]. Auch diese Kommandos haben 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.<br>
+
 
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 zu mächtig und unangemessen für winzige Probleme sind, dann ist eventuell '''sed''' als kleine elegante Lösung die beste Option.
+
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 [http://sed.sourceforge.net/local/docs/emulating_unix.txt 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.<br>
  
  
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 besser geeignet. Man sollte '''sed''' jedoch nicht dort einsetzen, wo die normalen Standard-Tools oder Programme das gewünschte Ergebnis mit vertretbaren Aufwand auch liefern können, diese sind schneller und oftmals auch genauer. Bei größeren und komplizierten Probleme wird man gerne auf eine höhere Programmiersprache  wie zB Perl oder Phyton ausweichen.  
+
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.
  
  
Zeile 36: Zeile 50:
 
== das Funktionsprinzip ==
 
== 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.
+
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.
  
'''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 ausgegeben. Der Musterspeicher wird gelöscht und die nächste Zeile geladen, usw. Beim Laden der neuen Zeile wird jetzt der interne Zeilenzähler um eins erhöht. Diesen Zeilenzähler können wir auch im Programm abfragen und auswerten.
+
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.
  
Das Grundverhalten, dass sed jede bearbeitete Zeile selbstständig ausgibt, können wir mit einer Option beim Start von '''sed''' verhindern. Dann müssen wir jedoch innerhalb der Regeln festlegen, was '''sed''' ausgeben soll, wir müssen also  "Print-Befehle" benutzen. Die Option dazu ist "'''-n'''". Angenommen wir wollen aus einem Text die 2. Zeile löschen, dann müssen wir ohne die Option '''-n''' den Filter nur so einstellen dass die 2. Zeile gelöscht wird. Verwenden wir die Option '''-n''' so müssen wir 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 Buffer ausgeben. Das sind oftmals fast gegensätzliche Ansatzweisen, 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 beim den ersten Programmierversuchen wird es den meisten sehr oft passieren, dass entweder Zeilen doppelt vorkommen oder gar keine oder nur unvollständige Ausgaben kommen,
 
  
 +
'''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.
  
  
=== was beinhaltet sed ===
+
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'''".
  
Neben dem Musterspeicher gibt es noch einen 2. Textbuffer, den sogenannten '''Haltespeicher'''. Auch dieser ist beim Start des Programmes leer. In ihm können man jetzt zB den Inhalt des Musterspeichers kopieren und den Inhalt dort aufbewahren bis er zu einem späteren Zeitpunkt benötigt wird und dann wieder in den Musterspeicher laden. Hierfür gibt es einige [[#Befehlsübersicht| '''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 können wird darüber hinaus nicht abfragen oder gar ändern.
 
  
Was geht jetzt mit dem Musterspeicher? 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 durch einen im Programm enthaltenen Text ersetzen, oder diesen 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 [http://linux.die.net/man/1/tr tr]), und innerhalb des Musterspeichers suchen und ersetzen.
+
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.<br>
 +
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  <!-- mit?bei --> 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 [[#Befehlsübersicht| '''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?<br>
 +
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 [http://linux.die.net/man/1/tr 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<br>
 +
; Schleifen ?
 +
: gibt es auch keine, aber es gibt 2 '''Sprungbefehle''', ähnlich wie '''GOTO-Befehle''' und natürlich einen vorzeitigen Programmabbruch<br>
 +
Wenn man jetzt noch die Kommentar-Möglichkeit und Befehlsgruppierung hinzuzählt hat man '''sed''' schon sogut wie komplett erklärt.
  
'''Variablen ?''' außer dem Haltespeicher und der Variable in der '''sed''' automatisch die Eingabezeilen zählt, gibt es nichts<br>
 
Schleifen gibt es auch keine, aber es gibt 2 '''Sprungbefehle''', ähnlich wie '''goto''' und natürlich einen vorzeitigen Programmabbruch<br>
 
Wenn man jetzt noch die Kommentar-Möglichkeit und Befehlsgruppierung hinzuzählt hat man '''sed''' sogut wie komplett erklärt.<br>
 
  
  
Zeile 59: Zeile 108:
 
=== wie kann man damit Probleme lösen ===
 
=== wie kann man damit Probleme lösen ===
  
Nun kann man sich fragen wie man mir so einer spartanischen Ausstattung und einem minimalem Befehlssatz damit überhaupt größere und komplexe Probleme lösen könnte?
+
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äre Ausdrücke|Regulären Ausdürcken]] sehr mächtig,(weiter unten spezielles Kapitel). Er bietet wesentlich mehr Möglichkeiten als nur einzelne Worte auszutauschen, 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.<br>
+
 
 +
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äre Ausdrücke|Regulären Ausdrücken]] sehr mächtig, ''([[#der s-Befehl|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. <br>
 +
'''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.<br>
 +
Das Ganze erinnert etwas an [http://de.wikipedia.org/wiki/Assemblersprache 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. <br>
 +
 
 +
 
 +
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. <br>
 +
1973 da hatten die [http://de.wikipedia.org/wiki/PDP-11 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 ([http://de.wikipedia.org/wiki/Geschichte_von_Unix Geschichte von Unix]).
 +
<br> Terminals gab es zwar, aber der verbreitetste Weg durch einen Rechner war immer noch, von der [http://technikum29.de/de/rechnertechnik/lochkarten-edv Lochkarte] oder [http://www.pdp8.net/tu56/tu56.shtml einem Magnetband] über den Rechner auf den Drucker. Alles was vorher kam war sehr viel Assembler-Programmierung, erste brauchbare universelle Betriebssysteme wie [http://web.mit.edu/multics-history/source/Multics_Internet_Server/Multics_sources.html  Multics] und [http://infolab.stanford.edu/pub/voy/museum/pictures/display/3-1.htm nackte Logik], das gesamte Umfeld war ein Tummelplatz von genialen Wissenschaftlern.<br>
 +
Wenn wir also heute immer noch mit dem Stream Editor arbeiten, dann muss in ihm wohl eine geniale Idee verbaut sein.
  
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 zusammengebaut 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 [http://de.wikipedia.org/wiki/Assemblersprache 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 ausgeführt werden können. Der Unterschied ist nur, die CPU arbeitet mit Registern einer definierten Bit Breite und wir arbeiten mit einem Textbuffer in dem sich eine beliebige Anzahl von Textzeichen befinden.<br>
 
Und warum der Stream-Editor so funktioniert, wird deutlich wenn man sich noch einmal vor Augen führt, wann dieser Stream-Editor entwickelt wurde. 1973 da hatten die Rechner Hauptspeicher in KB Größe, Speichermedien in wenigen MB waren riesige Massenspeicher, UNIX und die Grundzüge der Programmiersprache C waren gerade erst geboren. Alles was vorher kam war sehr viel Assembler-Programmierung und das gesammte Umfeld war ein Tummelplatz von genialen Wissenschaftlern.
 
  
  
Zeile 74: Zeile 133:
  
 
; sed -e REGEL:
 
; 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)  
+
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:
 
; 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.
+
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 :
 
; 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 nurin Einzelfällen benötigt.  
+
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.  
  
  
Zeile 85: Zeile 144:
  
 
Nachfolgend ein paar Beispiele wie sed-Programme auf der Konsole oder aus einem Script heraus aufgerufen werden können
 
Nachfolgend ein paar Beispiele wie sed-Programme auf der Konsole oder aus einem Script heraus aufgerufen werden können
 +
<pre>
 
  BEFEHL | sed -e 'REGEL' > AUSGABEDATEI
 
  BEFEHL | sed -e 'REGEL' > AUSGABEDATEI
 +
 
  sed  -n -e 'REGEL' EINGABEDATEI > AUSGABEDATEI
 
  sed  -n -e 'REGEL' EINGABEDATEI > AUSGABEDATEI
 +
 
  BEFEHL | sed -f REGELDATEI | BEFEHL
 
  BEFEHL | sed -f REGELDATEI | BEFEHL
 +
 
  sed -e 'REGEL1' -f REGELDATEI -e 'REGEL2' <EINGABEDATEI >AUSGABEDATEI
 
  sed -e 'REGEL1' -f REGELDATEI -e 'REGEL2' <EINGABEDATEI >AUSGABEDATEI
 +
 
  VARIABLE=`BEFEHL | sed -e 'REGEL1' | sed -ne 'REGEL2' | BEFEHL `  
 
  VARIABLE=`BEFEHL | sed -e 'REGEL1' | sed -ne 'REGEL2' | BEFEHL `  
'''sed''' Programme lassen sich auch als eigenständige Script schreiben. Dazu wird der Programmtest in eine Datei geschrieben. An den Begin der Datei wird die '''[http://de.wikipedia.org/wiki/Shebang Magic Line''' (shebang)]
+
</pre>
#!/usr/bin/sed -f
+
Oftmals lassen sich die Regeln für ein sed-Programm aus bestimmten Regelgründen nicht in eine Zeile schreiben.
(eventuell noch zusätzlich die Option '''-n''') gesetzt, und die Datei erhält Ausführungsrechte. Jetzt kann sie wie andere Scripte auch direkt mit ihrem Namen ausgeführt werden.
+
<pre>sed -ne '
 
 
Oftmals lassen sich die Regeln für ein sed-Programm aus bestimmten Regelgründen nicht in eine Zeile schreiben
 
sed -ne '
 
 
         BEFEHL1\
 
         BEFEHL1\
 
             Optionen zum BEFEHL1\
 
             Optionen zum BEFEHL1\
Zeile 102: Zeile 163:
 
             Optionen zum BEFEHL3
 
             Optionen zum BEFEHL3
 
         ; BEFEHL4 ; BEFEHL5
 
         ; BEFEHL4 ; BEFEHL5
  '
+
  '</pre>
Hier findet man sehr oft in den Scripten 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
+
 
 +
 
 +
 
 +
==== 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 '''[http://de.wikipedia.org/wiki/Shebang Magic Line''' (shebang)]
 +
#!/usr/bin/sed -f
 +
(eventuell noch zusätzlich die Option '''-n''') gesetzt.<br>
 +
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
 
  #!/bin/bash
 
   
 
   
Zeile 115: Zeile 193:
 
  }'
 
  }'
 
Die genaue Funktion die sed ausführen soll, soll uns hier erst einmal nicht interessieren, gemeint ist hier die unterbrochen Quotierung<br>
 
Die genaue Funktion die sed ausführen soll, soll uns hier erst einmal nicht interessieren, gemeint ist hier die unterbrochen Quotierung<br>
 +
<font face="Arial" size="4"><br>
 
'''<font color="red">'</font><font color="blue">/$1/</font><font color="red">'</font>!{ '''<br>
 
'''<font color="red">'</font><font color="blue">/$1/</font><font color="red">'</font>!{ '''<br>
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'''
+
</font><br>
 +
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 [http://en.wikipedia.org/wiki/Heredoc Here Document]
 
Eine weitere häufig benutzte Aufrufmöglichkeit von '''sed''' innerhalb von Shell-Scripten ist das [http://en.wikipedia.org/wiki/Heredoc Here Document]
Auch hier wird oftmals mit der selben Methode auf Shellvariablen zurückgegriffen. Die Eingabefile ist dabei der Inhalt des Here-Dokumentes. folgendes Beispiel soll das verdeutlichen.
+
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.
 
<pre>
 
<pre>
 
#!/bin/bash
 
#!/bin/bash
Zeile 141: Zeile 226:
 
== die Befehle ==
 
== 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 meist leicht als Kürzel für den Befehl gut interpretieren kann.
+
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  = '''p'''rint
 
* p  = '''p'''rint
 
* l  = '''l'''ist
 
* l  = '''l'''ist
 +
* i  = '''i'''nsert
 
* a  = '''a'''pend
 
* a  = '''a'''pend
 
*usw
 
*usw
Zeile 154: Zeile 240:
 
=== Adressierung der Befehle ===
 
=== Adressierung der Befehle ===
  
Unter Adressen versteht man die 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  )
+
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
 
* 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
 
* 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'''
 
* 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)  
+
* (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
 
Die Adressierungsmöglichkeiten unterliegen folgenden Regeln
 +
  
 
* Eine Adresse kann eine Zahl sein, diese bedeutet die entsprechende Zeilennummer der Eingabedatei
 
* 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)
 
* 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
+
* zwei Adressen '''Zahl1,Zahl2''' enspricht von Zeilennummer '''Zahl1''' bis Zeilennummer '''Zahl2''' bezogen auf die Eingangsdatei
* '''/regex1/,/regex2/''' bedeutet vom der Zeilennummer die '''regex1''' erfüllt bis zur Zeilennummer die '''regex2''' erfüllt  
+
* '''/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
+
* Kominationen von '''Zahl,/regex/''' und '''/regex/,Zahl''' sind möglich
 
* anstatt einer Zahl das Zeichen '''$''' bedeutet die letzte Zeile
 
* anstatt einer Zahl das Zeichen '''$''' bedeutet die letzte Zeile
* Zeilenberechnungen mit Zeilennummern wie zB '''$-10''' (für die letzten 10 Zeilen) geht nicht  
+
* 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'''  
 
* 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 '''p'''rint und '''d'''elete und der Einfluss der Option '''-n'''
 +
<pre>
 +
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 </pre>
 +
 +
 +
 +
 +
hier jetzt mal ein paar Beispiele zur Verwendung von [http://sed.sourceforge.net/sedfaq3.html#s3.7 Charakter Klassen] und ähnlichen Neuerungen die in GNU-sed unter anderem also auf Linux funktionieren, aber nicht 100% portabel sind
 +
<pre>
 +
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
 +
</pre>
 +
 +
 +
 +
Bisher wurden nur sehr einfache Reguläre Ausdrücke verwendet, aber da geht natürlich einiges mehr
 +
<pre>
 +
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
 +
</pre>
 +
 +
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. ;-) <br>
 +
 +
zuerst werden ein paar Zeilen mit korrekten und falschen Zeitstings in eine Datei ausgegeben.<br>
 +
Anschließend wird diese Datei dann mit sed und der entsprechenden Regex durchsucht, und nur korrekte Zeilen ausgegeben<br>
 +
unten sind dann die korrekten Zeilen in der Ausgabe zu sehen.
 +
<pre>
 +
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: # 
 +
</pre>
 +
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 [https://aurelio.net/projects/txt2regex/ 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<br>
 +
'''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
  
  
==== Beispiele für Adressierung ====
 
  
  
 +
=== 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 [[VIM|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: <br>
 +
<font face="Arial" size="6"><br>
 +
[ADRESSE]<font color="red">'''s/'''</font>SUCHMUSTER<font color="red">'''/'''</font>ERSETZUNG<font color="red">'''/'''</font>[FLAG] <br>
 +
</font>
 +
 +
 +
* '''ADRESSE''' ist der optionale Ausdruck wie er [[#Adressierung der Befehle|oben]] schon beschrieben ist, fehlt er, wird der Befehl auf alle Zeilen angewendet
 +
* '''FLAG''' steuert die Eigenschaften des Befehls und ist ebenfalls optional, [[#die Bedeutung der Flags|Ü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äre Ausdrücke|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. 
 +
 +
     
  
  
=== der s-Befehle ===
 
  
  
 
==== die Bedeutung der Flags ====
 
==== 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
 +
 +
{| border=1
 +
|+ '''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 <font color="red">nicht kompatibel</font> zu allen SED-Implementierungen
 +
|-
 +
!| m   
 +
|| ||
 +
|| betrifft Interpretation von '''^ '''und''' $''' ; <font color="red">nicht kompatibel</font>
 +
|-
 +
!| x   
 +
|| || 
 +
|| <font color="red">nicht kompatibel</font> ; nur bei ssed im Perlmodus
 +
|-
 +
!| s   
 +
|| || 
 +
|| <font color="red">nicht kompatibel</font> ; nur bei ssed im Perlmodus
 +
|}
 +
es ist auch mehr als nur ein einzelnes Flag möglich, soweit die Kombination einen Sinn ergibt. z.B.
 +
<pre>
 +
LINUX: # echo "abcabcabc" | sed -ne 's/AB/CD/2ip'
 +
abcCDcabc
 +
LINUX: # </pre>
 +
 +
 +
 +
==== kleine Befehlsbeispiele zum Suchen und Ersetzten ====
 +
<pre>
 +
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"
 +
</pre>
 +
'''Besonderheiten der Beispiele'''<br>
 +
 +
# Beispiel: es wird eine Oderverknüpfung benutzt  '''|''' muss dabei entwertet werden also '''\|'''
 +
# Beispiel: Verwendung der Sonderzeichen '''^''' für Zeilenanfang und '''$''' für Zeilenende
 +
# Beispiel: '''#.*$''' bedeutet Zeichen '''#''' anschließend müssen 0 oder beliebig viele beliebige Zeichen '''(.*)''' stehen, bis Zeilenende '''($)''' ; alles wird durch NICHTS ersetzt '''(//)'''
 +
# 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.
 +
# 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.
 +
# Beispiel: Im Ersetzungsfeld steht wieder '''"&"''' der '''"/"''' im Ersetzungstext musste entwertet werden '''"\/"'''   
 +
# 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"'''
  
==== einfache Befehlsbeispiele ====
 
  
  
Zeile 202: Zeile 496:
 
|-
 
|-
 
! <font color="red">{ }</font> || 2 || - || - || - || -  
 
! <font color="red">{ }</font> || 2 || - || - || - || -  
|| umschließt eine Block, der mehrere Kommandos beinhalten kann, müssen durch ''';''' getrennt werden
+
|| umschließt einen Block, der mehrere Kommandos beinhalten kann, diese müssen durch ''';''' getrennt werden
 
|-
 
|-
 
! <font color="red">#</font>  || - || - || - || - || -  
 
! <font color="red">#</font>  || - || - || - || - || -  
Zeile 208: Zeile 502:
 
|-
 
|-
 
! <font color="red">:</font> MARKE || - || - || - || - || -  
 
! <font color="red">:</font> MARKE || - || - || - || - || -  
|| definiert das Sprungziel '''MARKE''' Siehe Kommandos b oder t,
+
|| definiert das Sprungziel '''MARKE''' Siehe Kommandos '''b''' oder '''t'''
 
|-
 
|-
 
! <font color="red">=</font>  || 2 || - || X || - || -  
 
! <font color="red">=</font>  || 2 || - || X || - || -  
Zeile 220: Zeile 514:
 
|-
 
|-
 
! <font color="red">c</font>  || 2 || - || X || X || -  
 
! <font color="red">c</font>  || 2 || - || X || X || -  
|| Musterspeicher bzw Bereich löschen und nachfolgenden Text ausgeben
+
|| Musterspeicher bzw Bereich löschen und stattdessen nachfolgenden Text ausgeben
 
|-
 
|-
 
! <font color="red">d</font>  || 2 || - || - || X || -  
 
! <font color="red">d</font>  || 2 || - || - || X || -  
Zeile 246: Zeile 540:
 
|| Musterspeicher ausgegeben. ("C-Notation" unbekannte Zeichen in Oktalformat)
 
|| Musterspeicher ausgegeben. ("C-Notation" unbekannte Zeichen in Oktalformat)
 
|-
 
|-
! <font color="red">n</font>  || 2 || X || ? || - || -  
+
! <font color="red">n</font>  || 2 || X || ? || X || -  
 
|| je nach Option '''-n''' wird der Buffer ausgegeben oder nicht, neue Zeile laden  
 
|| je nach Option '''-n''' wird der Buffer ausgegeben oder nicht, neue Zeile laden  
 
|-
 
|-
Zeile 283: Zeile 577:
  
  
== kleine sed programme am Beispiel erklärt ==
+
== 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) '''"/"''' ([https://de.wikipedia.org/wiki/Regul%C3%A4rer_Ausdruck#Quantoren 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 [http://de.wikipedia.org/wiki/Regul%C3%A4rer_Ausdruck#Ein_Zeichen_aus_einer_Auswahl 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 [https://de.wikipedia.org/wiki/Regul%C3%A4rer_Ausdruck#Vordefinierte_Zeichenklassen irgend ein Zeichen] das mit '''"\( \)"''' [https://de.wikipedia.org/wiki/Regul%C3%A4rer_Ausdruck#Gruppierungen_und_R%C3%BCckw%C3%A4rtsreferenzen 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 ([https://de.wikipedia.org/wiki/Regul%C3%A4rer_Ausdruck#Gruppierungen_und_R%C3%BCckw%C3%A4rtsreferenzen 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. [https://learntutorials.net/de/regex/topic/429/gierige-und-faule-quantifizierer 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 ==
 
== weiterführende Links ==
Zeile 300: Zeile 773:
  
 
-----
 
-----
 
+
<!-- ~~~~ -->
 
[[Konsole#Unixwerkzeuge|zurück zu UNIX-Werkzeuge]]
 
[[Konsole#Unixwerkzeuge|zurück zu UNIX-Werkzeuge]]
 
[[Kategorie:Konsole]][[Kategorie:Scripte]]
 
[[Kategorie:Konsole]][[Kategorie:Scripte]]

Aktuelle Version vom 18. Februar 2022, 23:16 Uhr

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




zurück zu UNIX-Werkzeuge