Shell-Programmierung/werkzeugkasten.tex

% $Id$
\chapter{N<EFBFBD>tzliche Shell-Kommandos}\label{nuetzliche_shell-kommandos}
Durch die gezeigten Steuerungsm<73>glichkeiten stehen dem Shell-Pro\-grammie\-rer
M<EFBFBD>glichkeiten offen, fast alle g<>ngigen Algorithmen zu implementieren. Es ist
tats<EFBFBD>chlich in der Shell m<>glich, Sortier- oder Suchfunktionen zu schreiben.
Leider kommt aber an dieser Stelle einer der bedeutendsten Nachteile der Shell
zum tragen: Die Geschwindigkeit.

In einem Shell-Skript wird f<>r jedes externe Kommando\footnote{Externe
Kommandos sind solche, die nicht direkt in der Shell enthalten sind, f<>r die
also eine eigene Datei aufgerufen wird.} ein eigener Proze<7A> gestartet. Das
kostet nat<61>rlich Zeit und Speicher.

Zeitkritische Anwendungen sind also kein Einsatzgebiet f<>r Shell-Skripte. Die
schreibt man besser in Perl, oder noch besser in einer `compilierten' Sprache
wie C oder C++.

Es stehen jedoch an der Shell viele sehr n<>tzliche externe Kommandos zur
Verf<EFBFBD>gung, die einem die Entwicklung entsprechender eigener Routinen ersparen.
Diese externen Kommandos sind zudem in anderen Sprachen geschrieben worden, so
da<EFBFBD> sie schneller ablaufen als jedes Shell-Skript. Man kommt als
Shell-Programmierer nicht sinnvoll um den Einsatz dieser Programme herum.

In diesem Abschnitt sollen einige dieser Programme mit typischen
Einsatzm<EFBFBD>glichkeiten vorgestellt werden. Eine vollst<73>ndige Beschreibung w<>re
(wenn <20>berhaupt m<>glich) viel zu lang, um an dieser Stelle untergebracht zu
werden. F<>r ausf<73>hrlichere Beschreibungen empfiehlt sich das Studium der
Man-Pages oder der Kauf eines entsprechenden Buches. Am besten macht man
nat<EFBFBD>rlich beides. ;-)

Eine globale Beschreibung aller g<>ngigen Kommandos w<>rde den Rahmen dieses
Textes sprengen. Au<41>erdem w<>re es nicht leicht, das zu einer Aufgabe passende
Werkzeug zu finden. Die Werkzeuge nach Aufgaben zu sortieren f<>llt allerdings
auch nicht leicht. Die Entwickler der Kommandos versuchen, ihre Tools m<>glichst
universell einsetzbar zu halten, also gibt es keine 1:1-Beziehung zwischen
Problem und L<>sung.

Um sowohl das Finden eines Werkzeugs zu einem gegebenen Problem als auch das
Finden einer Beschreibung zu einem gegebenen Werkzeug zu vereinfachen, und um
die oben beschriebene n:m-Beziehung abzubilden, werden hier also zun<75>chst
typische Aufgaben beschrieben. Diese enthalten `Links' zu den in Frage
kommenden Werkzeugen. Danach gibt es eine alphabetische Aufz<66>hlung der
wichtigsten Kommandos.

\section{N<EFBFBD>gel...}\label{naegel}

\subsection{Ein- und Ausgabe}\label{ein_und_ausgabe}

Praktisch jedes Skript verwendet in irgendeiner Form die Ein- oder Ausgabe. Sei
es in interaktiver Art auf dem Terminal, oder im Hintergrund auf Dateien.

