Sed

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

Robi 14:03, 4. Okt. 2008 (UTC) SED - eine kleine Einführung und Übersicht über ein mächtiges UNIX-Werkzeug

Was ist sed und was kann sed ?

sed (Stream-EDitor) ist ein universelles Textbearbeitungstool und auf jedem UNIX- und Linux-System zu finden. Ein Texteditor im gewöhnlichen Sinn, ist ein Programm mit dem wir mittels Tastatur einen Text erstellen oder ändern können, und genau das ist sed nicht.
Der Stream-Editor ließt die Standardeingabe, (oder wenn angegeben eine oder mehrer Dateien) ein, ändert diesen Text nach einem "programmiertem Rezept" welches wir ihm beim Aufruf mitgeben ab, und gibt den so geänderten Text auf der Standardausgabe (oder umgeleitet auch als Datei) wieder aus. Es handelt sich also um einen universell programmierbaren 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 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 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.

 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. 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

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 SED Script Archiv sind einige solcher Programme zu finden. Weitere sed-scripte und weitere Spiele gibt es auf einer der wichtigsten SED-Seiten ( Geschrieben übrigens mit ? : natürlich mit sed ;-)))

Heute gibt es eine Vielzahl von 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 sed 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 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.
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 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.
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 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.

das Funktionsprinzip

Das Prinzip von sed ist recht simpel, aber man muss es sich genau verinnerlichen, sonst kommt man schnell Verständnissprobleme beim Schreiben oder Interpretieren von Sed-Programmen. Beim Aufruf von sed werden die Regeln zum Ändern des Textes mit beim Programmaufruf übergeben. Wird keine Datei angegeben, dann nimmt sed den Standardeingabekanal als Eingangsdatei, wird eine Datei angegeben, dann diese. Werden mehrere Dateien angegeben, dann werden die Dateien der Reihe nach bearbeitet, und zwar werden die Dateien aneinander gereiht, der Zeilenzähler wird also bei einer neuen Datei nicht wieder zurückgesetzt.( Achtung ist in awk anders) Die Ausgabe erfolgt auf der Standardausgabe und kann von hier mit den normalen Umleitungen an ander Befehle übergeben, oder in eine Datei geleitet werden. Die Eingangsdateien werden also nicht geändert.

sed hat einen Textbuffer den sogenannten Musterspeicher, dieser ist beim Starten des Programmes leer. In diesen Musterspeicher wird die erste Zeile der Eingangsdatei geladen. Jetzt werden die Regeln auf diese Musterspeicher angewendet und diese Zeile damit entsprechend geändert oder auch nicht. Sind alle Regeln abgearbeitet, dann wird der Inhalt des jetzt geänderten Musterspeichers 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.

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,

was beinhaltet sed

Neben dem Musterspeicher gibt es noch einen 2. Textbuffer, den sogenannten Haltespeicher. Auch dieser ist beim Start des Programmes leer. In ihm kö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 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 tr), und innerhalb des Musterspeichers suchen und ersetzen.

Variablen ? außer dem Haltespeicher und der Variable in der sed automatisch die Eingabezeilen zählt, gibt es nichts
Schleifen gibt es auch keine, aber es gibt 2 Sprungbefehle, ähnlich wie goto und natürlich einen vorzeitigen Programmabbruch
Wenn man jetzt noch die Kommentar-Möglichkeit und Befehlsgruppierung hinzuzählt hat man sed sogut wie komplett erklärt.

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? Der Befehl, der den Hauptteil der Arbeit innerhalb von sed leistet, ist oben nur als "suchen und ersetzen" angegeben. Dieser s-Befehl ist in der Kombination mit Regulären Ausdürcken sehr mächtig,(weiter unten spezielles Kapitel). Er bietet wesentlich mehr Möglichkeiten als nur einzelne Worte auszutauschen, wie man das von gleichnamigen Funktionen aus Text-Bearbeitungs-Programmen kennt. Suchen und ersetzen umfasst ja zB auch "eine bestimmte Stelle suchen und dort NICHTS gegen einen Text ersetzen". So lassen sich damit alle typischen Arbeiten an einem Text simulieren : Einfügen; Überschreiben; Löschen; Verschieben; Erweitern; usw. Aber wie gesagt, alles immer jeweils nur in dem Text, der momentan im Musterspeicher steht.

