Sed: Unterschied zwischen den Versionen

Aus Foxwiki
Subpages:
show all...
Versionsgeschichte interaktiv durchsuchen
← Zum vorherigen Versionsunterschied
VisuellWikitext
K Textersetzung - „== Syntax ==“ durch „== Aufruf ==“
 
(98 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 1: Zeile 1:
{{DISPLAYTITLE:sed}}
{{DISPLAYTITLE:sed}}
'''sed''' - strom-orientierter Editor zur Bearbeitung von Dateien anhand von Regeln
'''sed''' - Stromeditor zum Filtern und Umwandeln von Text


== Beschreibung ==
== Beschreibung ==
* Da es ein "nicht-interaktives" Programm ist, kann es, falls gewünscht, zur Automatisierung der Bearbeitung verwendet werden.
* Der Name sed ist eine Abkürzung für stream editor, und das Dienstprogramm leitet viele seiner Befehle vom ed line-editor ab (ed war der erste UNIX-Texteditor).
* So können Sie mehrere Dateien bearbeiten oder gängige Bearbeitungsvorgänge durchführen, ohne jemals vi oder emacs öffnen zu müssen.
* sed liest aus einer Datei oder von der Standardeingabe und gibt auf der Standardausgabe aus.
* sed hat zwei Puffer, die Musterpuffer und Haltepuffer genannt werden.
* Beide sind anfangs leer.


=== So funktioniert's ===
'''sed''' steht für ''Stream EDitor'' und ist ein [[Unix]]-Werkzeug, mit dem Text-[[Datenstrom|Datenströme]] bearbeitet werden können. Der Datenstrom kann auch aus einer Datei gelesen werden. Im Gegensatz zu einem [[Texteditor]] wird die Ursprungsdatei aber nicht verändert.
* Geben Sie den Musterpuffer auf stdout aus.  
 
* Der Stream-Editor ist kein herkömmlicher Editor wie Vi oder Emacs.
Im Gegensatz zu einem interaktiven Texteditor, wie etwa dem [[vi]], wird <code>sed</code> mittels eines [[Skriptsprache|Skripts]] gesteuert.
* Sed arbeitet nicht interaktiv, sondern wird über Kommandozeilenoptionen oder ein Skript gesteuert.
* Sed verändert nicht das Original, sondern schreibt das Ergebnis auf die Standardausgabe.
* Sed lädt die aktuell betrachtete Zeile in einen temporären Puffer - im Folgenden als Arbeitspuffer bezeichnet.  


==== Unix Sed Arbeitsmethodik ====
Der <code>sed</code>-Befehlssatz orientiert sich an jenem des [[Zeilenorientierter Editor|zeilenorientierten Texteditors]] [[Ed (Texteditor)|ed]]. Dabei werden für die Text-Durchmusterung laut der [[Portable Operating System Interface|POSIX]]-Spezifikation eine bestimmte Abart der [[Regulärer Ausdruck|Regular Expressions]], sogenannte (POSIX-) ''Basic Regular Expressions'' (BRE) verwendet.<ref>{{Internetquelle |url=http://pubs.opengroup.org/onlinepubs/009695399/utilities/sed.html#tag_04_126_13_02 |titel=sed-Spezifikation der Open Group |sprache=en |zugriff=2013-03-27}}</ref> Die [[GNU]]-Implementation verwendet allerdings ''GNU-BRE''s, die von ''POSIX-BRE''s geringfügig abweichen.
Dies wird als ein Ausführungszyklus bezeichnet.  
* Der Zyklus wird fortgesetzt, bis das Ende der Datei/Eingabe erreicht ist # Lesen einer ganzen Zeile aus stdin/file.  
# Entfernt alle nachstehenden Zeilenumbrüche.  
# Legt die Zeile in seinen Musterpuffer.
# Ändert den Musterpuffer entsprechend den übergebenen Befehlen.  


== Installation ==
Auch wenn der Sprachumfang von <code>sed</code> ziemlich limitiert und spezialisiert erscheint, so handelt es sich doch um eine [[Turing-Vollständigkeit|Turing-vollständige]] Sprache. Beweisen kann man die Turing-Vollständigkeit, indem man eine [[Turingmaschine]] mittels <code>sed</code> programmiert<ref>{{Internetquelle |url=http://www.catonmat.net/ftp/sed/turing.txt |titel=Implementation of a Turing Machine as Sed Script |sprache=en |zugriff=2013-03-23}}</ref><ref>{{Internetquelle |url=http://www.stunet.tu-freiberg.de/~bahmann/turing-sed/ |titel=Turing-Maschine mit ''sed'' |sprache=de |zugriff=2013-03-17}}</ref> oder indem man mit ''sed'' einen Interpreter für eine andere, Turing-vollständige Sprache schreibt.<ref>{{Webarchiv|url=http://mi.eng.cam.ac.uk/~er258/code/sed/ |wayback=20100418131328 |text=cam.ac.uk}}</ref>
== Syntax ==
=== Optionen ===
=== Parameter ===
=== Umgebungsvariablen ===
=== Exit-Status ===
== Anwendungen ==
=== Fehlerbehebung ===
== Konfiguration ==
=== Dateien ===
== Sicherheit ==


== Siehe auch ==
Folglich konnten und wurden sogar Spiele wie [[Sokoban]] oder [[Arkanoid]] und andere anspruchsvolle Programme wie [[Debugger]] mit sed geschrieben.<ref>{{Internetquelle |url=http://sed.sourceforge.net/grabbag/scripts/#misc |titel=Liste verschiedener sed-Skripte |sprache=en |zugriff=2011-11-19}}</ref>
=== Dokumentation ===
# https://www.gnu.org/software/sed/manual/sed.html
==== Man-Pages ====
==== Info-Pages ====


=== Links ===
==== Einzelnachweise ====
<references />
==== Projekt ====
==== Weblinks ====


== Testfragen ==
; Sed ist ein Stromeditor (stream editor)
<div class="toccolours mw-collapsible mw-collapsed">
* Ein Stromeditor wird für grundlegende Texttransformationen auf einen Eingabestrom (einer Datei oder aus einer Verarbeitungskette) verwandt.
''Testfrage 1''
* Obwohl in einigen Aspekten ähnlich zu einem Editor, der Bearbeitungen nach Skript erlaubt (wie Ed), führt Sed nur einen Durchlauf über die Eingabe(n) durch und ist somit effizienter.
<div class="mw-collapsible-content">'''Antwort1'''</div>
* Allerdings ist es die Fähigkeit von Sed, Text in einer Verarbeitungskette zu filtern, die ihn besonders gegenüber anderen Arten von Editoren auszeichnet.
</div>
<div class="toccolours mw-collapsible mw-collapsed">
''Testfrage 2''
<div class="mw-collapsible-content">'''Antwort2'''</div>
</div>
<div class="toccolours mw-collapsible mw-collapsed">
''Testfrage 3''
<div class="mw-collapsible-content">'''Antwort3'''</div>
</div>
<div class="toccolours mw-collapsible mw-collapsed">
''Testfrage 4''
<div class="mw-collapsible-content">'''Antwort4'''</div>
</div>
<div class="toccolours mw-collapsible mw-collapsed">
''Testfrage 5''
<div class="mw-collapsible-content">'''Antwort5'''</div>
</div>


= TMP =
* Da es ein "nicht-interaktives" Programm ist, kann es, falls gewünscht, zur Automatisierung der Bearbeitung verwendet werden.
=== Aufruf ===
* Der Name sed ist eine Abkürzung für stream editor, und das Dienstprogramm leitet viele seiner Befehle vom ed line-editor ab (ed war der erste UNIX-Texteditor).
[[Sed/Aufruf]]
* So können Sie mehrere Dateien bearbeiten oder gängige Bearbeitungsvorgänge durchführen, ohne jemals vi oder emacs öffnen zu müssen.
* sed liest aus einer Datei oder von der Standardeingabe und gibt auf der Standardausgabe aus.
* sed hat zwei Puffer, die Musterpuffer und Haltepuffer genannt werden.
* Beide sind anfangs leer.


=== Dateiübergabe ===
; Funktionsweise
[[Sed/Dateiübergabe]]
* Geben Sie den Musterpuffer auf stdout aus.
* Der Stream-Editor ist kein herkömmlicher Editor wie Vi oder Emacs.
* Sed arbeitet nicht interaktiv, sondern wird über Kommandozeilenoptionen oder ein Skript gesteuert.
* Sed verändert nicht das Original, sondern schreibt das Ergebnis auf die Standardausgabe.
* Sed lädt die aktuell betrachtete Zeile in einen temporären Puffer - im Folgenden als Arbeitspuffer bezeichnet.


=== Ausgabe ===
==== Unix Sed Arbeitsmethodik ====
[[Sed/Ausgabe]]
; Ausführungszyklus
* Der Zyklus wird fortgesetzt, bis das Ende der Datei/Eingabe erreicht ist # Lesen einer ganzen Zeile aus stdin/file
# Entfernt alle nachstehenden Zeilenumbrüche
# Legt die Zeile in seinen Musterpuffer
# Ändert den Musterpuffer entsprechend den übergebenen Befehlen


=== Kommandoübersicht ===
==== Reguläre Ausdrücke ====
[[Sed/Kommandos]]
; POSIX.2-BREs sollten unterstützt werden
* Dies erfolgt allerdings aus Leistungsgründen nicht vollständig.
* Die Sequenz \n in einem regulären Ausdruck passt auf das Zeilenumbruchzeichen und ähnliches gilt für \a, \t und andere Sequenzen.
* Die Option -E schaltet auf die Verwendung von erweiterten regulären Ausdrücken um; sie wurde seit Jahren in GNU Sed unterstützt und ist jetzt in POSIX enthalten.


=== Substitutionen ===
== Installation ==
[[Sed/Substitutionen]]
# '''apt install sed'''


=== Reguläre Ausdrücke ===
== Aufruf ==
Folgende Reguläre Ausdrücke werden von sed unterstützt
$ '''sed''' [-V] [--version] [--help] [-n] [--quiet] [--silent]
[-l N] [--line-length=N] [-u] [--unbuffered]
[-E] [-r] [--regexp-extended]
[-e Skript] [--expression=script]
[-f Skriptdatei] [--file=Skriptdatei]
[script-if-no-other-script]
[Datei …]


{|class="wikitable"  
=== Optionen ===
{| class="wikitable sortable options"
|-
! Unix !! GNU !! Beschreibung
|-
| -n || --quiet, --silent || unterdrückt die Ausgabe des Musterbereichs
|-
|-
| | '''^ '''
| || --debug || Kommentiert die Programmausführung
| | Zeilenanfang
|-
|-
| | '''$'''
| -e Skript || --expression=Skript || Fügt das Skript zu den auszuführenden Befehlen hinzu
| | Zeilenende (bei der Adressierung steht das Zeichen für die letzte Zeile)
|-
|-
| | '''. '''
| -f Skriptdatei || --file=Skriptdatei || Fügt den Inhalt der Skriptdatei zu den auszuführenden Befehlen hinzu
| | Ein Zeichen (Ausnahme ist der Zeilenumbruch)
|-
|-
| | '''* '''
| || --follow-symlinks || Symbolischen Links bei der Bearbeitung an Ort und Stelle folgen
| | Keine, eine oder mehrere Wiederholungen des vorhergehenden Buchstabens / der vorhergehenden Gruppe
|-
|-
| | '''[...] '''
| -i[ENDUNG] || --in-place[=ENDUNG] || Dateien an Ort und Stelle bearbeiten (erstellt Sicherung, falls ENDUNG angegeben)
| | Ein Zeichen aus der Menge
|-
|-
| | '''[^...] '''
| -l N || --line-length=N || Gibt die gewünschte Zeilenumbruchlänge für den Befehl »l« an
| | Kein Zeichen aus der Menge
|-
|-
| | '''\(...\) '''
| || --posix || Deaktiviert alle GNU-Erweiterungen
| | Speichern des enthaltenen Musters
|-
|-
| | '''& '''
| -E, -r || --regexp-extended || Verwendet erweiterte reguläre Ausdrücke in dem Skript (für Portabilität verwenden Sie POSIX -E)
| | Enthält das Suchmuster
|-
|-
| | '''\< '''
| -s || --separate || Betrachtet Dateien getrennt statt als einzigen, kontinuierlichen langen Strom
| | Wortanfang
|-
|-
| | '''\> '''
| || --sandbox || Arbeitet im »Sandbox«-Modus (deaktiviert e/r/w-Befehle)
| | Wortende
|-
|-
| | '''x\{m\} '''
| -u || --unbuffered || Lädt minimale Datenmenge aus den Eingabedateien und schreibt die Ausgabepuffer öfter
| | m-fache Wiederholung des Zeichens x
|-
|-
| | '''x\{m,\} '''
| -z || --null-data || Zeilen durch NUL-Zeichen trennen
| | Mindestens m-fache Wiederholung des Zeichens x
|-
|-
| | '''x\{m,n\} '''
| || --help || zeigt Hilfeinformationen an und beendet das Programm
| | Mindestens m-, maximal n-fache Wiederholung des Zeichens x
|-
|-
| || --version || gibt Versionsinformationen aus und beendet das Programm
|}
|}


=== Beispieltext ===
=== Befehle ===
* Zunächst soll es um die Möglichkeiten zur Adressierung von Zeilen mit Sed gehen (das Schema lässt sich u.a. auch im Vi anwenden)
[[Sed/Befehle]]


$ '''cat sedtest.txt'''
=== Rückgabewert ===
Einrückungen?
Der Aufruf des Stream Editors besitzt immer das Format:
sed 'Kommando' Dateiname
Dabei kann dem Kommando mitgeteilt werden, welche Zeilen der Eingabedatei es bearbeiten soll.
Als Adressierung kommen folgende Mechanismen infrage:
Keine Angabe Alle Zeilen
Nummer Genau diese Zeile
Start, Ende Alle Zeilen von "Start" bis "Ende"
$ Symbolisiert die letzte Zeile
RegEx Zeilen, die den Regulären Ausdruck enthalten
1, RegEx Von Zeile 1 bis zur ersten Zeile, die RegEx enthält


Um die spätere Arbeit besser verfolgen zu können, wird die Datei nummeriert.
== Anwendungen ==
$ '''nl -w 2 -b a sedtest.txt | tee test.txt'''
=== Arbeitsweise ===
  1 Der Aufruf des Stream Editors besitzt immer das Format:
<code>sed</code> kann sowohl innerhalb einer [[Pipe (Informatik)|Pipeline]] als auch auf [[Datei]]en arbeiten. Ausgaben erfolgen grundsätzlich auf <code><stdout></code>, Fehlermeldungen auf <code><stderr></code>. Der typische Aufruf sieht deshalb so aus:
  2
  3 sed 'Kommando' Dateiname
  4
  5 Dabei kann dem Kommando mitgeteilt werden, welche Zeilen der
  6 Eingabedatei es bearbeiten soll. Als Adressierung kommen folgende
  7 Mechanismen in Frage:
  8
  9 Keine Angabe Alle Zeilen
  10 Nummer Genau diese Zeile
  11 Start, Ende Alle Zeilen von "Start" bis "Ende"
  12 $ Symbolisiert die letzte Zeile
  13 RegEx Zeilen, die den Regulären Ausdruck enthalten
  14 1, RegEx Von Zeile 1 bis zur ersten Zeile, die RegEx enthält


==== Erstellung einer Testdatei ====
:{|
cat > sed-test.txt << EOF
|
Dies ist Zeile 1
  sed &apos;Anweisung1
Hier isst ein Fehler
      Anweisung2
  Hier isst noch ein Frhler
      …
Dies ist die vorletzte Zeile
      Anweisung''N''&apos; Eingabedatei > Ausgabedatei
Dies ist die letzte Zeile
  ''&lt;stream>'' | sed &apos;Anweisung1
EOF
                Anweisung2
 
                …
=== Aufbau der sed-Anweisungen ===
                Anweisung''N''&apos; | ''<stream>''
sed-Anweisungen werden meist von einfachen Hochkomma umschlossen.
|}
sed 'anweisung' < sed-test.txt
 
sed kann mehrere Anweisungen in einem Durchgang abarbeiten.
* In diesem Falle muss jedem Befehl die Option "-e" vorangestellt werden.
* Wenn nur eine Anweisung abgearbeitet werden soll, kann man "-e" weglassen.
sed -e 'anweisung1' -e 'anweisung2' < sed-test.txt
 
möglich, aber etwas unübersichtlicher ist auch diese Form:
sed -e 'anweisung1; anweisung2' < sed-test.txt
 
In vielen sed-Anweisungen kommt das Zeichen '/' vor.
* Es ist ein Begrenzungszeichen, also ein "delimiter".
* Eine Regular Expression, also ein Suchausdruck, wird durch zwei Schrägstriche begrenzt.
* Im folgende kürze ich "Regular Expression" durch "RE" ab.
 
Unvollständige Anweisung:
  sed '/isst/' < sed-test.txt
* sed durchsucht die Datei Zeile pro Zeile nach dem String "isst"
* die RE "isst" wird durch "/" am Anfang und Ende eingegrenzt.
* "/" ist also nichts anderes als ein Begrenzungszeichen, ähnlich wie Hochkommata
 
Die vorige Anweisung ist unvollständig, da sie nur aus der RE '/isst/' besteht.
* sed muss noch mitgeteilt werden, wie mit dem Suchergebnis zu verfahren ist.
 
Hinter der durch die RE getroffenen Bereichsauswahl ist der Befehl anzugeben.
* Eine sed-Anweisung enthält also i.A.
* mindestens zwei Komponenten (die Bereichsauswahl kann in bestimmten Konstrukten fehlen): # Bereichsauswahl<br/>Auswahl der Zeilen, die bearbeitet werden sollen.
* Im vorigen Beispiel würde sich die Auswahl auf alle Zeilen beziehen, in denen "isst" vorkommt.
# Befehl<br/>Was soll mit den ausgewählten Zeilen passieren? Der einfachste Befehl lautet "p" (print), er gibt die selektierten Zeilen am Bildschirm aus.
 
Das vorige Beispiel wird vervollständigt:
sed '/isst/p' < sed-test.txt
 
* Durchsuchen der Datei nach Zeilen, die "isst" enthalten
* Die selektierten Zeilen werden am Bildschirm ausgegeben
* "/" umschließt die RE, hat also mit dem Befehl "p" nichts zu tun.
 
Leider liefert die sed-Anweisung ein unbefriedigendes Ergebnis, da alle Zeilen ausgegeben werden.
 
Dies liegt an der Arbeitsweise von sed.
* Um das gewünschte Ergebnis zu erhalten, muss sed mit der Option "-n" aufgerufen werden:
 
sed -n '/isst/p' < sed-test.txt''' '''  
* beim p-Befehl immer die Option "-n" verwenden!
* aufgrund der Option "-n" werden nur die Zeilen ausgegeben, in denen "isst" vorkommt.
 
Wenn man die Option "-e" verwendet, muss beachtet weden, dass "-n" vor "-e" steht.
 
sed -n -e '/isst/p' < sed-test.txt
* "-e" muss hinter "-n" stehen!
 
== Dateizeilen ausgeben ==
=== Ausgabe [p] ===
Zunächst wenden wir das Kommando p auf die ersten 3 Zeilen der Datei an:
 
$ '''sed '1,3p' test.txt'''
1 Der Aufruf des Stream Editors besitzt immer das Format:
1 Der Aufruf des Stream Editors besitzt immer das Format:
2
2
3 sed 'Kommando' Dateiname
3 sed 'Kommando' Dateiname
4
5 Dabei kann dem Kommando mitgeteilt werden, welche Zeilen der
6 Eingabedatei es bearbeiten soll.
* Als Adressierung kommen folgende
7 Mechanismen in Frage:
8
9 Keine Angabe Alle Zeilen
10 Nummer Genau diese Zeile
11 Start, Ende Alle Zeilen von "Start" bis "Ende"
12 $ Symbolisiert die letzte Zeile
13 RegEx Zeilen, die den Regulären Ausdruck enthalten
14 1, RegEx Von Zeile 1 bis zur ersten Zeile, die RegEx enthält
 
Offensichtlich zeigt der Stream Editor etwas mehr an, als uns lieb ist; er gibt einfach die gesamte Datei aus und wiederholt nur die Zeilen, die durch das Kommando »1,3p« bearbeitet wurden.
 
=== Mehrfache Ausgaben unterbinden [-n] ===
Um solche »überflüssigen« Ausgaben zu unterbinden, muss die Option »-n« verwendet werden:
 
'''sed -n '1,3p' test.txt'''
  1 Der Aufruf des Stream Editors besitzt immer das Format:
  2
  3 sed 'Kommando' Dateiname
 
Bei der Adressierung mittels regulärer Ausdrücke müssen diese in Schrägstriche (Slashes) eingeschlossen sein:
 
'''sed -n '/RegEx/,/RegEx/p' test.txt'''
  13 RegEx Zeilen, die den Regulären Ausdruck enthalten
  14 1, RegEx Von Zeile 1 bis zur ersten Zeile, die RegEx enthält
 
=== Printing Operation in Sed ===
* is a command for printing the data from the pattern buffer.
* To suppress automatic printing of pattern space use -n command with sed.
* sed -n option will not print anything, unless an explicit request to print is found.
Syntax:
# sed -n 'ADDRESS'p filename
 
# sed -n '/PATTERN/p' filename
 
Let us first create thegeekstuff.txt file that will be used in all the examples mentioned below.
# cat thegeekstuff.txt
1. Linux - Sysadmin, Scripting etc.
2. Databases - Oracle, mySQL etc.
3. Hardware
4. Security (Firewall, Network, Online Security etc)
5. Storage
6. Cool gadgets and websites
7. Productivity (Too many technologies to explore, not much time available)
8. Website Design
9. Software Development
10.Windows- Sysadmin, reboot etc.
 
== Adressierung ==
* Es ist möglich, bestimmte Zeilen explizit auszuwählen, also zum Beispiel "Zeile 1", "Zeile 1-2", "letzte Zeile" usw.
* In diesem Falle wird die Bereichsauswahl direkt angegeben, sie steht also nicht zwischen "/" wie bei RE-Ausdrücken.
* Der Befehl 'p' steht direkt hinter der Bereichsauswahl.


=== Using Address and Patterns ===
<code>sed</code> liest eine Eingabedatei (oder einen <code>input stream</code> auf <code><stdin></code>) zeilenweise ein. Diese Eingangsdaten landen zunächst im sogenannten '''Pattern Space'''. Auf diesem Pattern Space wird nacheinander jede Anweisung des vorgegebenen Programmes ausgeführt. Jede dieser Anweisungen kann dabei den Pattern Space verändern, folgende Anweisungen werden dann auf dem jeweiligen Ergebnis der letzten Anweisung ausgeführt. Führt eine dieser Veränderungen zu einem Nulltext, so wird die Verarbeitung an dieser Stelle abgebrochen und die Anweisungsliste mit der nächsten Eingabezeile wieder von vorne begonnen. Ansonsten wird das Ergebnis der letzten Anweisung auf <code><stdout></code> ausgegeben und die Anweisungsliste ebenfalls mit der nächsten Eingabezeile wieder begonnen.
* from a file using sed address and patterns.
* “p” command prints the buffer (remember to use -n option with “p”) 
* will delete the pattern space buffer and immediately starts the next cycle. <br/>
 
==== Syntax ====
sed 'ADDRESS'd filename
 
sed /PATTERN/d filename
 
* Syntax for ADDRESSES and PATTERNS given in the printing is applicable for deletion also, except -n option. (-n only to suppress printing pattern buffer, can be used with “p” command )
* Let us first creates thegeekstuff.txt file that will be used in all the examples mentioned below.
# cat thegeekstuff.txt
1. Linux - Sysadmin, Scripting etc.
2. Databases - Oracle, mySQL etc.
3. Hardware
4. Security (Firewall, Network, Online Security etc)
5. Storage
6. Cool gadgets and websites
7. Productivity (Too many technologies to explore, not much time available)
8. Website Design
9. Software Development
10.Windows- Sysadmin, reboot etc.
 
=== ADDRESS Format Beispiele ===
==== NUMBER ====
This will match only Nth line in the input.
'''# sed -n ‘N’p filename'''
 
For example, 3p prints third line of input file thegeekstuff.txt as shown below.
# sed -n '3'p thegeekstuff.txt
3. Hardware
 
===== Erste Zeile ausgeben =====
sed -n '1p' < sed-test.txt
 
Option "-n" nicht vergessen!
 
==== NUMBER1~NUMBER2 ====
M~N with “p” command prints every Nth line starting from line M.
'''# sed -n ‘M~N’p filename'''
 
For example, 3~2p prints every 2nd line starting from 3rd line as shown below.
# sed -n '3~2'p thegeekstuff.txt
3. Hardware
5. Storage
7. Productivity (Too many technologies to explore, not much time available)
9. Software Development
 
==== START, END ====
M,N with “p” command prints Mth line to Nth line.
'''# sed -n ‘M,N’p filename'''
 
For example, 4,8p prints from 4th line to 8th line from input file thegeekstuff.txt
 
# sed -n '4,8'p thegeekstuff.txt
4. Security (Firewall, Network, Online Security etc)
5. Storage
6. Cool gadgets and websites
7. Productivity (Too many technologies to explore, not much time available)
8. Website Design
 
==== ‘$’ Last Line ====
$ with “p” command matches only the last line from the input.
'''# sed -n ‘$’p filename'''
 
For example, $p prints only the last line as shown below.
# sed -n '$'p thegeekstuff.txt
10.Windows- Sysadmin, reboot etc.
 
==== NUMBER,$ ====
N,$ with “p” command prints from Nth line to end of file.
'''# sed -n ‘N,$p’ filename'''
 
For example 4,$p prints from 4th line to end of file.
# sed -n '4,$p' thegeekstuff.txt
4. Security (Firewall, Network, Online Security etc)
5. Storage
6. Cool gadgets and websites
7. Productivity (Too many technologies to explore, not much time available)
8. Website Design
9. Software Development
10.Windows- Sysadmin, reboot etc.
 
===== Letzte Zeile ausgeben =====
sed -n '$p' < sed-test.txt
 
=== PATTERN Format Beispiele ===
==== PATTERN ====
PATTERN could be unix regular expression.
* The below command prints only the line which matches the given pattern.
'''# sed -n /PATTERN/p filename'''
 
For example, following prints the line only which matches the pattern “Sysadmin”.
# sed -n /Sysadmin/p thegeekstuff.txt
1. Linux - Sysadmin, Scripting etc.
10.Windows- Sysadmin, reboot etc.
 
==== /PATTERN/,ADDRESS ====
'''# sed -n ‘/PATTERN/,Np’ filename'''
 
For example, following prints lines which matches the pattern to Nth line, from input. 3rd line matches the pattern “Hardware”, so it prints from 3rd line to 6th line.
# sed -n '/Hardware/,6p' thegeekstuff.txt
3. Hardware
4. Security (Firewall, Network, Online Security etc)  
5. Storage
6. Cool gadgets and websites
 
==== ADDRESS,/PATTERN/ ====
* It prints from the Nth line of the input, to the line which matches the pattern.
* If the pattern doesnt match, it prints upto end of the input.
'''# sed -n ‘N,/PATTERN/p’ filename'''
 
For example, 4th line matches the pattern “Security”, so it prints from 3rd line to 4th line.  
# sed -n '3,/Security/p' thegeekstuff.txt
3. Hardware
4. Security (Firewall, Network, Online Security etc)
 
==== /PATTERN/,$ ====
It prints from the line matches the given pattern to end of file.
'''# sed -n ‘/PATTERN/,$p’ filename'''
 
# sed -n '/Website/,$p' thegeekstuff.txt
8. Website Design
9. Software Development
10.Windows- Sysadmin, reboot etc.
 
==== /PATTERN/,+N ====
It prints the lines which matches the pattern and next N lines following the matched line.
'''# sed -n ‘/PATTERN/,+Np’ filename'''
 
For example, following prints the 5th line which matches the pattern /Storage/ and next two lines following /Storage/.
# sed -n '/Storage/,+2p' thegeekstuff.txt
5. Storage
6. Cool gadgets and websites
7. Productivity (Too many technologies to explore, not much time available)
 
==== /PATTERN/,/PATTERN/ ====
Prints the section of file between two regular expression (including the matched line ).
'''# sed -n ‘/P1/,/P2/p’ filename'''
 
For example, 5th line matches “Storage” and 8th line matches “Design”, so it prints 5th to 8th.
# sed -n '/Storage/,/Design/p' thegeekstuff.txt
5. Storage
6. Cool gadgets and websites
7. Productivity (Too many technologies to explore, not much time available)
8. Website Design
 
=== Besondere Zeichen ===
==== Negation ====
Das Ausrufezeichen ("!") hinter der Bereichsauswahl bewirkt eine Negation
sed '/isst/!d' < sed-test.txt
 
* Zeilen, die "isst" nicht enthalten, werden nicht ausgegeben
sed -n '1!p' < sed-test.txt
 
* alle Zeilen außer Zeile 1 werden ausgegeben
 
==== $-Zeichen: letztes Element ====
Das $-Zeichen steht bei der Bereichsauswahl für "letzte Zeile":
sed -n '$p' < sed-test.txt
 
* letzte Zeile ausgeben
 
In einer RE steht das $-Zeichen für "Zeilenende"
sed -n '/Zeile$/p' < sed-test.txt
* Zeilen ausgeben, in denen "Zeile" am Ende steht
 
Möchte man dem Zeilenende eine Zeichenkette anhängen, genügt ein $ als Suchmuster:
sed -n 's/$/ und Schluss!/p' < sed-test.txt
* Jede Zeile endet mit ' und Schluss!'
 
==== ^ - Zeichen ====
Das ^-Zeichen steht in einer RE für Zeilenanfang:
sed -n '/^Hier/p' < sed-test.txt
* Zeilen ausgeben, in denen "Hier" am Anfang steht<br/>
 
Innerhalb einer Zeichenklasse in einer RE steht es für Verneinung.
sed -n '/F[^e]hler/p' < sed-test.txt
* Zeilen ausgeben, in denen das Wort "F.hler" vorkommt, wobei der 2.
* Buchstabe kein "e" sein darf<br/>
 
Möchte man dem Zeilenanfang eine Zeichenkette voranstellen genügt ein ^ als Suchmuster:
sed -n 's/^/Am Anfang stand /p' < sed-test.txt
* Jede Zeile beginnt mit 'Am Anfang stand '
 
== Zeilen löschen ==
=== Löschen [d] ===
Der nachfolgende Aufruf löscht alle Zeilen ab der (einschließlich) 4.
* bis zum Dateiende:
 
'''sed '4,$d' test.txt'''
  1 Der Aufruf des Stream Editors besitzt immer das Format:
  2
  3 sed 'Kommando' Dateiname
 
Das Entfernen aller Zeilen, die mit einem Leerzeichen beginnen, erledigt dieser Aufruf:
 
'''sed '/^ /d' test.txt'''
  10 Nummer Genau diese Zeile
  11 Start, Ende Alle Zeilen von "Start" bis "Ende"
  12 $ Symbolisiert die letzte Zeile
  13 RegEx Zeilen, die den Regulären Ausdruck enthalten
  14 1, RegEx Von Zeile 1 bis zur ersten Zeile, die RegEx enthält
 
Der delete-Befehl ist die Umkehrung des print-Befehls: Die bei der Bereichsauswahl (mittels RE oder explizit) selektierten Zeilen werden "gelöscht", also nicht ausgegeben.
 
sed '/isst/d' < sed-test.txt
* Zeilen, die "isst" enthalten, werden nicht ausgegeben
 
sed '3d' < sed-test.txt
* die dritte Zeile wird nicht ausgegeben


=== Beispiele ===
=== Beispiele ===
==== Lösche die Nte Zeile ====
# [[Sed/Aufruf]]
‘Nd’ deletes the Nth line and prints the other lines.
# [[Sed/Dateiübergabe]]
'''sed ‘Nd’ filename'''
# [[Sed/Ausgabe]]
It reads the first line and places in its pattern buffer. 
# [[Sed/Kommandos]]
* Check whether supplied command is true for this line, if true, deletes pattern space buffer and starts next cycle. i.e Read next line. 
# [[Sed/Substitutionen]]
* If supplied command doesnt true, as its normal behaviour it prints the content of the pattern space buffer. 
# [[Sed/Regular Expressions]]
# [[Sed/Beispieltext]]
# [[Sed/Anweisungen]]
# [[Sed/Zeilen ausgeben]]
# [[Sed/Adressierung]]
# [[Sed/Zeilen löschen]]
# [[Sed/Suchen und Ersetzen]]
# [[Sed/Mehrere Kommandos]]
# [[Sed/Einfügen]]
# [[Sed/Einfügen aus einer Datei]]
# [[Sed/Schreiben in eine Datei]]
# [[Sed/Dateien direkt bearbeiten]]
# [[Sed/Dateien ergänzen]]
# [[Sed/Nächste Zeile beabeiten]]
# [[Sed/Zeichen tauschen]]
# [[Sed/Sed vorzeitig beenden]]
# [[Sed/Zeilentausch]]
# [[Sed/Sed-Skripte]]


For example, 3d deletes 3rd line and prints other lines as shown below.
== Siehe auch ==
sed 3d thegeekstuff.txt
# [[awk]](1)
1. Linux - Sysadmin, Scripting etc.
# [[ed]](1)
2. Databases - Oracle, mySQL etc.
# [[grep]](1)
4. Security (Firewall, Network, Online Security etc)  
# [[tr]](1)
5. Storage
# [[perlre]](1)
6. Cool gadgets and websites
# sed.info
7. Productivity (Too many technologies to explore, not much time available)
# Sed-FAQ http://sed.sf.net/grabbag/tutorials/sedfaq.txt
8. Website Design
# http://sed.sf.net/grabbag/
9. Software Development
10.Windows- Sysadmin, reboot etc.


==== Delete Starting from 3rd line and every 2nd line from there. ====
sed '3~2d' thegeekstuff.txt
1.
* Linux - Sysadmin, Scripting etc.
2.
* Databases - Oracle, mySQL etc.
4.
* Security (Firewall, Network, Online Security etc)
6.
* Cool gadgets and websites
8.
* Website Design
10.Windows- Sysadmin, reboot etc.


==== Delete from 4th to 8th line from file. ====
{{Special:PrefixIndex/{{BASEPAGENAME}}}}
sed '4,8d' thegeekstuff.txt
1.
* Linux - Sysadmin, Scripting etc.
2.
* Databases - Oracle, mySQL etc.
3.
* Hardware
9.
* Software Development
10.Windows- Sysadmin, reboot etc.


==== Delete the last line from input. ====
=== Dokumentation ===
sed '$d' thegeekstuff.txt
# https://www.gnu.org/software/sed/manual/sed.html
1.  
* Linux - Sysadmin, Scripting etc.  
2.
* Databases - Oracle, mySQL etc.
3.
* Hardware
4.
* Security (Firewall, Network, Online Security etc)
5.
* Storage
6.
* Cool gadgets and websites
7.
* Productivity (Too many technologies to explore, not much time available)
8.
* Website Design
9.
* Software Development


==== Delete the line which matches the given pattern from input. ====
==== Man-Page ====
For example, the below command deletes the line which matches with “Sysadmin”.
* {{man|1|sed|posix|stream editor}}
* {{man|1|sed|bsd|stream editor}}
* {{man|1|sed|gnu|Stromeditor zum Filtern und Umwandeln von Text}}


sed /Sysadmin/d thegeekstuff.txt
==== Info-Pages ====
2.
  $ info sed
* Databases - Oracle, mySQL etc.
  3.
* Hardware
4.
* Security (Firewall, Network, Online Security etc)
5.
* Storage
6.
* Cool gadgets and websites
7.
* Productivity (Too many technologies to explore, not much time available)
8.
* Website Design
9.
* Software Development


==== Deletes the line from which matches the given pattern to end of the file. ====
=== Links ===
sed '/Website/,$d' thegeekstuff.txt
==== Projekt ====
1.  
==== Weblinks ====
* Linux - Sysadmin, Scripting etc.  
# https://de.wikipedia.org/wiki/Sed_(Unix)
2.  
# [http://sed.sourceforge.net/ sed-Projektseite auf sourceforge] (englisch)
* Databases - Oracle, mySQL etc.
# [http://sed.sourceforge.net/grabbag/ seder’s grab bag] (englisch)
3.  
# [http://www.pement.org/sed/ sed für Windows mit funktionierender -i Option] ([[ZIP-Dateiformat|ZIP]]; 50&nbsp;kB)
* Hardware
# [https://tty1.net/sed-tutorium/index.html Ausführliches Tutorium] (deutsch)
4.  
* Security (Firewall, Network, Online Security etc)  
5.  
* Storage
6.  
* Cool gadgets and websites
7.  
* Productivity (Too many technologies to explore, not much time available)  


==== Deletes the line from which matches the given pattern and 2lines next to that. ====
= Wikipedia =
sed '/Storage/,+2d' thegeekstuff.txt
== Programmierung ==
1.
<code>sed</code>-Anweisungen können grob in drei Gruppen unterteilt werden: Textmanipulationen, Verzweigungen und sonstige. (Die meisten <code>sed</code>-Handbücher wie auch die POSIX-Spezifikation unterteilen abweichend davon Anweisungen in 2-Adress-, 1-Adress- und adresslose – siehe [[Sed#Textmanipulationen|unten]] –, aber diese Gruppierung ist für Einführungszwecke nicht geeignet.)
* Linux - Sysadmin, Scripting etc.
2.
* Databases - Oracle, mySQL etc.
3.
* Hardware
4.
* Security (Firewall, Network, Online Security etc)
8.
* Website Design
9.
* Software Development
10.Windows- Sysadmin, reboot etc.  


==== Delete blank Line from a file using sed ====
=== Textmanipulationen ===
You can also remove blank lines with sed.
Dies ist die am weitaus häufigsten eingesetzte Funktion und der Befehlssatz ist hier auch besonders reichhaltig. Generell hat eine Anweisung folgende Struktur (''2-Adress-Kommando''):
* The following sed example shows how to use sed and remove blank lines.  


sed '/^$/d' thegeekstuff.txt
{| style="margin-left:2em"
1.
|-
* Linux - Sysadmin, Scripting etc.
|
2.
  <Adresse1>,<Adresse2> Kommando [Optionen]
* Databases - Oracle, mySQL etc.
|}
3.
* Hardware
  4.
* Security (Firewall, Network, Online Security etc)
5.
* Storage
6.
* Cool gadgets and websites
7.
* Productivity (Too many technologies to explore, not much time available)
8.
* Website Design
9.
* Software Development
10.Windows- Sysadmin, reboot etc.


== Suchen und Ersetzen ==
<code>Adresse1</code> und <code>Adresse2</code> können auch weggelassen werden. Werden beide Adressen angegeben, so wird <code>Kommando</code> für jede Zeile, beginnend mit jener, die mit <code>Adresse1</code> übereinstimmt, bis zu der, die mit <code>Adresse2</code> übereinstimmt, ausgeführt. Werden <code>Adresse1</code> und <code>Adresse2</code> nicht angegeben, so wird <code>Kommando</code> für jede Zeile ausgeführt, wird lediglich <code>Adresse2</code> weggelassen, so wird <code>Kommando</code> nur für Zeilen ausgeführt, die mit <code>Adresse1</code> übereinstimmen. Eine Adresse ist entweder eine Zeilennummer oder ein [[regulärer Ausdruck]]. Reguläre Ausdrücke werden dabei in zwei <code>/</code> eingeschlossen. Zwei Beispiele:
In diesem Falle steht das Trennzeichen "/" an drei Stellen: vor und hinter der RE, also dem Suchmuster und hinter dem Ersetzungsmuster.  


Der mittlere Schrägstrich ist also Ende-Delimiter für die RE und gleichzeitig Anfangs-Delimiter für den Ersetzungsstring.
{| style="margin-left:2em"
|-
|colspan="2"|
sed &apos;/Beginn/,/Ende/ s/alt/NEU/&apos; inputfile
|-
|'''Input'''
|'''Output'''
|-
|
x alt
Beginn
y alt
Ende
z alt
|
x alt
Beginn
y NEU
Ende
z alt
|}


Logischer Weise müsste der Schrägstrich viermal vorkommen, aber sed hat die beiden mittleren Schrägstriche zu einem verschmolzen.  
„alt“ wird durch „NEU“ ersetzt, aber nur ab der Zeile, die „Beginn“ enthält, bis zu der Zeile, die „Ende“ enthält (2-Adress-Variante). Hingegen wird dieselbe Ersetzung im zweiten Beispiel in allen Zeilen durchgeführt, die mit „y“ oder „z“ beginnen (1-Adress-Variante):


=== Zeichen ersetzen [s] ===
{| style="margin-left:2em"
Das dem s-Kommando folgende Zeichen wird als Trennzeichen angesehen.
|-
|colspan="2"|
sed &apos;/^[yz]/ s/alt/NEU/&apos; inputfile
|-
|'''Input'''
|'''Output'''
|-
|
x alt
Beginn
y alt
Ende
z alt
|
x alt
Beginn
y NEU
Ende
z NEU
|}


Anschließend folgt das Suchmuster und, getrennt durch das Trennzeichen, das Ersatzmuster, welches wiederum mittels des Trennzeichens abgeschlossen wird.  
==== Zusammengesetzte Kommandos ====
Anstatt eines einzelnen Kommandos kann <code>Kommando</code> auch eine Liste von Anweisungen enthalten, die durch <code>{ … }</code> umschlossen werden. Für diese Anweisungen gelten wieder die oben beschriebenen Regeln, sie können ihrerseits ebenfalls aus weiteren zusammengesetzten Kommandos bestehen. Ein Beispiel:


Prinzipiell kann jedes druckbare Zeichen als Trennzeichen Verwendung finden, es selbst darf allerdings kein Bestandteil eines Musters sein!
{| style="margin-left:2em"
|-
|colspan="2"|
sed &apos;/^[yz]/ {
                s/^\([yz]\)/(\1)/
                s/alt/NEU/
              }&apos; inputfile
|-
|'''Input'''
|'''Output'''
|-
|
x alt
Beginn
y alt
Ende
z alt
|
x alt
Beginn
(y) NEU
Ende
(z) NEU
|}


Eine Substitution sieht demnach wie folgt aus:  
=== Verzweigungen ===
<code>sed</code> kennt zwei Arten von Verzweigungen: unbedingte Verzweigungen (Sprunganweisungen) und bedingte, die in Abhängigkeit einer zuvor erfolgten oder nicht erfolgten Ersetzungsoperation zur Ausführung kommen. Ein typisches Anwendungsbeispiel ist das folgende: ein Quelltext wurde mit Hilfe von führenden [[Tabulatorzeichen]] eingerückt, diese führenden ''Tabs'' sollen durch jeweils 8 ''Blanks'' ersetzt werden. Andere als am Zeilenbeginn liegende ''Tabs'' können im Text vorkommen, sollen aber nicht verändert werden. Das Problem besteht darin, dass multiplikative Verknüpfungen (''ersetze N Tabs durch N * 8 Blanks'') nicht als RegExp ausgedrückt werden können. Andererseits würde eine globale Ersetzung auch die Tabulatorzeichen innerhalb des Texts betreffen. Deshalb wird mit Sprunganweisungen eine Schleife gebildet (im Folgenden werden ''Blanks'' und ''Tabs'' zur besseren Verständlichkeit durch <code>&lt;b&gt;</code> und <code>&lt;t&gt;</code> symbolisiert):


  sed 's/altes Muster/neues Muster/' datei
{| style="margin-left:2em"
sed 's?altes Muster?neues Muster?' datei
|-
|colspan="2"|
  sed &apos;:start
      /^&lt;b&gt;*&lt;t&gt;/ {
                  s/^\(&lt;b&gt;*\)&lt;t&gt;/\1&lt;b&gt;&lt;b&gt;&lt;b&gt;&lt;b&gt;&lt;b&gt;&lt;b&gt;&lt;b&gt;&lt;b&gt;/
                  b start
                }&apos; inputfile
|}


Im Beispiel ersetzen wir »RegEx« durch »Regulärer Ausdruck«:
In jeder Zeile wird das erste Tabulatorzeichen, sofern davor lediglich null oder mehr Leerzeichen stehen, durch 8 Leerzeichen ersetzt, danach sorgt die Sprunganweisung <code>b <Sprungzielname></code> dafür, dass die Programmausführung wieder zur ersten Zeile zurückkehrt. Ist das letzte führende Tabulatorzeichen ersetzt, so matcht der Ausdruck <code>/^&lt;b&gt;*&lt;t&gt;/</code> nicht mehr und der Block wird nicht ausgeführt, sodass das Programmende erreicht und die nächste Zeile eingelesen wird.


sed 's#RegEx#Regulärer Ausdruck#' test.txt
Hier wird die Ähnlichkeit mit Assembler-Sprachen deutlich, indem mit einer Bedingung und einem [[Label (Programmierung)|Label]] eine Kontrollstruktur vergleichbar dem in Hochsprachen üblichen <code style="white-space:nowrap">repeat-until</code> aufgebaut wird.
  1 Der Aufruf des Stream Editors besitzt immer das Format:
  2
  3 sed 'Kommando' Dateiname
  4
  5 Dabei kann dem Kommando mitgeteilt werden, welche Zeilen der
  6 Eingabedatei es bearbeiten soll.
* Als Adressierung kommen folgende
  7 Mechanismen in Frage:
  8
  9 Keine Angabe Alle Zeilen
  10 Nummer Genau diese Zeile
  11 Start, Ende Alle Zeilen von "Start" bis "Ende" 12 $ Symbolisiert die letzte Zeile
  13 Regulärer Ausdruck Zeilen, die den Regulären Ausdruck enthalten
  14 1, Regulärer Ausdruck Von Zeile 1 bis zur ersten Zeile, die RegEx enthält


=== Globale Substitution ===
=== Sonstige Anweisungen ===
Wer genau hinschaut, wird im letzten Beispiel eine fehlende Ersetzung von »RegEx« bemerkt haben (Zeile 14).  
==== Hold Space Manipulation ====
* Der Editor bearbeitet in jeder Zeile nur das erste Vorkommen.  
Eine mächtige (gleichwohl relativ unbekannte) Funktion von <code>sed</code> ist der sogenannte '''Hold Space'''. Das ist ein frei verfügbarer Speicherbereich, der in seiner Arbeitsweise dem in manchen [[Assemblersprache|Assembler-Sprachen]] bekannten [[Akkumulator (Computer)|Akkumulator]] ähnelt. Direkte Manipulation der Daten im Hold Space ist zwar nicht möglich, aber Daten im Pattern Space können in den Hold Space verlagert, kopiert, oder auch mit dem Inhalt desselben vertauscht werden. Auch das Anhängen des Pattern Spaces an den Hold Space oder vice versa ist möglich.
* Um alle Muster zu ersetzen, ist das Kommando »g« nachzustellen:


'''sed -n 's#RegEx#Regulärer Ausdruck#gp' test.txt'''
Das folgende Beispiel verdeutlicht die Funktion des Hold Space: der Text einer „Kapitelüberschrift“ wird gespeichert und jeder Zeile des jeweiligen „Kapitels“ nachgestellt, die Zeile mit der Kapitelüberschrift selbst aber unterdrückt:
  13 Regulärer Ausdruck Zeilen, die den Regulären Ausdruck enthalten
  14 1, Regulärer Ausdruck Von Zeile 1 bis zur ersten Zeile, die Regulärer Ausdruck enthält


Da wir nur an den modifizierten Zeilen interessiert sind, haben wir das Sed mitgeteilt (Option -n).
{| style="margin-left:2em"
|-
|colspan="2"|
sed &apos;/^=/ {
              s/^=//
              s/^/ (/
              s/$/)/
              h
              d
          }
      G; s/\n// &apos; inputfile
|-
|'''Input'''
|'''Output'''
|-
|
=Kapitel1
Zeile 1
Zeile 2
Zeile 3
=Kapitel2
Zeile A
Zeile B
Zeile C
|
Zeile 1 (Kapitel1)
Zeile 2 (Kapitel1)
Zeile 3 (Kapitel1)
Zeile A (Kapitel2)
Zeile B (Kapitel2)
Zeile C (Kapitel2)
|}


Allerdings würde nun das Substitutionskommando die gesamte Ausgabe unterdrücken, hätten wir dem nicht mit dem p-Kommando entgegen gewirkt.  
Immer wenn eine Zeile mit „=“ beginnt, so wird der Anweisungsblock ausgeführt, der dieses Zeichen entfernt und dafür die restliche Zeile mit einem führenden Leerzeichen und Klammern versieht. Danach wird dieser Text in den Hold Space kopiert (<code>h</code>) und aus dem Pattern Space gelöscht (<code>d</code>), wodurch das Programm für diese Zeile beendet und die nächste Zeile gelesen wird. Da für „normale Zeilen“ die Bedingung des Eingangsblocks nicht zutrifft, wird lediglich die letzte Anweisung (<code>G</code>) durchgeführt, die den Inhalt des Hold Space an den Pattern Space anhängt.


==== Speichern von Mustern und den späteren Zugriff darauf ====
==== Mehrzeilen-Anweisungen ====
Es soll die Numerierung der Zeilen von Einer- auf Zehnerschritte erhöht werden:  
Nicht alle Textmanipulationen lassen sich innerhalb einzelner Zeilen ausführen. Manchmal müssen Informationen aus anderen Zeilen in die Entscheidungsfindung miteinbezogen werden, manchmal auch zeilenübergreifende Ersetzungen durchgeführt werden. Dafür sieht die <code>sed</code>-Programmiersprache die Anweisungen <code>N</code>, <code>P</code> und <code>D</code> vor, mit denen mehrere Zeilen des Eingabetexts gleichzeitig in den Pattern Space geladen (<code>N</code>) und Teile davon ausgegeben (<code>P</code>) oder gelöscht (<code>D</code>) werden können. Ein typisches Anwendungsbeispiel ist der folgende Einzeiler (eigentlich zwei Einzeiler), der einen Text mit Zeilennummern versieht:


'''sed 's/^\([[:space:]]*[1-9]\{1,\}\)/\10/' test.txt'''
{| style="margin-left:2em"
  10 Der Aufruf des Stream Editors besitzt immer das Format:
|-
  20
|colspan="2"|
  30 sed 'Kommando' Dateiname
sed &apos;=&apos; inputfile | sed &apos;N; s/\n/&lt;t&gt;/&apos;
  40
|}
  50 Dabei kann dem Kommando mitgeteilt werden, welche Zeilen der
  60 Eingabedatei es bearbeiten soll.
* Als Adressierung kommen folgende
  70 Mechanismen in Frage:
  80
  90 Keine Angabe Alle Zeilen
  100 Nummer Genau diese Zeile
  110 Start, Ende Alle Zeilen von "Start" bis "Ende"
  120 $ Symbolisiert die letzte Zeile
  130 RegEx Zeilen, die den Regulären Ausdruck enthalten
  140 1, RegEx Von Zeile 1 bis zur ersten Zeile, die RegEx enthält* Das Beispiel profitiert von dem Wissen, dass die Zeilenummer am Beginn der Zeile zu finden ist.
* Das Muster, dem unser Interesse gilt, sind alle Ziffern zu Beginn der Zeile, wobei führende Leerzeichen durchaus möglich sind.
* Genau jenes Muster merken wir uns für den späteren Gebrauch vor, indem wir es in »\(...\)« einschließen.
* Der Zugriff auf dieses erste gespeicherte Muster im Ersatzmuster erfolgt durch »\1«. <br/>Bis zu 9 Muster lassen sich pro Zeile speichern, die entsprechend ihrer Reihenfolge mittels \1, \2,... \9 referenziert werden.


==== Beispiel ====
Der erste <code>sed</code>-Aufruf druckt für jede Zeile im Eingangstext die Zeilennummer aus und danach die Zeile selbst. Der zweite <code>sed</code>-Aufruf verbindet diese beiden Zeilen zu einer einzigen, indem erst die jeweils nachfolgende Zeile eingelesen (<code>N</code>) und dann das automatisch eingefügte Zeilentrennzeichen („\n“) durch ein Tabulatorzeichen ersetzt wird.
"isst" soll in allen Zeilen durch "ist" ersetzt werden.
* Eigentlich müssten pro String ein Anfangs-/Ende-Delimiter verwendet werden.
/isst//ist/
* beide Strings müssten durch "/" begrenzt werden
* sed verschmilzt die mittleren Schrägstriche zu einem!
/isst/ist/
* # dies erscheint zunächst unlogisch.


Der Befehl "s" für "suchen & ersetzen" steht vor(!) der RE.  
== Anwendungen, Optionen, Hinweise ==
=== Kapazitätsgrenzen ===
<code>sed</code> unterliegt keinen (realen) Beschränkungen hinsichtlich der Dateigrößen. Abgesehen vom verfügbaren Plattenplatz, der eine praktische Grenze darstellt, realisieren die meisten Implementationen den Zeilenzähler als <code>int</code> oder <code>long int</code>. Bei den heute üblichen 64-Bit-Prozessoren kann die Gefahr eines Überlaufs deshalb vernachlässigt werden.


sed 's/isst/ist/' < sed-test.txt
Wie die meisten textmanipulierenden Tools in UNIX unterliegt <code>sed</code> allerdings einer Begrenzung hinsichtlich der Zeilenlänge (genauer: der Anzahl Bytes bis zum nachfolgenden <code>newline</code>-Zeichen). Die Mindestgröße ist durch den POSIX-Standard festgelegt, die tatsächliche Größe kann von System zu System variieren und kann im jeweiligen Fall in der Kernel-Headerdatei <code>/usr/include/limits.h</code> als Wert der Konstanten <code>LINE_MAX</code> nachgeschlagen werden. Die Länge wird in ''Bytes'' angegeben, nicht in ''Zeichen'' (weshalb eine Umrechnung etwa bei der Verarbeitung von UTF-codierten Dateien, die einzelne Zeichen mit mehreren Bytes darstellen, nötig ist).
* Befehl "s" steht am Anfang!
* sed selektiert alle Zeilen, in denen "isst" vorkommt, ersetzt "isst" durch "ist"
* und gibt das Ergebnis am Bildschirm aus


Um die Änderungen in die Datei zu schreiben, gibt es zwei Möglichkeiten:
=== Greedyness ===
{{Siehe auch|Regulärer Ausdruck}}
Beim Geltungsbereich von <code>RegExp</code>s wird zwischen ''greedy'' und ''non-greedy'' unterschieden. <code>sed</code>-<code>RegExp</code>s sind immer ''greedy'', das bedeutet, dass die <code>RegExp</code> immer den längstmöglichen Geltungsbereich hat:


===== mit Hilfe einer temporären Datei =====
{| style="margin-left:2em"
  sed 's/isst/ist/' < sed-test.txt > sed-test2.txt * Ausgabe in temporäre Datei umleiten
|-
|colspan="2"|
  /a.*B/; "&apos;a&apos;, gefolgt von null oder mehr beliebigen Zeichen, gefolgt von &apos;B&apos;"


  vim sed-test2.txt* Ergebnis kontrollieren!
  '''axyBBBskdjfhaaBBpweruB'''jdfh ; längstmöglicher Geltungsbereich (greedy)
'''axyB'''BBskdjfhaaBBpweruBjdfh ; kürzestmöglicher Geltungsbereich (non-greedy)
|}


mv sed-test2.txt sed-test.txt* Originaldatei ersetzen durch temporäre Datei
Der Grund ist, dass <code>sed</code> auf Geschwindigkeit optimiert ist und non-greedy <code>RegExp</code>s aufwendiges [[Backtracking]] erfordern würde. Will man ein Non-greedy-Verhalten erzwingen, so erreicht man dies üblicherweise durch negierte Zeichenklassen. Im obigen Beispiel etwa:


===== direkt =====
{| style="margin-left:2em"
  sed -i 's/isst/ist/' sed-test.txt* Vorsicht, Änderungen werden direkt in Datei geschrieben!
|-
|colspan="2"|
  /a[^B]*B/ ; "'a', gefolgt von null oder mehr nicht-'B', gefolgt von 'B'"
|}


Im Beispiel würde sed in jeder Zeile nur das erste gefundene "isst" durch "ist" ersetzen.
=== Praktische Grenzen in der Shell-Programmierung ===
* Um zu erreichen, dass alle Fundstellen geändert werden, muss ans Ende der Anweisung der g-Spezifizierer (=global) gesetzt werden:  
Es sollte nicht unerwähnt bleiben, dass die allerhäufigste Anwendung von <code>sed</code> (aber auch von <code>[[awk]]</code>, <code>[[Tr (Unix)|tr]]</code> und ähnlichen Filterprogrammen) in der Praxis – die Manipulation ''ad hoc'' von Ausgaben anderer Kommandos, etwa so:


  sed 's/isst/ist/g' < sed-test.txt
{| style="margin-left:2em"
|-
|
  ls -l /path/to/myfile | sed &apos;s/^\([^ ][^ ]*\) .*/\1/&apos; # gibt Filetype und Filemode aus
|}


=== Selektives Suchen und Ersetzen ===
genaugenommen einen Missbrauch darstellt. Da jeder Aufruf eines externen Programmes die aufwendigen Systemaufrufe <code>[[Fork (Unix)#Nutzung von Fork zum Starten anderer Programme|fork()]]</code> und <code>exec()</code> erfordert, sind Shell-interne Methoden, etwa die sogenannte ''Variablenexpansion'', selbst wenn sie deutlich länger zu schreiben sind, meist dem Aufruf von externen Programmen überlegen.<ref>{{Internetquelle |url=http://www.unix.com/302248917-post19.html |titel=Comparing the Run-Time Efficiency of a ROT13 Algorithm in tr vs. ksh93 |sprache=en |zugriff=2013-03-25}}</ref> Die Faustregel dafür lautet: wenn die Ausgabe des Filterprozesses eine Datei bzw. ein Datenstrom ist, so ist das Filterprogramm zu verwenden, ansonsten ist Variablenexpansion vorzuziehen.
Beim "normalen" Suchen und Ersetzen werden alle Zeilen in den Suchvorgang einbezogen.  
* Es kommt jedoch vor, dass die Ersetzung nur innerhalb eines bestimmten Bereiches erfolgen soll.  
* Die Bereichsauswahl kann, wie oben beschrieben, über eine RE oder explizit erfolgen.  


==== Beispiel ====
=== In-Place-Editing ===
Ans Ende aller Zeilen, in denen "isst" vorkommt, soll " --Fehler!" angehängt werden.
Aufgrund der Art wie <code>sed</code> Textmanipulationen durchführt, kann dies nicht direkt auf der Eingabedatei geschehen. Als Ausgabe wird eine von dieser getrennte Datei benötigt, die gegebenenfalls danach über die Eingangsdatei kopiert wird.
* Das normale Suchen und Ersetzen hilft hierbei nicht weiter, denn "isst" soll ja nicht ersetzt werden, sondern dient nur Selektion der Zeilen, an die das Suffix angehängt werden soll.  


Es sind also zwei Vorgänge erforderlich:* Bereichsauswahl über die RE "/isst/"
{| style="margin-left:2em"
* Suchen des Zeilenendes und ersetzen durch " --Fehler!".
|-
|colspan="2"|
sed &apos;…<Anweisungen>…&apos; /path/to/inputfile > /path/to/output
mv /path/to/output /path/to/input
|}


Genau genommen wird nicht das Zeilenende ersetzt, sondern ein gedachte fiktives "leer-Zeichen" (sozusagen "") vor dem Zeilenende.  
Dies ist auch so im POSIX-Standard vorgesehen. Die GNU-Version von sed bietet zusätzlich zum POSIX-Standard die Kommandozeilen-Option <code>-i</code>. Diese erlaubt es, eine Datei scheinbar ohne Umweg (''in place'') zu verändern, tatsächlich wird aber im Hintergrund ebenfalls eine temporäre Datei angelegt. Diese wird im Fehlerfall nicht gelöscht und die Metadaten (Besitzer, Gruppe, Inode-Nummer, …) der Originaldatei auf jeden Fall verändert.


Damit sed weiß, dass sich Suchen und Ersetzen nur auf die Bereichsauswahl bezieht, steht es hinter der Bereichsauswahl in geschweiften Klammern.  
=== <code>RegExp</code>-Notation ===
* Sie können auch weggelassen werden.  
Es hat sich eingebürgert, ''regular Expressions'' – wie auch in den obigen Beispielen – durch Schrägstriche zu begrenzen. <code>sed</code> erfordert dies allerdings nicht. Jedes Zeichen, das einem Ersetzungskommando folgt, wird als Begrenzer akzeptiert und dann in der Folge erwartet. Diese beiden Anweisungen sind deshalb gleichwertig:
* Ich rate jedoch dazu, sie zu verwenden, da die Logik des Befehls dadurch klarer wird.  


sed '/isst/{s/$/ --Fehler!/}' < sed-test.txt
{| style="margin-left:2em"
* /isst/ -> Bereichsauswahl über RE
|-
* {...} -> Anweisung in "{...}" bezieht sich auf die vorangestellte Bereichsauswahl
|colspan="2"|
  * $ -> Platzhalterzeichen für "Zeilenende" (in Suchen & Ersetzen Anweisungen)
  s/^\([^ ][^ ]*\) \([^ ][^ ]*\)/\2 \1/ ; vertauscht erstes und zweites Wort einer Zeile
  * s/$/ --Fehler!/ -> fiktives "leer-Zeichen" vor dem Zeilenende wird ersetzt durch " --Fehler!"
  s_^\([^ ][^ ]*\) \([^ ][^ ]*\)_\2 \1_ ; "_" statt "/"
|}


Bei expliziter Bereichsauswahl funktioniert dies analog.  
Dies ist praktisch, wenn der Schrägstrich als Teil der <code>RegExp</code> benötigt wird, weil man sich dann das mühsame ''Escapen'' (Kenntlichmachen der Verwendung als [[Literal]]) ersparen kann. Man weicht dann einfach auf ein anderes, nicht verwendetes Zeichen aus.


==== Beispiel ====
=== Einige typische Verfahren ===
Ans Ende der 2.  
==== Löschung von Textteilen ====
* und 3.
Erfolgt durch ''Ersetzung durch nichts''. Explizite Löschung für Teile einer Zeile ist nur vom Zeilenbeginn bis zum ersten Zeilentrennzeichen (<code>D</code>) vorgesehen. Der Ausdruck
* Zeile soll " --Fehler!" gesetzt werden.  


sed '2,3{s/$/ --Fehler!/}' < sed-test.txt
{| style="margin-left:2em"
* 2,3 -> explizite Bereichsauswahl: Zeile 2-3
|-
|
/Ausdruck/d
|}


Beachten Sie, dass die explizite Bereichsauswahl durch keine Delimiterzeichen "/" eingegrenzt ist.  
löscht hingegen '''NICHT''' den Teil ''Ausdruck'', sondern jede Zeile, die ''Ausdruck'' enthält! ''Ausdruck'' fungiert hier als die Adresse (siehe oben, 1-Adress-Variante des Kommandos <code>d</code>).


==== Beispiel ====
==== Ansprechen von mindestens einem Zeichen ====
Ans Ende der letzten Zeile soll " --Ende" gesetzt werden.  
Im Umfang der POSIX-BREs ist – im Unterschied zu den GNU-BREs – der [[Regexp#Quantoren|Quantor]] <code>\+</code> für ''ein oder mehrere des vorangegangenen Ausdrucks'' nicht vorgesehen. Um portable <code>sed</code>-Scripte zu schreiben, die nicht nur mit GNU-sed laufen, sollte der [[Regexp#Quantoren|Quantor]] <code>\{min,\}</code> verwendet werden.


sed '${s/$/ --Fehler!/}' < sed-test.txt
{| style="margin-left:2em"
* # $ -> explizite Bereichsauswahl; "$" steht hier für "letzte Zeile"
|-
 
|colspan="2"|
==== Beispiel ====
  /xa\+y/ ; GNU-Variante für "'x' gefolgt von einem oder mehr (aber nicht null) 'a', gefolgt von 'y'"
an den Anfang der ersten Zeile soll "Anfang--" gesetzt werden.
  /xa\{1,\}y/ ; dasselbe in POSIX: "'x' gefolgt von mindestens einem 'a', gefolgt von 'y'"
 
|}
sed '1{s/^/Anfang--/}' < sed-test.txt
* 1 -> explizite Bereichsauswahl
* ^ -> Platzhalterzeichen für "Zeilenanfang"
* ein fiktives "leer-Zeichen" ("") am Zeilenanfang wird ersetzt durch "Anfang--"
 
Der vorige Befehl funktioniert auch ohne {}, ist aber schwerer zu lesen:  
 
sed '1s/^/Anfang--/' < sed-test.txt
 
=== Control-Character ===
Mit Hilfe von sed können verschiedenste Konvertierungen durchgeführt werden, zum Beispiel von DOS- (CR-LF) zix Dateiendezeichen (LF).
* Control-Character können entweder als escape-character oder als hexadezimal-character dargestellt werden.
 
==== Wichtige control-character ====
Bezeichnung escape hex "cat -A"
linefeed \n \x0a $
carriage-return \r \x0d ^M
tab \t \x09 ^I
 
Kontrollzeichen innerhalb von Variablen lassen sich auch sehr gut mit Hilfe des l-Befehls von sed am Bildschirm darstellen.
* Dies ist eine Alternative zu "cat -A"
 
a=$'Tabulator: \x09 CR: \x0d LF: \x0a'
echo -e "$a" | sed -n 'l'
 
==== Escape-character ====
a="Zeile1\r\nZeile2"
 
am Ende von Zeile1 steht CR-LF (=DOS-Zeilenende)
 
echo -e "$a" | cat -A
 
Inhalt wird inkl.
* Kontrollzeichen ausgegeben und darstellbar gemacht (cat -A), der carriage-return wird als ^M dargestellt (0x0D)
 
  echo -e "$a" | sed 's/\r//' | cat -A
 
der carriage-return wird durch "leer" ersetzt, ^M wird nicht mehr angezeigt
 
unset a
 
==== Hexadezimal-character ====
a=$'Zeile1\x0d\x0aZeile2'  
 
am Ende von Zeile1 steht CR-LF (0x0d+0x0a)
 
echo -e "$a" | cat -A
  echo -e "$a" | sed 's/\x0d//' | cat -A
  unset a
 
=== Beispiele ===
==== Text in Dateien mit RegEx ====
In this article let us review how to use sed substitute command “s”.
* The `s’ command is probably the most important in `sed’ and has a lot of different options.
 
The `s’ command attempts to match the pattern space against the supplied REGEXP; if the match is successful, then that portion of the pattern space which was matched is replaced with REPLACEMENT.
 
Syntax:
#sed 'ADDRESSs/REGEXP/REPLACEMENT/FLAGS' filename
 
*  s is substitute command
* / is a delimiter
*  REGEXP is regular expression to match
*  REPLACEMENT is a value to replace
 
 
 
g Replace all the instance of REGEXP with REPLACEMENT
*  n Could be any number,replace nth instance of the REGEXP with REPLACEMENT.
*  p If substitution was made, then prints the new pattern space.
*  i match REGEXP in a case-insensitive manner.
*  w file If substitution was made, write out the result to the given file.
*  We can use different delimiters ( one of @ % ; : ) instead of /
 
 
 
Let us first create thegeekstuff.txt file that will be used in all the examples mentioned below.
 
cat thegeekstuff.txt
# Instruction Guides
1.
* Linux Sysadmin, Linux Scripting etc.
2.
* Databases - Oracle, mySQL etc.
3.
* Security (Firewall, Network, Online Security etc)
4.
* Storage in Linux
5.
* Productivity (Too many technologies to explore, not much time available)
# Additional FAQS
6.
* Windows- Sysadmin, reboot etc.
 
Let us review some interesting examples for substitution now.
 
==== Ersetzen von “Linux” durch “Unix” (s) ====
In the example below, in the output line “1.
* Linux-Unix Sysadmin, Linux Scripting etc” only first Linux is replaced by Linux-Unix.
* If no flags are specified the first match of line is replaced.
 
sed 's/Linux/Unix/' thegeekstuff.txt
# Instruction Guides
1.
* Unix Sysadmin, Linux Scripting etc.
2.
* Databases - Oracle, mySQL etc.
3.
* Security (Firewall, Network, Online Security etc)
4.
* Storage in Unix
5.
* Productivity (Too many technologies to explore, not much time available)
# Additional FAQS
6.
* Windows- Sysadmin, reboot etc.
 
==== Alle Treffer ersetzen (s//g) ====
The below sed command replaces all occurrences of Linux to Linux-Unix using global substitution flag “g”.
 
sed 's/Linux/Linux-Unix/g' thegeekstuff.txt
# Instruction Guides
1.
* Linux-Unix Sysadmin, Linux-Unix Scripting etc.
2.
* Databases - Oracle, mySQL etc.
3.
* Security (Firewall, Network, Online Security etc)
4.
* Storage in Linux-Unix
5.
* Productivity (Too many technologies to explore, not much time available)
# Additional FAQS
6.
* Windows- Sysadmin, reboot etc.
 
==== Jeden zweiten Treffer ersetzen (s//2) ====
In the example below, in the output line “1.
* Linux Sysadmin, Linux-Unix Scripting etc.” only 2nd occurance of Linux is replaced by Linux-Unix.
 
sed 's/Linux/Linux-Unix/2' thegeekstuff.txt
# Instruction Guides
1.
* Linux Sysadmin, Linux-Unix Scripting etc.
2.
* Databases - Oracle, mySQL etc.
3.
* Security (Firewall, Network, Online Security etc)
4.
* Storage in Linux
5.
* Productivity (Too many technologies to explore, not much time available)
# Additional FAQS
6.
* Windows- Sysadmin, reboot etc.


==== Nur ersetzen, wenn eine Zeile einen Treffer ergibt ====
==== Ersetzung mehrerer bzw. aller Vorkommen innerhalb einer Zeile ====
In this example, if the line matches with the pattern “-”, then it replaces all the characters from “-” with the empty.
Ohne Angabe weiterer Optionen wird immer nur das erste Vorkommen eines Suchtexts der Ersetzungsregel unterworfen:


sed '/\-/s/\-.*//g' thegeekstuff.txt
{| style="margin-left:2em"
# Instruction Guides
1.
* Linux Sysadmin, Linux Scripting etc.
2.
* Databases
 
3.
4.
5.
#
6.
 
Security (Firewall, Network, Online Security etc)
Storage in Linux
Productivity (Too many technologies to explore, not much time available)
Additional FAQS
Windows
 
==== Letzten X Zeichen jeder Zeile löschen ====
This sed example deletes last 3 characters from each line.
 
sed 's/...$//' thegeekstuff.txt
# Instruction Gui
1.
* Linux Sysadmin, Linux Scripting e
2.
* Databases - Oracle, mySQL e
3.
* Security (Firewall, Network, Online Security e
4.
* Storage in Li
5.
* Productivity (Too many technologies to explore, not much time availab
# Additional F
6.
* Windows- Sysadmin, reboot e
 
==== Kommentare löschen ====
Delete all the comment lines from a file as shown below using sed command.
 
'''sed -e 's/#.*//' thegeekstuff.txt'''
1.
* Linux Sysadmin, Linux Scripting etc.
2.
* Databases - Oracle, mySQL etc.
3.
* Security (Firewall, Network, Online Security etc)
4.
* Storage in Linux
5.
* Productivity (Too many technologies to explore, not much time available)
6.
* Windows- Sysadmin, reboot etc.
 
==== Kommentare und leere Zeilen löschen ====
In this example, there are two commands seperated by ‘;’
 
First command replaces the lines starting with the # to the blank lines
 
Second command deletes the empty lines.
 
'''sed -e 's/#.*//;/^$/d' thegeekstuff.txt'''
1.
* Linux Sysadmin, Linux Scripting etc.
2.
* Databases - Oracle, mySQL etc.
3.
* Security (Firewall, Network, Online Security etc)
4.
* Storage in Linux
5.
* Productivity (Too many technologies to explore, not much time available)
6.
* Windows- Sysadmin, reboot etc.
 
==== Zeilenwechsel konvertieren ====
===== DOS newlines (CR/LF) ins Unix-Format ändern =====
Copy the DOS file to Unix, you could find \r\n in the end of each line.
 
This example converts the DOS file format to Unix file format using sed command.
 
'''$sed 's/.$//' filename'''
 
==== Rekursives Suchen und Ersetzen ====
Ersetzen einer Zeichenkette in allen Daten einer Verzeichnisstruktur.
 
'''find . -type f -print0 | xargs -0 -n 1 sed -i -e "s/suche/ersetze/g"'''
 
===== Beispiel mit escape Zeichen \ =====
''‘typo3temp/pics''' ersetzen mit ''‘../../typo3temp/pics'''
 
'''find . -name *.html -type f -print0 | xargs -0 -n 1 sed -i -e \ "s/’temp\/pics/’..\/..\/temp\/pics/g"'''
 
==== HTML Tags aus Datei entfernen ====
In this example, the regular expression given in the sed command matches the html tags and replaces with the empty.
 
'''sed -e 's/<[^>]*>//g''''
This <b> is </b> an <i>example</i>.
This is an example.
 
== Mehrere Kommandos [-e] ==
Das Problem mit Kommandos wie »s« ist, dass sie keine Adressierung zulassen.
 
Sicher gibt es Situationen, wo nur ein Teil einer Datei zu bearbeiten ist.
 
Hier hilft das e-Kommando, mit dem sich beliebig viele Kommandos kombinieren lassen:
 
'''sed -e '3,$d' -e 's# #.#g' test.txt'''
.1 Der.Aufruf.des.Stream.Editors.besitzt.immer.das.Format:
.2 * Zuerst werden alle Zeilen ab der 3.
* Zeile entfernt
* anschließend die Leerzeichen durch Punkte ersetzt<br/>
 
'''Die Reihenfolge der Kommandos kann das Ergebnis beeinflussen'''
* Eine alternative Angabe ist die Gruppierung mehrerer Kommandos.
Hierzu werden diese in geschweifte Klammern gesetzt und ein Semikolon nach jedem Kommando eingefügt
'''sed '{s/ /./g;3,$d}' test.txt'''
  .1 Der.Aufruf.des.Stream.Editors.besitzt.immer.das.Format:
  .2
 
==== Verkettung von sed-Anweisungen ====
* sed-Anweisungen lassen sich entweder mit Hilfe der Option "-e" aneinanderreihen oder mittels Pipe.
* Die Aneinanderreihung mittels Pipe macht dann Sinn, wenn die Auswahlmenge schrittweise reduziert werden soll, analog zum Aneinanderpipen von grep-Kommandos.
 
===== Beispiel =====
In der Datei httpd.conf sollen nur die Zeilen ausgegeben werden, die nicht mit "#" beginnen.
* Sodann soll "Allow" durch "Deny" ersetzt werden.
* Zunächst werden Zeilen selektiert, die nicht mit "#" beginnen.
* Die Ausgabe wird sodann mittels Pipe an einen weiteren sed-Prozess zu übergeben, der die Wortersetzung durchführt.
cat httpd.conf | sed -n '/^[^#]/p' | sed 's/Allow/Deny/'
# Reduktion der Auswahlmenge
# Ersetzung
 
Eine andere Möglichkeit besteht darin, mehrere Anweisungen an sed zu übergeben, die sukzessive abgearbeitet werden.
* Dies kann zum Beispiel dann verwendet werden, wenn innerhalb einer Datei mehrere "Suchen & Ersetzen"-Befehle nacheinander durchgeführt werden sollen.
 
Nach jedem s-Befehl werden sämtliche Zeilen ausgegeben, sodass beim folgenden s-Befehl wieder die gesamte Datei zur Verfügung steht.
 
===== Beispiel =====
in der Datei httpd.conf soll "Allow" durch "Deny" ersetzt werden und "localhost" durch "myserver"
 
cat httpd.conf | sed -e 's/Allow/Deny/g' -e 's/localhost/myserver/g'
# Ersetzung1
# Ersetzung2
 
Statt mehrere Anweisung mittels "-e" aneinanderzureihen, kann man diese auch durch ";" verketten, wobei das einfache Hochkomma nur am Anfang und am Ende stehen darf.
 
Die Option "-e" kann hierbei weggelassen werden.
 
cat httpd.conf | sed 's/Allow/Deny/g; s/localhost/myserver/g'
* analog zur vorigen Anweisung
 
== Einfügen [i|a] ==
Der einzufügende Text muss auf einer neuen Zeile stehen, wobei jede Zeile bis auf die letzte durch einen Backslash abzuschließen ist. * »i« (insert) fügt den Text '''vor '''der betreffenden Zeile ein
* »a« (append) schreibt den neuen Text '''nach '''der Zeile.
 
==== Beispiel ====
'''sed '8i\
  ===========================================\
  Angabe Bereich von Zeilen\
  ===========================================' test.txt'''
  1 Der Aufruf des Stream Editors besitzt immer das Format:
  2
  3 sed 'Kommando' Dateiname
  4
  5 Dabei kann dem Kommando mitgeteilt werden, welche Zeilen der
  6 Eingabedatei es bearbeiten soll.
* Als Adressierung kommen folgende
  7 Mechanismen in Frage:
  ===========================================
  Angabe Bereich von Zeilen
  ===========================================
  8
  9 Keine Angabe Alle Zeilen
  10 Nummer Genau diese Zeile
  11 Start, Ende Alle Zeilen von "Start" bis "Ende"
  12 $ Symbolisiert die letzte Zeile
  13 RegEx Zeilen, die den Regulären Ausdruck enthalten
  14 1, RegEx Von Zeile 1 bis zur ersten Zeile, die RegEx enthält
 
== Einfügen aus einer Datei [r] ==
In seltenen Fällen wird ein Text nur in eine einzige Datei eingefügt werden, sonst wäre der Griff zu einem herkömmlichen Editors der effizientere Weg.
 
Eine Methode ist, den einzusetzenden Text in einer separaten Datei zu erfassen und Sed jene unterzuschieben.
 
'''cat ins.txt'''
  ===========================================
  Angabe Bereich von Zeilen
  ===========================================
  Dieser Text lässt sich mittels des r-Kommandos einfach an beliebiger Stelle einordnen:
'''sed '8r ins.txt' test.txt'''
  1 Der Aufruf des Stream Editors besitzt immer das Format:
  2
  3 sed 'Kommando' Dateiname
  4
  5 Dabei kann dem Kommando mitgeteilt werden, welche Zeilen der
  6 Eingabedatei es bearbeiten soll.
* Als Adressierung kommen folgende
  7 Mechanismen in Frage:
  8
  ===========================================
  Angabe Bereich von Zeilen
  ===========================================
  9 Keine Angabe Alle Zeilen
  10 Nummer Genau diese Zeile
  11 Start, Ende Alle Zeilen von "Start" bis "Ende"
  12 $ Symbolisiert die letzte Zeile
  13 RegEx Zeilen, die den Regulären Ausdruck enthalten
  14 1, RegEx Von Zeile 1 bis zur ersten Zeile, die RegEx enthält
 
== Schreiben in eine Datei [w] ==
Das Ergebnis des Stream Editors lässt sich in einer Datei speichern:
'''sed -n '/^1/w out.txt' test.txt'''
'''cat out.txt'''
  10 Nummer Genau diese Zeile
  11 Start, Ende Alle Zeilen von "Start" bis "Ende"
  12 $ Symbolisiert die letzte Zeile
  13 RegEx Zeilen, die den Regulären Ausdruck enthalten
  14 1, RegEx Von Zeile 1 bis zur ersten Zeile, die RegEx enthält
 
==== Änderungen in Datei schreiben und auf Konsole (s//gpw) ====
The example below has substitution with three flags.
* It substitutes all the occurance of Linux to Linux-Unix and prints the substituted output as well as written the same to the given the file.
 
sed -n 's/Linux/Linux-Unix/gpw output' thegeekstuff.txt
1. Linux-Unix Sysadmin, Linux-Unix Scripting etc.
4. Storage in Linux-Unix
 
cat output
1. Linux-Unix Sysadmin, Linux-Unix Scripting etc.
4. Storage in Linux-Unix
 
== Dateien direkt bearbeiten ==
* Häufig ist es sinnvoll Dateien direkt zu bearbeiten, anstatt sie auf die Standardausgabe zu schreiben.
* Dies ist mit der Option »-i« möglich.
Der folgende Befehl ersetzt alle "Hallo" in der Datei test.txt durch "Hey", ohne eine Ausgabe zu erzeugen.
'''sed -i"" 's|Hallo|Hey|g' test.txt'''
* Achtung! Das "" nach -i ist notwendig.
* Mit dieser Option ist es auch sehr einfach möglich mehrere Dateien zu bearbeiten.
Hiermit werden alle Dateien im aktuellen Ordner die mit .txt enden wie gerade beschrieben bearbeitet:
'''sed -i"" 's|Hallo|Hey|g' *.txt'''
 
== Dateien ergänzen ==
=== Zeile am Dateianfang einfügen ===
Dies ist auch ohne sed möglich, zum Beispiel mit Hilfe von echo und cat
cat - <<< "Anfang" sed-test.txt > sed-test2.txt
echo "Anfang" | cat - sed-test.txt > sed-test2.txt
echo "Anfang" > sed-test2.txt; cat sed-test.txt >> sed-test2.txt
 
Mit Hilfe von sed geht dies eleganter.
sed '1iAnfang' < sed-test.txt > sed-test2.txt
* 1=Zeile 1 (explizite Bereichsauswahl)
* i=insert-Befehl
 
=== Zeile innerhalb des Textes einfügen ===
Die folgende Anweisung fügt eine neue Zeile vor der vorletzten Zeile ein.
sed '/vorletzte/idies ist die vorvorletzte Zeile' < sed-test.txt > sed-test2.txt
* /vorletzte/ = Bereichsauswahl über RE
* i=insert-Befehl
 
=== Zeile ans Dateiende anhängen ===
sed '$aEnde' < sed-test.txt > sed-test2.txt
* $=letzte Zeile (explizite Bereichsauswahl)
* a=append-Befehl
 
=== Zeichen am Zeilenanfang einfügen ===
Das Zeichen "#" soll in allen Zeilen an den Zeilenanfang gesetzt werden.
sed 's/^/#/' < sed-test.txt
* s =suchen & ersetzen
* /^/ ="Zeilenanfangszeichen"
* /#/ = Replace-String
 
Die Anweisung erscheint auf den ersten Blick nicht ganz logisch.
* Sie ist folgendermaßen zu interpretieren: Ersetze in jeder Zeile das am Zeilenanfang gedachte fiktive "leer-Zeichen" (sozusagen "") durch das #-Zeichen.
 
Es wird also nicht der Zeilenanfang selbst ersetzt, was ja gar nicht möglich wäre, da es kein Zeilenanfangszeichen analog zum Zeilenendezeichen gibt.
* Einfacher verständlich wird die Anweisung, wenn man ein bestimmtes Wort am Zeilenanfang ersetzen lässt:
sed 's/^Hier/Dort/' < sed-test.txt
 
* Hier" am Zeilenanfang wird ersetzt durch "Dort"
 
===== Beispiel =====
Das Zeichen "#" soll bei Zeilen, die mit "Hier" beginnen an den Zeilenanfang gesetzt werden.
sed 's/^Hier/#Hier/' < sed-test.txt
 
===== Beispiel =====
Das Zeichen "#" soll in Zeilen, in denen "letzt" vorkommt, an den Zeilenanfang gesetzt werden.
* Dieser Fall unterscheidet sich von den vorigen, weil das "suchen & ersetzen" auf einen bestimmten Bereich beschränkt werden muss.
* Hierzu werden geschweifte Klammern verwendet.
sed '/letzt/{s/^/#/}' < sed-test.txt
* /letzt/ =RE; Zeilen, in denen "letzt" vorkommt, werden selektiert
* {s...} = "suchen & ersetzen" wird nur in den selektierten Zeilen ausgeführt
 
== Nächste Zeile beabeiten[n] ==
Soll erst die dem Suchmuster folgende Zeile manipuliert werden, ist das n-Kommando der beste Kandidat:
'''sed -n '8,${n;s/\(.\{1,\}\)/*\1/p;}' test.txt'''
  * 9 Keine Angabe Alle Zeilen
  *11 $ Symbolisiert die letzte Zeile
  *13 RegEx Zeilen, die den Regulären Ausdruck enthalten
 
Die Kommandozeile ist schwer verdaulich...
* aber der Reihe nach:
 
{|class="wikitable"  
|-
|-
! | »-n«
|colspan="2"|
! | als Kommandozeilenoption besagt, dass die Ausgabe einzig die bearbeiteten Zeilen betreffen soll.
sed 's/alt/NEU/' inputfile
|-
|-
| | '''Da jedoch das Flag »s« '''
|'''Input'''
| | sämtliche Ausgaben »verschluckt«, muss »p« am Ende bemüht werden.
|'''Output'''
|-
|-
| | '''»8,$« '''
|
| | adressiert die Zeilen 8 bis zum Ende der Datei.
alt
* Die erste Zeile, die also gefunden wurde, ist die 8.
alt alt
alt alt alt
alt alt alt alt
alt alt alt alt alt
|
NEU
NEU alt
NEU alt alt
NEU alt alt alt
NEU alt alt alt alt
|}
 
Dieses Verhalten kann allerdings durch die Angabe von Kommandoptionen geändert werden: Wird eine Zahl N angegeben, dann wird lediglich das ''N''-te Vorkommen geändert, ein <code>g</code> (für ''global'') ändert alle Vorkommen:
 
{| style="margin-left:2em"
|-
|-
| | '''»n« '''
|colspan="2"|
| | als Substitutionskommando bewirkt, dass die nächste Zeile bearbeitet wird - Zeile 9.
sed &apos;s/alt/NEU/'''g'''&apos; inputfile
* Diese 9.
* Zeile wird nun substituiert.
|-
|-
| | '''».\{1,\}« '''
|'''Input'''
| | meint »mindestens ein (\{1,\}) beliebiges (.) Zeichen.
|'''Output'''
|-
| |
| | Da jede Zeile im Beispiel zumindest die Zeilenummer umfasst und das komplette Muster mit »\(...\)« gespeichert wird, erscheint die gesamte Zeile mit vorangestelltem Stern (*\1) in der Ausgabe...
|-
| |
| | Sed fährt mit der folgenden Zeile (10) fort, die (wegen Flag »n«) übersprungen wird.
|-
|-
|
alt
alt alt
alt alt alt
alt alt alt alt
alt alt alt alt alt
|
NEU
NEU NEU
NEU NEU NEU
NEU NEU NEU NEU
NEU NEU NEU NEU NEU
|}
|}
== Zeichen tauschen [y] ==
* Einzelne Zeichen lassen sich durch andere einzelne Zeichen ersetzen.
* Das Zeichen an Position x der Liste zu ersetzender Zeichen wird in das Zeichen an Position x der Liste der neuen Zeichen transformatiert.
Damit ist klar, dass beide Zeichenlisten dieselbe Länge besitzen müssen:
'''sed 'y/abcdefghijklmnopqrstuvwxyz/zyxwvutsrqponmlkjihgfedcba/' test.txt'''
  1 Dvi Afuifu wvh Sgivzn Ewrglih yvhrgag rnnvi wzh Flinzg:
  2
  3 hvw 'Klnnzmwl' Dzgvrmznv
  4
  5 Dzyvr pzmm wvn Klnnzmwl nrgtvgvrog dviwvm, dvoxsv Zvrovm wvi
  6 Ermtzyvwzgvr vh yvziyvrgvm hloo.
* Aoh Awivhhrvifmt plnnvm ulotvmwv
  7 Mvxszmrhnvm rm Fiztv:
  8
  9 Kvrmv Amtzyv Aoov Zvrovm
  10 Nfnnvi Gvmzf wrvhv Zvrov
  11 Sgzig, Emwv Aoov Zvrovm elm "Sgzig" yrh "Emwv"
  12 $ Sbnylorhrvig wrv ovgagv Zvrov
  13 RvtEc Zvrovm, wrv wvm Rvtfo/auml;ivm Afhwifxp vmgszogvm
  14 1, RvtEc Vlm Zvrov 1 yrh afi vihgvm Zvrov, wrv RvtEc vmgsäog
== Sed vorzeitig beenden [q] ==
Manchmal ist es sinnvoll, den Stream Editor vorzeitig zu beenden:
'''sed '3q' test.txt'''
  1 Der Aufruf des Stream Editors besitzt immer das Format:
  2
  3 sed 'Kommando' Dateiname
'''sed -n '/sed/{p;q;}' test.txt'''
  3 sed 'Kommando' Dateiname


== Zeilentausch [h|g|G|x ] ==
==== Filtern bestimmter Zeilen ====
* Die aktuell bearbeitete Zeile hält der Sed in einem Zwischenspeicher und bearbeitet sie in diesem »Pattern Space«.  
Grundsätzlich gibt <code>sed</code> immer den Inhalt des Pattern Spaces nach der letzten Anweisung aus. Will man dieses Verhalten für einzelne Zeilen unterdrücken, so kann man entweder über eine Regel bestimmte Zeilen löschen (explizite Filterung), aber es ist auch mit der Kommandozeilen-Option <code>-n</code> möglich, dieses Verhalten insgesamt abzustellen (implizite Filterung). Ausgegeben wird dann nur noch, was mit dem ausdrücklichen <code>Print</code>-Kommando (<code>p</code>) angegeben wird. <code>p</code> kann dabei entweder als eigene Anweisung oder als Option für andere Anweisungen dienen. Das Beispiel gibt aus dem bereits oben verwendeten Text nur noch die „Kapitelüberschriften“ aus:
* Hat der Editor seine Arbeit beendet, gibt er die Zeile aus und lädt die folgende Zeile der Eingabedatei in den Zwischenspeicher.


{|class="wikitable"  
{| style="margin-left:2em"
|-
! align=center | h
! | Mit dem Kommando »h« kann der aktuelle Zwischenspeicher in einen Puffer gesichert werden (»holding buffer«).
|-
| align=center | '''G'''
| | Das Kommando »G« fügt den Inhalt dieses Sicherungspuffers '''hinter '''der aktuell bearbeiteten Zeile ein.
|-
|-
| align=center | '''g'''
|colspan="2"|
| | »g« '''ersetzt '''die aktuelle Zeile durch den Inhalt des Sicherungspuffers.
sed -n 's/^=\(.*\)$/Kapitelüberschrift: \1/p' inputfile
|-
|-
| align=center | '''x'''
|'''Input'''
| | Den Inhalt der beiden Puffer '''vertauscht '''das Kommando »x«.
|'''Output'''
|-
|-
|
=Kapitel1
Zeile 1
Zeile 2
Zeile 3
=Kapitel2
Zeile A
Zeile B
Zeile C
|
Kapitelüberschrift: Kapitel1
Kapitelüberschrift: Kapitel2
|}
|}


==== Beispiel 1 ====
==== Debugging ====
'''sed -e '/sed/{h;d;}' -e '4G' -e '4q' test.txt'''
Zur Fehlersuche kann es nützlich sein, sich Zwischenergebnisse ausgeben zu lassen um die Entwicklung im Pattern Space besser nachvollziehen zu können. Dazu kann die bereits oben erwähnte Option <code>p</code> verwendet werden. Zeilen können durchaus mehrmals hintereinander ausgegeben werden. In dem obigen Beispielprogramm etwa:
  1 Der Aufruf des Stream Editors besitzt immer das Format:
  2
  4
  3 sed 'Kommando' Dateiname
'''sed -e '/sed/{h;d;}' -e '4g' -e '5q' test.txt'''
  1 Der Aufruf des Stream Editors besitzt immer das Format:
  2
  3 sed 'Kommando' Dateiname
  5 Dabei kann dem Kommando mitgeteilt werden, welche Zeilen der


===== Erklärung =====
{| style="margin-left:2em"
* Das erste Kommando »-e '/sed/{h;d;}'« in teilt dem Editor mit, die Zeile, die sed enthält, zuerst in den Zwischenspeicher zu sichern und nachfolgend zu löschen.
|-
* Das zweite Kommando vollzieht das Einfügen des Inhalts des Puffers. »-e '4G'« fügt nach der 4.Zeile ein (Achtung: die gelöschte Zeile wird mitgezählt!)»-e '4g'« ersetzt die 4.Zeile.
|colspan="2"|
* Das letzte Kommando »-e '4q'« beendet die Arbeit des Editors nach der 4.
  sed &apos;/^=/ {
* Zeile.
              s/^=//'''p'''
 
              s/^/ (/'''p'''
==== Beispiel 2 ====
              s/$/)/'''p'''
  '''sed -e '/Aufruf/h' -e '/Angabe/x' -e '$G' test.txt'''
              h
  1 Der Aufruf des Stream Editors besitzt immer das Format:
              d
  2
          }
  3 sed 'Kommando' Dateiname
      '''p'''
  4
      G&apos; inputfile
  5 Dabei kann dem Kommando mitgeteilt werden, welche Zeilen der
|}
  6 Eingabedatei es bearbeiten soll.
* Als Adressierung kommen folgende
  7 Mechanismen in Frage:
  8
  1 Der Aufruf des Stream Editors besitzt immer das Format:
  10 Nummer Genau diese Zeile
  11 Start, Ende Alle Zeilen von "Start" bis "Ende"
  12 $ Symbolisiert die letzte Zeile
  13 RegEx Zeilen, die den Regulären Ausdruck enthalten
  14 1, RegEx Von Zeile 1 bis zur ersten Zeile, die RegEx enthält
  9 Keine Angabe Alle Zeilen
 
===== Erklärung =====
* Enthält eine Zeile das Muster »Aufruf«, wird sie im Zwischenpuffer abgelegt.
* Steht in einer Zeile »Angabe«, so wird diese Zeile mit dem Inhalt des Zwischenpuffers vertauscht.
* Der Inhalt des Zwischenpuffers wird hinter der letzten Zeile eingefügt.
 
== Sed-Skripte ==
Kompliziertere und häufig benötigte Sed-Aufrufe schreibt man besser in eine Datei.
* Der Aufruf von Sed sieht dann wie folgt aus:
sed -f <Skript_Datei> <zu_bearbeitende_Datei>
 
Beim Schreiben eines Skripts gelten folgende Regeln: * Beginnt eine Zeile mit einem Doppelkreuz #, so handelt es sich um einen Kommentar
* Vor und nach einem Kommando dürfen keine Leerzeichen, Tabulatoren...
* stehen
* Mehrere Kommandos auf einer Zeile, sind sie durch Semikola voneinander zu trennen
 
Der Stream Editor wird das gesamte Skript auf jede Zeile der Eingabedatei anwenden.
 
Als Beispiel dient ein Skript, dass alle deutschen Umlaute in der Eingabedatei umschreibt.
'''cat umlaut'''
  ## Ersetzen Umlaute
  s/ä/\ae/g
  s/ü/\ue/g
  s/ö/\oe/g
  s/Ä/\ae/g
  s/Ü/\Ue/g
  s/Ö/\Oe/g
  s/ß/\ss/g
 
Das Anwendungsbeispiel demonstriert die Möglichkeit der Kopplung von Kommandozeilenbefehlen und einem Skript:
'''sed -e '1,12d' -f umlaut test.txt'''
  13 RegEx Zeilen, die den Regulären Ausdruck enthalten
  14 1, RegEx Von Zeile 1 bis zur ersten Zeile, die RegEx enthält


[[Kategorie:Sed]]
[[Kategorie:Linux/Befehl]]
[[Kategorie:Linux/Befehl]]
[[Kategorie:Bash/Scripting]]
[[Kategorie:Regular Expression]]
{{DEFAULTSORT:sed}}
{{DEFAULTSORT:sed}}

Aktuelle Version vom 12. November 2024, 18:36 Uhr

sed - Stromeditor zum Filtern und Umwandeln von Text

Beschreibung

sed steht für Stream EDitor und ist ein Unix-Werkzeug, mit dem Text-Datenströme bearbeitet werden können. Der Datenstrom kann auch aus einer Datei gelesen werden. Im Gegensatz zu einem Texteditor wird die Ursprungsdatei aber nicht verändert.

Im Gegensatz zu einem interaktiven Texteditor, wie etwa dem vi, wird sed mittels eines Skripts gesteuert.

Der sed-Befehlssatz orientiert sich an jenem des zeilenorientierten Texteditors ed. Dabei werden für die Text-Durchmusterung laut der POSIX-Spezifikation eine bestimmte Abart der Regular Expressions, sogenannte (POSIX-) Basic Regular Expressions (BRE) verwendet.[1] Die GNU-Implementation verwendet allerdings GNU-BREs, die von POSIX-BREs geringfügig abweichen.

Auch wenn der Sprachumfang von sed ziemlich limitiert und spezialisiert erscheint, so handelt es sich doch um eine Turing-vollständige Sprache. Beweisen kann man die Turing-Vollständigkeit, indem man eine Turingmaschine mittels sed programmiert[2][3] oder indem man mit sed einen Interpreter für eine andere, Turing-vollständige Sprache schreibt.[4]

Folglich konnten und wurden sogar Spiele wie Sokoban oder Arkanoid und andere anspruchsvolle Programme wie Debugger mit sed geschrieben.[5]


Sed ist ein Stromeditor (stream editor)
  • Ein Stromeditor wird für grundlegende Texttransformationen auf einen Eingabestrom (einer Datei oder aus einer Verarbeitungskette) verwandt.
  • Obwohl in einigen Aspekten ähnlich zu einem Editor, der Bearbeitungen nach Skript erlaubt (wie Ed), führt Sed nur einen Durchlauf über die Eingabe(n) durch und ist somit effizienter.
  • Allerdings ist es die Fähigkeit von Sed, Text in einer Verarbeitungskette zu filtern, die ihn besonders gegenüber anderen Arten von Editoren auszeichnet.
  • Da es ein "nicht-interaktives" Programm ist, kann es, falls gewünscht, zur Automatisierung der Bearbeitung verwendet werden.
  • Der Name sed ist eine Abkürzung für stream editor, und das Dienstprogramm leitet viele seiner Befehle vom ed line-editor ab (ed war der erste UNIX-Texteditor).
  • So können Sie mehrere Dateien bearbeiten oder gängige Bearbeitungsvorgänge durchführen, ohne jemals vi oder emacs öffnen zu müssen.
  • sed liest aus einer Datei oder von der Standardeingabe und gibt auf der Standardausgabe aus.
  • sed hat zwei Puffer, die Musterpuffer und Haltepuffer genannt werden.
  • Beide sind anfangs leer.
Funktionsweise
  • Geben Sie den Musterpuffer auf stdout aus.
  • Der Stream-Editor ist kein herkömmlicher Editor wie Vi oder Emacs.
  • Sed arbeitet nicht interaktiv, sondern wird über Kommandozeilenoptionen oder ein Skript gesteuert.
  • Sed verändert nicht das Original, sondern schreibt das Ergebnis auf die Standardausgabe.
  • Sed lädt die aktuell betrachtete Zeile in einen temporären Puffer - im Folgenden als Arbeitspuffer bezeichnet.

Unix Sed Arbeitsmethodik

Ausführungszyklus
  • Der Zyklus wird fortgesetzt, bis das Ende der Datei/Eingabe erreicht ist # Lesen einer ganzen Zeile aus stdin/file
  1. Entfernt alle nachstehenden Zeilenumbrüche
  2. Legt die Zeile in seinen Musterpuffer
  3. Ändert den Musterpuffer entsprechend den übergebenen Befehlen

Reguläre Ausdrücke

POSIX.2-BREs sollten unterstützt werden
  • Dies erfolgt allerdings aus Leistungsgründen nicht vollständig.
  • Die Sequenz \n in einem regulären Ausdruck passt auf das Zeilenumbruchzeichen und ähnliches gilt für \a, \t und andere Sequenzen.
  • Die Option -E schaltet auf die Verwendung von erweiterten regulären Ausdrücken um; sie wurde seit Jahren in GNU Sed unterstützt und ist jetzt in POSIX enthalten.

Installation

# apt install sed

Aufruf

$ sed [-V] [--version] [--help] [-n] [--quiet] [--silent]
[-l N] [--line-length=N] [-u] [--unbuffered]
[-E] [-r] [--regexp-extended]
[-e Skript] [--expression=script]
[-f Skriptdatei] [--file=Skriptdatei]
[script-if-no-other-script]
[Datei …]

Optionen

Unix GNU Beschreibung
-n --quiet, --silent unterdrückt die Ausgabe des Musterbereichs
--debug Kommentiert die Programmausführung
-e Skript --expression=Skript Fügt das Skript zu den auszuführenden Befehlen hinzu
-f Skriptdatei --file=Skriptdatei Fügt den Inhalt der Skriptdatei zu den auszuführenden Befehlen hinzu
--follow-symlinks Symbolischen Links bei der Bearbeitung an Ort und Stelle folgen
-i[ENDUNG] --in-place[=ENDUNG] Dateien an Ort und Stelle bearbeiten (erstellt Sicherung, falls ENDUNG angegeben)
-l N --line-length=N Gibt die gewünschte Zeilenumbruchlänge für den Befehl »l« an
--posix Deaktiviert alle GNU-Erweiterungen
-E, -r --regexp-extended Verwendet erweiterte reguläre Ausdrücke in dem Skript (für Portabilität verwenden Sie POSIX -E)
-s --separate Betrachtet Dateien getrennt statt als einzigen, kontinuierlichen langen Strom
--sandbox Arbeitet im »Sandbox«-Modus (deaktiviert e/r/w-Befehle)
-u --unbuffered Lädt minimale Datenmenge aus den Eingabedateien und schreibt die Ausgabepuffer öfter
-z --null-data Zeilen durch NUL-Zeichen trennen
--help zeigt Hilfeinformationen an und beendet das Programm
--version gibt Versionsinformationen aus und beendet das Programm

Befehle

Sed/Befehle

Rückgabewert

Anwendungen

Arbeitsweise

sed kann sowohl innerhalb einer Pipeline als auch auf Dateien arbeiten. Ausgaben erfolgen grundsätzlich auf <stdout>, Fehlermeldungen auf <stderr>. Der typische Aufruf sieht deshalb so aus: 

sed 'Anweisung1
     Anweisung2
     …
     AnweisungN' Eingabedatei > Ausgabedatei
<stream> | sed 'Anweisung1
                Anweisung2
                …
                AnweisungN' | <stream>

sed liest eine Eingabedatei (oder einen input stream auf <stdin>) zeilenweise ein. Diese Eingangsdaten landen zunächst im sogenannten Pattern Space. Auf diesem Pattern Space wird nacheinander jede Anweisung des vorgegebenen Programmes ausgeführt. Jede dieser Anweisungen kann dabei den Pattern Space verändern, folgende Anweisungen werden dann auf dem jeweiligen Ergebnis der letzten Anweisung ausgeführt. Führt eine dieser Veränderungen zu einem Nulltext, so wird die Verarbeitung an dieser Stelle abgebrochen und die Anweisungsliste mit der nächsten Eingabezeile wieder von vorne begonnen. Ansonsten wird das Ergebnis der letzten Anweisung auf <stdout> ausgegeben und die Anweisungsliste ebenfalls mit der nächsten Eingabezeile wieder begonnen.

Beispiele

  1. Sed/Aufruf
  2. Sed/Dateiübergabe
  3. Sed/Ausgabe
  4. Sed/Kommandos
  5. Sed/Substitutionen
  6. Sed/Regular Expressions
  7. Sed/Beispieltext
  8. Sed/Anweisungen
  9. Sed/Zeilen ausgeben
  10. Sed/Adressierung
  11. Sed/Zeilen löschen
  12. Sed/Suchen und Ersetzen
  13. Sed/Mehrere Kommandos
  14. Sed/Einfügen
  15. Sed/Einfügen aus einer Datei
  16. Sed/Schreiben in eine Datei
  17. Sed/Dateien direkt bearbeiten
  18. Sed/Dateien ergänzen
  19. Sed/Nächste Zeile beabeiten
  20. Sed/Zeichen tauschen
  21. Sed/Sed vorzeitig beenden
  22. Sed/Zeilentausch
  23. Sed/Sed-Skripte

Siehe auch

  1. awk(1)
  2. ed(1)
  3. grep(1)
  4. tr(1)
  5. perlre(1)
  6. sed.info
  7. Sed-FAQ http://sed.sf.net/grabbag/tutorials/sedfaq.txt
  8. http://sed.sf.net/grabbag/


Dokumentation

  1. https://www.gnu.org/software/sed/manual/sed.html

Man-Page

Info-Pages

$ info sed

Links

Projekt

Weblinks

  1. https://de.wikipedia.org/wiki/Sed_(Unix)
  2. sed-Projektseite auf sourceforge (englisch)
  3. seder’s grab bag (englisch)
  4. sed für Windows mit funktionierender -i Option (ZIP; 50 kB)
  5. Ausführliches Tutorium (deutsch)

Wikipedia

Programmierung

sed-Anweisungen können grob in drei Gruppen unterteilt werden: Textmanipulationen, Verzweigungen und sonstige. (Die meisten sed-Handbücher wie auch die POSIX-Spezifikation unterteilen abweichend davon Anweisungen in 2-Adress-, 1-Adress- und adresslose – siehe unten –, aber diese Gruppierung ist für Einführungszwecke nicht geeignet.)

Textmanipulationen

Dies ist die am weitaus häufigsten eingesetzte Funktion und der Befehlssatz ist hier auch besonders reichhaltig. Generell hat eine Anweisung folgende Struktur (2-Adress-Kommando): 

<Adresse1>,<Adresse2> Kommando [Optionen]

Adresse1 und Adresse2 können auch weggelassen werden. Werden beide Adressen angegeben, so wird Kommando für jede Zeile, beginnend mit jener, die mit Adresse1 übereinstimmt, bis zu der, die mit Adresse2 übereinstimmt, ausgeführt. Werden Adresse1 und Adresse2 nicht angegeben, so wird Kommando für jede Zeile ausgeführt, wird lediglich Adresse2 weggelassen, so wird Kommando nur für Zeilen ausgeführt, die mit Adresse1 übereinstimmen. Eine Adresse ist entweder eine Zeilennummer oder ein regulärer Ausdruck. Reguläre Ausdrücke werden dabei in zwei / eingeschlossen. Zwei Beispiele: 

sed '/Beginn/,/Ende/ s/alt/NEU/' inputfile
Input Output 
x alt
Beginn
y alt
Ende
z alt

x alt
Beginn
y NEU
Ende
z alt

„alt“ wird durch „NEU“ ersetzt, aber nur ab der Zeile, die „Beginn“ enthält, bis zu der Zeile, die „Ende“ enthält (2-Adress-Variante). Hingegen wird dieselbe Ersetzung im zweiten Beispiel in allen Zeilen durchgeführt, die mit „y“ oder „z“ beginnen (1-Adress-Variante): 

sed '/^[yz]/ s/alt/NEU/' inputfile
Input Output 
x alt
Beginn
y alt
Ende
z alt

x alt
Beginn
y NEU
Ende
z NEU

Zusammengesetzte Kommandos

Anstatt eines einzelnen Kommandos kann Kommando auch eine Liste von Anweisungen enthalten, die durch { … } umschlossen werden. Für diese Anweisungen gelten wieder die oben beschriebenen Regeln, sie können ihrerseits ebenfalls aus weiteren zusammengesetzten Kommandos bestehen. Ein Beispiel: 

sed '/^[yz]/ {
               s/^\([yz]\)/(\1)/
               s/alt/NEU/
             }' inputfile
Input Output 
x alt
Beginn
y alt
Ende
z alt

x alt
Beginn
(y) NEU
Ende
(z) NEU

Verzweigungen

sed kennt zwei Arten von Verzweigungen: unbedingte Verzweigungen (Sprunganweisungen) und bedingte, die in Abhängigkeit einer zuvor erfolgten oder nicht erfolgten Ersetzungsoperation zur Ausführung kommen. Ein typisches Anwendungsbeispiel ist das folgende: ein Quelltext wurde mit Hilfe von führenden Tabulatorzeichen eingerückt, diese führenden Tabs sollen durch jeweils 8 Blanks ersetzt werden. Andere als am Zeilenbeginn liegende Tabs können im Text vorkommen, sollen aber nicht verändert werden. Das Problem besteht darin, dass multiplikative Verknüpfungen (ersetze N Tabs durch N * 8 Blanks) nicht als RegExp ausgedrückt werden können. Andererseits würde eine globale Ersetzung auch die Tabulatorzeichen innerhalb des Texts betreffen. Deshalb wird mit Sprunganweisungen eine Schleife gebildet (im Folgenden werden Blanks und Tabs zur besseren Verständlichkeit durch <b> und <t> symbolisiert): 

sed ':start
     /^<b>*<t>/ {
                  s/^\(<b>*\)<t>/\1<b><b><b><b><b><b><b><b>/
                  b start
                }' inputfile

In jeder Zeile wird das erste Tabulatorzeichen, sofern davor lediglich null oder mehr Leerzeichen stehen, durch 8 Leerzeichen ersetzt, danach sorgt die Sprunganweisung b <Sprungzielname> dafür, dass die Programmausführung wieder zur ersten Zeile zurückkehrt. Ist das letzte führende Tabulatorzeichen ersetzt, so matcht der Ausdruck /^<b>*<t>/ nicht mehr und der Block wird nicht ausgeführt, sodass das Programmende erreicht und die nächste Zeile eingelesen wird.

Hier wird die Ähnlichkeit mit Assembler-Sprachen deutlich, indem mit einer Bedingung und einem Label eine Kontrollstruktur vergleichbar dem in Hochsprachen üblichen repeat-until aufgebaut wird.

Sonstige Anweisungen

Hold Space Manipulation

Eine mächtige (gleichwohl relativ unbekannte) Funktion von sed ist der sogenannte Hold Space. Das ist ein frei verfügbarer Speicherbereich, der in seiner Arbeitsweise dem in manchen Assembler-Sprachen bekannten Akkumulator ähnelt. Direkte Manipulation der Daten im Hold Space ist zwar nicht möglich, aber Daten im Pattern Space können in den Hold Space verlagert, kopiert, oder auch mit dem Inhalt desselben vertauscht werden. Auch das Anhängen des Pattern Spaces an den Hold Space oder vice versa ist möglich.

Das folgende Beispiel verdeutlicht die Funktion des Hold Space: der Text einer „Kapitelüberschrift“ wird gespeichert und jeder Zeile des jeweiligen „Kapitels“ nachgestellt, die Zeile mit der Kapitelüberschrift selbst aber unterdrückt: 

sed '/^=/ {
             s/^=//
             s/^/ (/
             s/$/)/
             h
             d
          }
     G; s/\n// ' inputfile
Input Output 
=Kapitel1
Zeile 1
Zeile 2
Zeile 3
=Kapitel2
Zeile A
Zeile B
Zeile C

Zeile 1 (Kapitel1)
Zeile 2 (Kapitel1)
Zeile 3 (Kapitel1)
Zeile A (Kapitel2)
Zeile B (Kapitel2)
Zeile C (Kapitel2)

Immer wenn eine Zeile mit „=“ beginnt, so wird der Anweisungsblock ausgeführt, der dieses Zeichen entfernt und dafür die restliche Zeile mit einem führenden Leerzeichen und Klammern versieht. Danach wird dieser Text in den Hold Space kopiert (h) und aus dem Pattern Space gelöscht (d), wodurch das Programm für diese Zeile beendet und die nächste Zeile gelesen wird. Da für „normale Zeilen“ die Bedingung des Eingangsblocks nicht zutrifft, wird lediglich die letzte Anweisung (G) durchgeführt, die den Inhalt des Hold Space an den Pattern Space anhängt.

Mehrzeilen-Anweisungen

Nicht alle Textmanipulationen lassen sich innerhalb einzelner Zeilen ausführen. Manchmal müssen Informationen aus anderen Zeilen in die Entscheidungsfindung miteinbezogen werden, manchmal auch zeilenübergreifende Ersetzungen durchgeführt werden. Dafür sieht die sed-Programmiersprache die Anweisungen N, P und D vor, mit denen mehrere Zeilen des Eingabetexts gleichzeitig in den Pattern Space geladen (N) und Teile davon ausgegeben (P) oder gelöscht (D) werden können. Ein typisches Anwendungsbeispiel ist der folgende Einzeiler (eigentlich zwei Einzeiler), der einen Text mit Zeilennummern versieht: 

sed '=' inputfile | sed 'N; s/\n/<t>/'

Der erste sed-Aufruf druckt für jede Zeile im Eingangstext die Zeilennummer aus und danach die Zeile selbst. Der zweite sed-Aufruf verbindet diese beiden Zeilen zu einer einzigen, indem erst die jeweils nachfolgende Zeile eingelesen (N) und dann das automatisch eingefügte Zeilentrennzeichen („\n“) durch ein Tabulatorzeichen ersetzt wird.

Anwendungen, Optionen, Hinweise

Kapazitätsgrenzen

sed unterliegt keinen (realen) Beschränkungen hinsichtlich der Dateigrößen. Abgesehen vom verfügbaren Plattenplatz, der eine praktische Grenze darstellt, realisieren die meisten Implementationen den Zeilenzähler als int oder long int. Bei den heute üblichen 64-Bit-Prozessoren kann die Gefahr eines Überlaufs deshalb vernachlässigt werden.

Wie die meisten textmanipulierenden Tools in UNIX unterliegt sed allerdings einer Begrenzung hinsichtlich der Zeilenlänge (genauer: der Anzahl Bytes bis zum nachfolgenden newline-Zeichen). Die Mindestgröße ist durch den POSIX-Standard festgelegt, die tatsächliche Größe kann von System zu System variieren und kann im jeweiligen Fall in der Kernel-Headerdatei /usr/include/limits.h als Wert der Konstanten LINE_MAX nachgeschlagen werden. Die Länge wird in Bytes angegeben, nicht in Zeichen (weshalb eine Umrechnung etwa bei der Verarbeitung von UTF-codierten Dateien, die einzelne Zeichen mit mehreren Bytes darstellen, nötig ist).

Greedyness

Vorlage:Siehe auch Beim Geltungsbereich von RegExps wird zwischen greedy und non-greedy unterschieden. sed-RegExps sind immer greedy, das bedeutet, dass die RegExp immer den längstmöglichen Geltungsbereich hat: 

/a.*B/; "'a', gefolgt von null oder mehr beliebigen Zeichen, gefolgt von 'B'"

axyBBBskdjfhaaBBpweruBjdfh ; längstmöglicher Geltungsbereich (greedy)
axyBBBskdjfhaaBBpweruBjdfh ; kürzestmöglicher Geltungsbereich (non-greedy)

Der Grund ist, dass sed auf Geschwindigkeit optimiert ist und non-greedy RegExps aufwendiges Backtracking erfordern würde. Will man ein Non-greedy-Verhalten erzwingen, so erreicht man dies üblicherweise durch negierte Zeichenklassen. Im obigen Beispiel etwa: 

/a[^B]*B/ ; "'a', gefolgt von null oder mehr nicht-'B', gefolgt von 'B'"

Praktische Grenzen in der Shell-Programmierung

Es sollte nicht unerwähnt bleiben, dass die allerhäufigste Anwendung von sed (aber auch von awk, tr und ähnlichen Filterprogrammen) in der Praxis – die Manipulation ad hoc von Ausgaben anderer Kommandos, etwa so: 

ls -l /path/to/myfile | sed 's/^\([^ ][^ ]*\) .*/\1/' # gibt Filetype und Filemode aus

genaugenommen einen Missbrauch darstellt. Da jeder Aufruf eines externen Programmes die aufwendigen Systemaufrufe fork() und exec() erfordert, sind Shell-interne Methoden, etwa die sogenannte Variablenexpansion, selbst wenn sie deutlich länger zu schreiben sind, meist dem Aufruf von externen Programmen überlegen.[6] Die Faustregel dafür lautet: wenn die Ausgabe des Filterprozesses eine Datei bzw. ein Datenstrom ist, so ist das Filterprogramm zu verwenden, ansonsten ist Variablenexpansion vorzuziehen.

In-Place-Editing

Aufgrund der Art wie sed Textmanipulationen durchführt, kann dies nicht direkt auf der Eingabedatei geschehen. Als Ausgabe wird eine von dieser getrennte Datei benötigt, die gegebenenfalls danach über die Eingangsdatei kopiert wird. 

sed '…<Anweisungen>…' /path/to/inputfile > /path/to/output
mv /path/to/output /path/to/input

Dies ist auch so im POSIX-Standard vorgesehen. Die GNU-Version von sed bietet zusätzlich zum POSIX-Standard die Kommandozeilen-Option -i. Diese erlaubt es, eine Datei scheinbar ohne Umweg (in place) zu verändern, tatsächlich wird aber im Hintergrund ebenfalls eine temporäre Datei angelegt. Diese wird im Fehlerfall nicht gelöscht und die Metadaten (Besitzer, Gruppe, Inode-Nummer, …) der Originaldatei auf jeden Fall verändert.

RegExp-Notation

Es hat sich eingebürgert, regular Expressions – wie auch in den obigen Beispielen – durch Schrägstriche zu begrenzen. sed erfordert dies allerdings nicht. Jedes Zeichen, das einem Ersetzungskommando folgt, wird als Begrenzer akzeptiert und dann in der Folge erwartet. Diese beiden Anweisungen sind deshalb gleichwertig: 

s/^\([^ ][^ ]*\) \([^ ][^ ]*\)/\2 \1/ ; vertauscht erstes und zweites Wort einer Zeile
s_^\([^ ][^ ]*\) \([^ ][^ ]*\)_\2 \1_ ; "_" statt "/"

Dies ist praktisch, wenn der Schrägstrich als Teil der RegExp benötigt wird, weil man sich dann das mühsame Escapen (Kenntlichmachen der Verwendung als Literal) ersparen kann. Man weicht dann einfach auf ein anderes, nicht verwendetes Zeichen aus.

Einige typische Verfahren

Löschung von Textteilen

Erfolgt durch Ersetzung durch nichts. Explizite Löschung für Teile einer Zeile ist nur vom Zeilenbeginn bis zum ersten Zeilentrennzeichen (D) vorgesehen. Der Ausdruck 

/Ausdruck/d

löscht hingegen NICHT den Teil Ausdruck, sondern jede Zeile, die Ausdruck enthält! Ausdruck fungiert hier als die Adresse (siehe oben, 1-Adress-Variante des Kommandos d).

Ansprechen von mindestens einem Zeichen

Im Umfang der POSIX-BREs ist – im Unterschied zu den GNU-BREs – der Quantor \+ für ein oder mehrere des vorangegangenen Ausdrucks nicht vorgesehen. Um portable sed-Scripte zu schreiben, die nicht nur mit GNU-sed laufen, sollte der Quantor \{min,\} verwendet werden. 

/xa\+y/ ; GNU-Variante für "'x' gefolgt von einem oder mehr (aber nicht null) 'a', gefolgt von 'y'"
/xa\{1,\}y/ ; dasselbe in POSIX: "'x' gefolgt von mindestens einem 'a', gefolgt von 'y'"

Ersetzung mehrerer bzw. aller Vorkommen innerhalb einer Zeile

Ohne Angabe weiterer Optionen wird immer nur das erste Vorkommen eines Suchtexts der Ersetzungsregel unterworfen: 

sed 's/alt/NEU/' inputfile
Input Output 
alt
alt alt
alt alt alt
alt alt alt alt
alt alt alt alt alt

NEU
NEU alt
NEU alt alt
NEU alt alt alt
NEU alt alt alt alt

Dieses Verhalten kann allerdings durch die Angabe von Kommandoptionen geändert werden: Wird eine Zahl N angegeben, dann wird lediglich das N-te Vorkommen geändert, ein g (für global) ändert alle Vorkommen: 

sed 's/alt/NEU/g' inputfile
Input Output 
alt
alt alt
alt alt alt
alt alt alt alt
alt alt alt alt alt

NEU
NEU NEU
NEU NEU NEU
NEU NEU NEU NEU
NEU NEU NEU NEU NEU

Filtern bestimmter Zeilen

Grundsätzlich gibt sed immer den Inhalt des Pattern Spaces nach der letzten Anweisung aus. Will man dieses Verhalten für einzelne Zeilen unterdrücken, so kann man entweder über eine Regel bestimmte Zeilen löschen (explizite Filterung), aber es ist auch mit der Kommandozeilen-Option -n möglich, dieses Verhalten insgesamt abzustellen (implizite Filterung). Ausgegeben wird dann nur noch, was mit dem ausdrücklichen Print-Kommando (p) angegeben wird. p kann dabei entweder als eigene Anweisung oder als Option für andere Anweisungen dienen. Das Beispiel gibt aus dem bereits oben verwendeten Text nur noch die „Kapitelüberschriften“ aus: 

sed -n 's/^=\(.*\)$/Kapitelüberschrift: \1/p' inputfile
Input Output 
=Kapitel1
Zeile 1
Zeile 2
Zeile 3
=Kapitel2
Zeile A
Zeile B
Zeile C

Kapitelüberschrift: Kapitel1
Kapitelüberschrift: Kapitel2

Debugging

Zur Fehlersuche kann es nützlich sein, sich Zwischenergebnisse ausgeben zu lassen um die Entwicklung im Pattern Space besser nachvollziehen zu können. Dazu kann die bereits oben erwähnte Option p verwendet werden. Zeilen können durchaus mehrmals hintereinander ausgegeben werden. In dem obigen Beispielprogramm etwa: 

sed '/^=/ {
             s/^=//p
             s/^/ (/p
             s/$/)/p
             h
             d
          }
     p
     G' inputfile
  1. ↑
  2. ↑
  3. ↑
  4. ↑ Vorlage:Webarchiv
  5. ↑
  6. ↑
Abgerufen von „https://wiki.foxtom.de/index.php?title=Sed&oldid=115034“