An dieser Stelle sei darauf hingewiesen, da<64> es auf unixoiden Systemen nicht
nur Dateien im Sinne von `ein paar Kilobytes Daten, die irgendwo auf der
Festplatte rumliegen' gibt. Vielmehr findet man hier die Ger<65>te des Rechners
als Dateien unter /dev. Der Kernel selbst stellt Schnittstellen in Form von
virtuellen Dateien unter /proc (ab Kernel 2.6 auch unter /sys) zur Verf<72>gung.
Und Schlu<6C>endlich k<>nnen Prozesse sich sogenannte Named Pipes\index{Named Pipe}
anlegen, in die sie schreiben oder aus denen sie lesen.

Diese Kommandos sind also universell n<>tzlich, nicht nur im Zusammenhang mit
Dateien auf der Festplatte.

\begin{itemize}
\item \texttt{cat} (\ref{cat}): Dateien einlesen und ausgeben
\item \texttt{echo} (\ref{echo}): Daten ausgeben
\item \texttt{grep} (\ref{grep}): In Dateien suchen
\item \texttt{head} (\ref{head}): Dateianfang ausgeben
\item \texttt{printf} (\ref{printf}): formatierte Datenausgabe
\item \texttt{read} (\ref{read}): Zeilen einlesen
\item \texttt{sort} (\ref{sort}): Zeilenweises Sortieren
\item \texttt{tail} (\ref{tail}): Dateiende ausgeben
\end{itemize}


\subsection{Pfade und Dateien}\label{pfade_und_dateien}

Eine der Hauptaufgaben von Shell-Skripten ist nat<61>rlich das Hantieren mit
Dateien. In diesem Abschnitt geht es allerdings nicht um den Umgang mit
Dateiinhalten, sondern vielmehr werden einige n<>tzliche Tools im Umgang mit
Dateien an sich vorgestellt.

Auch hier gilt nat<61>rlich der Hinweis aus Abschnitt \ref{ein_und_ausgabe}: Eine
Datei kann viel mehr sein als nur ein paar Daten im Filesystem.

\begin{itemize}
\item \texttt{basename} (\ref{basename}): Den Namen einer Datei (ohne Pfad) ausgeben
\item \texttt{cp} (\ref{cp}): Dateien kopieren
\item \texttt{dirname} (\ref{dirname}): Den Pfad zu einer Datei (ohne den Namen) ausgeben
\item \texttt{find} (\ref{find}): Dateien suchen
\item \texttt{mv} (\ref{mv}): Dateien verschieben
\item \texttt{rm} (\ref{rm}): Dateien l<>schen
\item \texttt{touch} (\ref{touch}): Eine leere Datei anlegen, bzw. das Zugriffsdatum einer Datei <20>ndern
\item \texttt{xargs} (\ref{xargs}): Ausgaben eines Kommandos als Parameter eines anderen Kommandos benutzen
\end{itemize}


\subsection{Pipes manipulieren}\label{pipes_manipulieren}\index{Pipe|(textbf}

Das Konzept der Pipes (R<>hren) wird bereits in dem Kapitel <20>ber Befehlsformen
(\ref{befehlsformen}) vorgestellt. Im wesentlichen besteht es darin, da<64> Daten
von einem Programm an ein anderes weitergeleitet werden. Auf diese Weise
entsteht eine sogenannte \textit{Pipeline}\index{Pipeline} aus mehreren
Kommandos. Einige Kommandos sind f<>r den Einsatz in einem solchen Konstrukt
pr<EFBFBD>destiniert, obwohl die meisten auch alleine eingesetzt werden k<>nnen.

<EFBFBD>brigens gibt es einen goldenen Merksatz f<>r die Auswahl einiger dieser Tools:

Benutze nicht \texttt{awk}, wenn Du \texttt{sed} benutzen kannst. Benutze
nicht \texttt{sed}, wenn Du \texttt{grep} benutzen kannst. Benutze nicht
\texttt{grep}, wenn Du \texttt{cut} benutzen kannst.

Der Grund daf<61>r liegt darin, da<64> diese Programme bei jedem Einsatz gestartet
und ausgef<65>hrt werden m<>ssen. Und man sollte sich um der Performance willen den
kleinsten geeigneten Hammer nehmen.

\begin{itemize}
\item \texttt{cut} (\ref{cut}): Teile einer Zeile ausschneiden
\item \texttt{grep} (\ref{grep}): In einer Pipe suchen
\item \texttt{sed} (\ref{sed}): In einer Pipe editieren
\item \texttt{awk} (\ref{awk}): In einer Pipe editieren
\item \texttt{sort} (\ref{sort}): Zeilenweises Sortieren
\item \texttt{tee} (\ref{tee}): Datenstrom in einer Datei protokollieren
\item \texttt{wc} (\ref{wc}): Zeilen, W<>rter oder Zeichen z<>hlen
\end{itemize}

\index{Pipe|)}


\subsection{Proze<EFBFBD>management}\label{prozessmanagement}

Oft werden Shell-Skripte benutzt um Prozesse zu steuern oder zu <20>berwachen. So
werden Systemdienste <20>blicherweise <20>ber die Init-Skripte hoch- oder
heruntergefahren. Es ist auch nicht sonderlich schwer, mit einem Skript einen
`Wachhund' zu implementieren, der regelm<6C><6D>ig kontrolliert ob ein Proze<7A> noch
l<EFBFBD>uft und ihn bei bedarf nachstartet.