Beim Schreiben eines sed-Programmes muss das Problem sehr genau analysiert werden, in kleinste Einzelschritte zerlegt, entsprechend der Möglichkeiten von sed ein logischer Lösungsweg gefunden werden und dieser dann in lauter kleinen Einzelschritten zu einem fertigen sed-Programm 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 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.
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.

der Aufruf und die Optionen von sed

die Optionen

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

sed -e REGEL

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

sed -f REGELDATEI

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

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

diese könnten spezielle Steuerungsoptionen für den Umgang der Eingabedateien beinhalten, oder auch die Interpretation der Regulären Ausdrücke beeinflussen. Diese Optionen sind nicht zwingend kompatibel zu anderen sed-Implementierungen, und werden auch nurin 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 ` 

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 Magic Line (shebang)

#!/usr/bin/sed -f 

(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.

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
'

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

#!/bin/bash

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

Die genaue Funktion die sed ausführen soll, soll uns hier erst einmal nicht interessieren, gemeint ist hier die unterbrochen Quotierung
'/$1/'!{
die Roten Hochkommas lassen die Shell /$1/ sehen und damit wird die Shell beim Aufruf von sed an dieser Stelle anstatt $1 den Wert des ersten Arguments das dem Script mitgegebenen wurde, einsetzen. Wir haben hier also über die Optionen beim Aufruf des Shellscript direkten Einfluss auf die Funktionsweise von sed

Eine weitere häufig benutzte Aufrufmöglichkeit von sed innerhalb von Shell-Scripten ist das 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.

#!/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 meist leicht als Kürzel für den Befehl gut interpretieren kann.

• p = print
• l = list
• 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 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 )

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

Die Adressierungsmöglichkeiten unterliegen folgenden Regeln

• Eine Adresse kann eine Zahl sein, diese bedeutet die entsprechende Zeilennummer der Eingabedatei
• Eine Adresse kann ein Regulären Ausdruck sein /regex/ entspricht alle Zeilen auf die dieser Reguläre Ausdruck passt, ( hierbei ist es möglich aber selten gebräuchlich auch \%regex\% zu schreiben, wobei % ein beliebiges Zeichen ist)
• zwei Adressen Zahl1,Zahl2 enspricht von Zeilennummer Zahl1 bis Zeilennummer Zahl2 bezogen auf die Eingangsdatei
• /regex1/,/regex2/ bedeutet vom der Zeilennummer die regex1 erfüllt bis zur Zeilennummer die regex2 erfüllt
• Kominationen von Zahl,/regex/ und /regex/,zahl sind möglich
• anstatt einer Zahl das Zeichen $ bedeutet die letzte Zeile
• Zeilenberechnungen mit Zeilennummern wie zB $-10 (für die letzten 10 Zeilen) 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

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 eine Block, der mehrere Kommandos beinhalten kann, 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 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	?	-	-	je nach Option -n wird der Buffer ausgegeben oder nicht, neue Zeile laden
N	2	X	-	X	-	Nächste Zeile an Inhalt des Musterspeichers angefügen
p	2	-	X	-	-	Musterspeicher ausgegeben.
P	2	-	X	-	-	Musterspeicher bis zum nächsten „newline“-Zeichen ausgeben.
q	1	-	-	-	-	sed Beenden, bei nicht gesetzter Option -n wird Musterspeicher ausgegeben
r FILE	1	-	X	-	-	Inhalt einer angegebenen FILE wird eingelesen und ausgegeben.
s/regex/rpl/flg	2	-	-	X	-	Ersetzt regex durch rpl. Null oder mehrere flg wirken steuernd ein
t MARKE	2	-	-	-	-	bedingter Sprungbefehl zur MARKE abhängig von vorheriger s oder y Kommandos
w FILE	2	-	X	-	-	Schreibt Musterspeicher in FILE
x	2	-	-	X	X	Inhalt von Muster- und Haltespeicher vertauschen
y/src/rpc/flg	2	-	-	X	-	Ersetzt jedes Zeichen im pattern buffer welches in src vorkommt durch das entsprechenden Zeichen in rpc

weiterführende Links

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

---

zurück zu UNIX-Werkzeuge