F<EFBFBD>r Aufgaben in diesem Bereich stehen unter anderem die folgenden Kommandos zur
Verf<EFBFBD>gung.

\begin{itemize}
\item \texttt{kill} (\ref{kill}): Signal an einen Proze<7A> schicken
\item \texttt{killall} (\ref{killall}): Signal an mehrere Prozesse schicken
\item \texttt{ps} (\ref{ps}): Proze<7A>liste ausgeben
\item \texttt{pgrep} (\ref{pgrep}): Bestimmte Prozesse suchen
\item \texttt{pkill} (\ref{pkill}): Bestimmte Prozesse t<>ten
\end{itemize}


\section{... und H<>mmer}\label{haemmer}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{awk}\label{awk}\index{awk=\texttt{awk}|(textbf}

TODO!!! awk

\index{awk=\texttt{awk}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{basename}\label{basename}\index{basename=\texttt{basename}|(textbf}

Dem Tool \texttt{basename} wird als Parameter ein Pfad zu einer Datei
<EFBFBD>bergeben. Der in der Angabe enthaltene Pfad wird abgeschnitten, nur der Name
der eigentlichen Datei wird zur<75>ckgegeben. Siehe auch \texttt{dirname}
(\ref{dirname}).

\index{basename=\texttt{basename}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{bc}\label{bc}\index{bc=\texttt{bc}|(textbf}

Mit dem Kommando \texttt{bc} verf<72>gt die Shell praktisch <20>ber einen
Taschenrechner. Die Man-Page verr<72>t, da<64> es sich hierbei um ein erstaunlich
komplexes Programm handelt, in der Praxis findet man allerdings meistens
einfache Anwendungen wie das inkrementieren einer Laufvariable (\texttt{i=`bc
\$i + 1`}).

Bei Multiplikationen ist darauf zu achten, da<64> der Stern in der Shell eine
Sonderbedeutung hat, er mu<6D> also gequoted werden: \texttt{i=`bc \$i
\textbackslash{}* 3`}.

Eine andere M<>glichkeit f<>r einfache Rechnungen besteht in der sogenannten
Arithmetik-Expansion (Siehe \ref{arithmetikexpansion}).

\index{bc=\texttt{bc}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{cat}\label{cat}\index{cat=\texttt{cat}|(textbf}

Auch \texttt{cat} ist ein oft unterbewertetes Tool. Seine Aufgabe besteht zwar
lediglich darin, etwas von der Standardeingabe oder aus einer Datei zu lesen,
und das dann auf der Standardausgabe wieder auszugeben. Allerdings leistet es
an vielen, teilweise sehr unterschiedlich gelagerten Aufgaben wertvolle
Dienste.

Durch Umlenklung der Ausgabe k<>nnen Dateien erzeugt und erweitert werden. So
k<EFBFBD>nnen mehrere Dateien per \texttt{cat datei1.txt datei2.txt > datei.txt}
verkettet werden.

Au<EFBFBD>erdem kann man mit einem Aufruf in der Art \texttt{cat datei.txt | kommando}
Daten an ein Programm <20>bergeben, das nur von der Standardeingabe lesen kann
(Filter).

\texttt{cat} verf<72>gt <20>ber eine Reihe von Parametern, um die Ausgabe zu
formatieren, so k<>nnen mit \texttt{-n} bzw. \texttt{-b} die Zeilen numeriert
werden, oder mit \texttt{-s} mehrere Zeilen zu einer einzigen zusammengefa<66>t
werden.

\index{cat=\texttt{cat}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{chpasswd}\label{script}\index{chpasswd=\texttt{chpasswd}|(textbf}

Mit diesem Kommando bietet sich dem Administrator des Systems die
M<EFBFBD>g\-lich\-keit, scriptgesteuert die Pa<50>w<EFBFBD>rter f<>r neue Benutzer zu vergeben.
Manuell <20>ndert man ein Pa<50>wort mit dem Kommando
\texttt{passwd}\index{passwd=\texttt{passwd}}, allerdings l<>scht (flusht)
dieses Programm die Standard-Eingabe, bevor es das neue Pa<50>wort erwartet. Somit
lassen sich Pa<50>w<EFBFBD>rter mit \texttt{passwd} nur interaktiv <20>ndern\footnote{Es
gibt auch einen anderen Weg: Man kann \texttt{passwd} auch mittels
\texttt{expect} fernsteuern. Allerdings ist diese Methode weniger elegant.}.

Das Kommando wird in der Form

\texttt{echo }\textit{name}\texttt{:}\textit{pass}\texttt{ | chpasswd}

aufgerufen. Es ist auch m<>glich, dem Programm eine Datei mit vielen Name /
Pa<EFBFBD>wort-Kombinationen an die Standard-Eingabe zu <20>bergeben:

\texttt{cat }\textit{passwoerter.txt}\texttt{ | chpasswd}

Allerdings sollte dabei aus Sicherheitsgr<67>nden darauf geachtet werden, da<64>
diese Datei nicht allgemein lesbar ist.

\index{chpasswd=\texttt{chpasswd}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{cp}\label{cp}\index{cp=\texttt{cp}|(textbf}

Mit \texttt{cp} werden Dateien kopiert. Die wichtigsten Optionen im
Zusammenhang mit Skripten sind \texttt{-f} und \texttt{-R}. Ersteres erzwingt
(force) das Kopieren, falls an der Zielstelle schon Dateien existieren werden
sie <20>berschrieben. Letzteres erm<72>glicht ein rekursives Kopieren.
Verzeichnisse~---~auch leere~---~k<>nnen nur mit \texttt{-R} kopiert werden.

\index{cp=\texttt{cp}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{cut}\label{cut}\index{cut=\texttt{cut}|(textbf}

Wie der Name (fast) schon sagt, kann man mit diesem Kommando Zeilen
zerschneiden. Mit den Parametern \texttt{-c} (Character) oder \texttt{-f}
(Field) wird bestimmt, in welcher Einheit die Schnittstellen abgesteckt werden
sollen. Falls die Zeilen in Felder zerteilt werden sollen, kann zus<75>tzlich
mittels \texttt{-d} der Delimiter, also das Trennzeichen bestimmt werden. Wird
das nicht explizit getan, wird der Tabulator benutzt.

Dieser Definition folgt die Angabe des zu behaltenden Bereichs. Daf<61>r kann eins
der Formate N, N-, N-M oder -M benutzt werden.

\LTXtable{\textwidth}{tab_kommandos_cut_beispiele.tex}

\index{cut=\texttt{cut}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{dirname}\label{dirname}\index{dirname=\texttt{dirname}|(textbf}

Analog zu \texttt{basename} (\ref{basename}) gibt \texttt{dirname} nur die
Pfad-Komponente einer angegebenen Datei zur<75>ck.

\index{dirname=\texttt{dirname}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{echo}\label{echo}\index{echo=\texttt{echo}|(textbf}

Dies ist wohl der grundlegendste Befehl, der in einem Skript verwendet werden
kann. Er ist die Voraussetzung, um eines der wichtigsten Werkzeuge der
Kybernetik auch mittels eines Shell-Skriptes effizient umzusetzen: Hello World.
:-)

Die eigentliche Aufgabe dieses Befehls d<>rfte jedem bekannt sein, der sich bis
zu dieser Stelle durchgearbeitet hat. Allerdings wissen viele nicht, da<64> auch
der echo-Befehl <20>ber Parameter verf<72>gt. Zumindest zwei davon erweisen sich in
der Praxis oft als sehr hilfreich:

\LTXtable{\textwidth}{tab_kommandos_echo_parameter.tex}

\index{echo=\texttt{echo}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{expr}\label{expr}\index{expr=\texttt{expr}|(textbf}

TODO!!! expr

\index{expr=\texttt{expr}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{find}\label{find}\index{find=\texttt{find}|(textbf}

TODO!!! find

Siehe auch: Abschnitt \ref{beispiele_suchen_dateien}.

\index{find=\texttt{find}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{grep}\label{grep}\index{grep=\texttt{grep}|(textbf}

Das Tool \texttt{grep} stammt aus dem Standard-Repertoire eines jeden
Sys\-tem\-ad\-mi\-ni\-stra\-tors. Mit seiner Hilfe kann in einer oder mehreren Dateien,
oder eben auch in einem Datenstrom nach dem Auftreten bestimmter regul<75>rer
Ausdr<EFBFBD>cke (siehe \ref{mustererkennung}) gesucht werden.

Die folgende Tabelle stellt einige der vielen Parameter vor:

\LTXtable{\textwidth}{tab_kommandos_grep_parameter.tex}

Siehe auch: Abschnitt \ref{beispiele_suchen}.

\index{grep=\texttt{grep}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{head}\label{head}\index{head=\texttt{head}|(textbf}

\texttt{head} ist das Gegenst<73>ck zu \texttt{tail} (Siehe \ref{tail}). Hier
werden allerdings nicht die letzten Zeilen angezeigt, sondern die ersten.

\index{head=\texttt{head}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{kill}\label{kill}\index{kill=\texttt{kill}|(textbf}

TODO!!! kill

<EFBFBD>brigens: Die landl<64>ufige Annahme ist, da<64> man mit dem
\texttt{kill}-Kom\-man\-do Prozesse `umbringt'. Das ist zwar wahr, aber nicht
die ganze Wahrheit.

\index{kill=\texttt{kill}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{killall}\label{killall}\index{killall=\texttt{killall}|(textbf}

TODO!!! killall

\index{killall=\texttt{killall}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{mv}\label{mv}\index{mv=\texttt{mv}|(textbf}

TODO!!! mv

\index{mv=\texttt{mv}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{pgrep}\label{pgrep}\index{pgrep=\texttt{pgrep}|(textbf}

TODO!!! pgrep

Siehe auch: Abschnitt \ref{beispiele_suchen_prozesse}.

\index{pgrep=\texttt{pgrep}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{pkill}\label{pkill}\index{pkill=\texttt{pkill}|(textbf}

TODO!!! pkill

\index{pkill=\texttt{pkill}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{printf}\label{printf}\index{printf=\texttt{printf}|(textbf}

TODO!!! printf

\index{printf=\texttt{printf}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{ps}\label{ps}\index{ps=\texttt{ps}|(textbf}

TODO!!! ps

Siehe auch: Abschnitt \ref{beispiele_suchen_prozesse}.

\index{ps=\texttt{ps}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{read}\label{read}\index{read=\texttt{read}|(textbf}

Mit dem Kommando \texttt{read} kann man Eingaben von der
Standard-Eingabe\index{Standard-Eingabe} lesen. Dabei wird <20>blicherweise einer
oder mehrere Variablennamen <20>bergeben. Dem ersten Namen wird das erste
eingegebene Wort zugewiesen, dem zweiten das zweite Wort usw.  Dem letzen
Variablennamen wird der verbleibende Rest der Eingabezeile zugewiesen. Wenn
also nur ein Variablenname angegeben wird, erh<72>lt dieser die komplette
Eingabezeile. Wenn weniger Worte gelesen werden als Variablen angegeben sind,
enthalten die verbleibenden Variablen leere Werte. Als Wort-Trennzeichen dienen
alle Zeichen, die in der vordefinierten Variable \texttt{\$IFS} enthalten sind
(siehe Seite \pageref{IFS}).

Wenn keine Variablennamen angegeben werden, wird die Eingabe in der Variable
\texttt{REPLY} abgelegt.

Normalerweise wird eine Eingabezeile mit einem Newline abgeschlossen. Mit dem
Parameter \texttt{-d} ist es m<>glich, ein anderes Zeilenendezeichen anzugeben.
Beispielsweise liest \texttt{read -d \dq~\dq~var} alle Zeichen bis zum ersten
Leerzeichen in die Variable \texttt{var} ein.

Wenn nur eine bestimmte Zahl von Zeichen gelesen werden soll, kann diese durch
den Parameter \texttt{-n} angegeben werden. Der Befehl \texttt{read -n 5 var}
liest die ersten f<>nf Zeichen in die Variable \texttt{var} ein. Demzufolge kann
ein Skript durch ein \texttt{read -n 1} dazu gebracht werden, auf einen
einzelnen Tastendruck~---~nicht zwingend ein Return~---~zu warten.

Mit dem Parameter \texttt{-p} kann man einen Prompt, also eine
Eingabeaufforderung ausgeben lassen. \texttt{read -p \dq{}Gib was ein:\dq~var}
schreibt also erst den Text \textit{Gib was ein:} auf das Terminal, bevor die
Eingaben in die Variable \texttt{var} <20>bernommen werden. Dieser Prompt wird nur
an einem interaktiven Terminal ausgegeben, also nicht in einem Skript das seine
Eingaben aus einer Datei oder aus einem Stream erh<72>lt.

Sonderzeichen k<>nnen w<>hrend der Eingabe normalerweise mittels eines Backslash
vor der Interpretation gesch<63>tzt werden. Ein Backslash vor einem Newline
bewirkt also eine mehrzeilige Eingabe. Dieses Verhalten kann mit dem Parameter
\texttt{-r} abgeschaltet werden.

Wenn die Eingabe von einem Terminal kommt und nicht auf dem Bildschirm
erscheinen soll, zum Beispiel bei Pa<50>wortabfragen, kann die Ausgabe mit dem
Parameter \texttt{-s} (Silent) unterdr<64>ckt werden.

Mit \texttt{-t} kann ein Time-Out definiert werden, nach dessen Ablauf das
Kommando mit einem Fehler abbricht. Dieser Parameter ist nur bei interaktiver
Eingabe oder beim Lesen aus einer Pipe aktiv.

Der R<>ckgabewert des \texttt{read}-Kommandos ist 0, es sei denn es trat ein
Timeout oder ein EOF auf.

\index{read=\texttt{read}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{rm}\label{rm}\index{rm=\texttt{rm}|(textbf}

TODO!!! rm

\index{rm=\texttt{rm}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{script}\label{script}\index{script=\texttt{script}|(textbf}

Dieses Kommando eignet sich vorz<72>glich f<>r das Debuggen fertiger Skripte. Man
ruft es in Verbindung mit einem Dateinamen auf. Dieser Aufruf startet eine neue
Shell, in der man beliebige Kommandos ausf<73>hren kann. Wenn man fertig ist,
beendet man den script-Befehl durch die Eingabe von \texttt{exit},
\texttt{logout} oder Druck der Tastenkombination \Ovalbox{CTRL}+\Ovalbox{d}
(EOF).

Script schreibt alle Ein- und Ausgaben die an dem Terminal vorgenommen werden
in die angegebene Datei. So kann man auch interaktive Skripte relativ leicht
debuggen, da sowohl Ein- als auch Ausgaben in dem Logfile sichtbar sind.
\index{script=\texttt{script}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{sed}\label{sed}\index{sed=\texttt{sed}|(textbf}

TODO!!! sed

\index{sed=\texttt{sed}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{seq}\label{seq}\index{seq=\texttt{seq}|(textbf}

TODO!!! seq

\index{seq=\texttt{seq}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{sleep}\label{sleep}\index{sleep=\texttt{sleep}|(textbf}

TODO!!! sleep

\index{sleep=\texttt{sleep}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{sort}\label{sort}\index{sort=\texttt{sort}|(textbf}

TODO!!! sort

\index{sort=\texttt{sort}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{tail}\label{tail}\index{tail=\texttt{tail}|(textbf}

Der Befehl \texttt{tail} gibt die letzten zehn Zeilen einer Datei aus. Wenn
kein Dateiname (oder ein \texttt{-}) angegeben wird, liest \texttt{tail} von
der Standard-Eingabe. Man kann die Anzahl der ausgegebenen Zeilen mit dem
Parameter \texttt{-n} steuern.

Mit dem Parameter \texttt{-f} (follow) gibt \texttt{tail} neue Zeilen aus,
sobald sie an die Datei angeh<65>ngt werden.

\index{tail=\texttt{tail}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{tee}\label{tee}\index{tee=\texttt{tee}|(textbf}

TODO!!! tee

\index{tee=\texttt{tee}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{touch}\label{touch}\index{touch=\texttt{touch}|(textbf}

Mit diesem Kommando kann man einerseits Dateien anlegen wenn sie nicht
existieren, und andererseits die <20>nderungs- und Zugriffszeiten einer Datei
<EFBFBD>ndern. Ohne die Angabe weiterer Parameter wird die Datei erzeugt wenn sie
nicht existierte, bzw. in ihrer <20>nderungs- und Zugriffszeit auf die aktuelle
Zeit gesetzt.

Mit dem Parameter \texttt{-a} wird nur die Zugriffs-, mit \texttt{-m} nur die
<EFBFBD>nderungszeit gesetzt. Mit \texttt{-c} kann die Erstellung einer neuen Datei
unterdr<EFBFBD>ckt werden.

Die eingesetzte Zeit kann auch durch die Parameter \texttt{-t} bzw. \texttt{-d}
angegeben werden. Mit \texttt{-r} kann die Zeit der einer angegebenen
Referenzdatei angepa<70>t werden.

\index{touch=\texttt{touch}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{wc}\label{wc}\index{wc=\texttt{wc}|(textbf}

TODO!!! wc

\index{wc=\texttt{wc}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{who}\label{who}\index{who=\texttt{who}|(textbf}

TODO!!! who

\index{who=\texttt{who}|)}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{xargs}\label{xargs}\index{xargs=\texttt{xargs}|(textbf}

TODO!!! xargs

\index{xargs=\texttt{xargs}|)}