rschaten/Shell-Programmierung
1
0
Fork 0
Code Issues 7 Pull Requests Actions Packages Projects Releases Wiki Activity

Viele ueberarbeitungen

Browse Source
This commit is contained in:
rschaten
2004-11-12 12:07:32 +00:00
parent 7eea8ed0e9
commit 14dec49967
13 changed files with 568 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
quellen.tex
View File

@ -1,5 +1,5 @@
% $Id$
\chapter{Quellen}
\chapter{Quellen}\label{quellen}
\begin{itemize}
\item Bash Reference Manual (\texttt{http://www.gnu.org/manual/bash-2.02/\\bashref.html})
@ -11,6 +11,8 @@
TODO!!! Andere URL angeben (http://www.tldp.org...)
\item Bash Guide for Beginners (\texttt{http://tldp.org/LDP/Bash-Beginners-Guide/})
\item Advanced Bash-Scripting Guide (\texttt{http://tldp.org/LDP/abs/})
\item ... und eine Menge Skripte, die ich im Laufe der Zeit gelesen habe (das
kann ich nur jedem empfehlen - es ist spannender als es sich anh<6E>rt...).
\end{itemize}

2
schmutzige_tricks.tex
View File

@ -26,6 +26,8 @@ haben.
TODO!!! tar-Br<42>cke
%ssh 192.168.2.1 tar clf - / | (cd /mnt; tar xf - )
\section{Binaries inside}

5
shell.tex
View File

@ -119,8 +119,8 @@ irgendeiner Form Kommerz zu machen. Ich stelle es frei zur Verf
Hoffnung, da<64> andere Leute daraus vielleicht einen Nutzen ziehen k<>nnen.
\textbf{Aber ich <20>bernehme keine Garantie f<>r die Korrektheit der hier
dargestellten Dinge.} Mit der Formulierung \textsl{`daraus vielleicht einen
Nutzen ziehen k<>nnen'} meine ich nicht, da<64> dieses Dokument~---~oder Teile
daraus~---~verkauft werden darf. \textbf{Dieses Dokument darf nur kostenlos
Nutzen ziehen k<>nnen'} meine ich nicht, da<64> dieses Dokument~--~oder Teile
daraus~--~verkauft werden darf. \textbf{Dieses Dokument darf nur kostenlos
weitergegeben werden.}\bigskip
Ich danke folgenden Personen, die mir bei der Durchsicht behilflich waren und
@ -157,6 +157,7 @@ R
\include{beispiele}
\include{schmutzige_tricks}
\include{quellen}
\include{todo}
\printindex % Index einf<6E>gen

2
tab_beisp_metazeichen.tex
View File

@ -10,5 +10,5 @@
\texttt{\$ ls neu*} & Listet alle Dateien, die mit `neu' anfangen \tabularnewline\STRUT
\texttt{\$ ls neu?} & Listet `neuX', `neu4', aber nicht `neu10' \tabularnewline\STRUT
\texttt{\$ ls [D-R]*} & Listet alle Dateien, die mit einem Gro<72>buchstaben\index{Gro<EFBFBD>buchstaben}\footnote{Nat<EFBFBD>rlich wird in Shell-Skripten --- wie <20>berall in der Unix-Welt --- zwischen Gro<72>- und Kleinschreibung unterschieden.} zwischen D und R anfangen
\texttt{\$ ls [D-R]*} & Listet alle Dateien, die mit einem Gro<72>buchstaben\index{Gro<EFBFBD>buchstaben}\footnote{Nat<EFBFBD>rlich wird in Shell-Skripten~--~wie (fast) <20>berall in der Unix-Welt~--~zwischen Gro<72>- und Kleinschreibung unterschieden.} zwischen D und R anfangen
\end{longtable}

16
tab_kommandos_chmod_beispiele.tex Normal file
View File

@ -0,0 +1,16 @@
% $Id$
\begin{longtable}{|l|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
a-x & & Allen Benutzern werden die Ausf<73>hrungsrechte genommen \tabularnewline\STRUT
ug+rw & & Dem Besitzer und der Gruppe werden Lese- und Schreibrechte gegeben \tabularnewline\STRUT
u=rw,go-rwx & 600 & Nur der Besitzer kann die Datei lesen \tabularnewline\STRUT
u=rw,go=r & 644 & Der Besitzer darf lesen und schreiben, alle anderen nur lesen \tabularnewline\STRUT
u=rwx,go=rx & 755 & Der Besitzer darf lesen, schreiben und ausf<73>hren, alle anderen nur lesen und ausf<73>hren
\end{longtable}

16
tab_kommandos_cut_beispiele.tex Normal file
View File

@ -0,0 +1,16 @@
% $Id$
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\textsl{s=\dq{}Dies ist ein Test\dq{}} & ~ \tabularnewline\STRUT
\texttt{echo \dq{}\$s\dq{} | cut -c 2-6} & gibt `ies i' aus \tabularnewline\STRUT
\texttt{echo \dq{}\$s\dq{} | cut -d \dq{}~\dq{} -f 2} & gibt `ist' aus \tabularnewline\STRUT
\texttt{echo \dq{}\$s\dq{} | cut -d \dq{}~\dq{} -f 2-3} & gibt `ist ein' aus \tabularnewline\STRUT
\texttt{echo \dq{}\$s\dq{} | cut -d \dq{}~\dq{} -f 2-} & gibt `ist ein Test' aus
\end{longtable}

29
tab_kommandos_expr_parameter.tex Normal file
View File

@ -0,0 +1,29 @@
% $Id$
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{|} & logisches `oder' \tabularnewline\STRUT
\texttt{\&} & logisches `und' \tabularnewline\STRUT
\texttt{<} & kleiner als \tabularnewline\STRUT
\texttt{<=} & kleiner als oder gleich \tabularnewline\STRUT
\texttt{=} & gleich \tabularnewline\STRUT
\texttt{!=} & ungleich \tabularnewline\STRUT
\texttt{>=} & gr<67><72>er als oder gleich \tabularnewline\STRUT
\texttt{>} & gr<67><72>er als \tabularnewline\STRUT
\texttt{+} & Addition \tabularnewline\STRUT
\texttt{-} & Subtraktion \tabularnewline\STRUT
\texttt{*} & Multiplikation \tabularnewline\STRUT
\texttt{/} & Division \tabularnewline\STRUT
\texttt{\%} & Modulo (`Divisionsrest') \tabularnewline\STRUT
\texttt{:} & Pattern-Match mit regul<75>ren Ausdr<64>cken \tabularnewline\STRUT
\texttt{match} & Analog zu `:' \tabularnewline\STRUT
\texttt{substr} & Teil einer Zeichenkette zur<75>ckgeben \tabularnewline\STRUT
\texttt{index} & Position einer Zeichenkette in einer anderen finden \tabularnewline\STRUT
\texttt{length} & L<>nge einer Zeichenkette
\end{longtable}

15
tab_kommandos_pgrep_parameter.tex Normal file
View File

@ -0,0 +1,15 @@
% $Id$
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{-f} & Normalerweise wird nur nach Proze<7A>-Namen gesucht, mit diesem Parameter wird das volle Kommando (incl. Pfad und Parametern) betrachtet\tabularnewline\STRUT
\texttt{-l} & Nicht nur die Proze<7A>-ID, sondern das volle Kommando wird ausgegeben\tabularnewline\STRUT
\texttt{-v} & Findet alle Zeilen, in denen das Suchmuster \emph{nicht} vorkommt\tabularnewline\STRUT
\texttt{-x} & Sucht nach Kommandos, deren Name dem Muster \emph{exakt} entspricht
\end{longtable}

16
tab_kommandos_sort_beispiele.tex Normal file
View File

@ -0,0 +1,16 @@
% $Id$
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{-k 3} & Sortiert nach dem dritten Feld \tabularnewline\STRUT
\texttt{-k 3.5} & Sortiert nach dem f<>nften Zeichen des dritten Feldes \tabularnewline\STRUT
\texttt{-k 3.5r} & Sortiert r<>ckw<6B>rts nach dem f<>nften Zeichen des dritten Feldes \tabularnewline\STRUT
\texttt{-k 3,5} & Beachtet bei der Sortierung nur das dritte bis f<>nfte Feld \tabularnewline\STRUT
\texttt{-k 3.5,3.8} & Beachtet die Zeichen f<>nf bis acht des dritten Feldes
\end{longtable}

20
tab_kommandos_sort_parameter.tex Normal file
View File

@ -0,0 +1,20 @@
% $Id$
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{-b} & Ignoriert f<>hrende Leerzeichen \tabularnewline\STRUT
\texttt{-c} & Pr<50>ft nur, ob die Eingabedaten bereits sortiert sind \tabularnewline\STRUT
\texttt{-f} & Gro<72>- / Kleinschreibung nicht beachten \tabularnewline\STRUT
\texttt{-i} & Nur `printable' Zeichen beachten \tabularnewline\STRUT
\texttt{-k} & Sortiert nicht nach der ersten, sondern nach der angegebenen Spalte (siehe unten) \tabularnewline\STRUT
\texttt{-n} & Numerische Sortierung \tabularnewline\STRUT
\texttt{-r} & Sortierreihenfolge umkehren \tabularnewline\STRUT
\texttt{-t} & Normalerweise f<>ngt ein Feld (siehe \texttt{-k}) beim <20>bergang von `blank' nach `non-blank' an, mit diesem Parameter k<>nnen ander Feld-Trenner definiert werden \tabularnewline\STRUT
\texttt{-u} & Gibt bei identischen Zeilen nur die erste Fundstelle aus (unique)
\end{longtable}

29
todo.tex Normal file
View File

@ -0,0 +1,29 @@
% $Id$
\chapter{Routenplanung - Die Zukunft dieses Dokuments}
Ich werde in dieser Version des Dokumentes nicht alles umgesetzt haben, was mir
sinnvoll erscheint. An dieser Stelle sammele ich Ideen f<>r eine n<>chste
Version. Kommentare dazu nehme ich jederzeit dankend entgegen.
\begin{itemize}
\item \textbf{GNU / Posix:} Bessere Abgrenzung der GNU-Erweiterungen
ge\-gen\-<EFBFBD>\-ber dem Posix-Standard, damit die Skripte portabel bleiben und
nicht nur auf Linux laufen.
\item \textbf{Performance:} Ein Kapitel mit Hinweisen, wie Skripte nicht
unn<EFBFBD>tig langsam werden.
\item \textbf{Interaktive Shell:} Exkurs zur interaktiven Benutzung der Bash.
Es gibt da eine Reihe hilfreicher Tastenkombinationen, die l<>ngst nicht jedem
bekannt sind.
\item \textbf{HTML-Version:} Ich w<>rde gerne eine HTML-Version zur Verf<72>gung
stellen, bin mir aber noch nicht sicher ob das aus den \LaTeX-Quellen geht. Mir
liegt dabei die Indizierung der Stichworte am Herzen, die sollte nicht
verloren gehen.
\item \textbf{Glossar:} Verzeichnis von Begriffen wie PID, Prompt, GID, UID,
Cron, usw.
\end{itemize}

345
werkzeugkasten.tex
View File

@ -24,9 +24,10 @@ 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<EFBFBD>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. ;-)
werden. \textbf{Dies ist also nur ein grober <20>berblick, nicht mal ann<6E>hernd
eine vollst<73>ndige Referenz!} F<>r ausf<73>hrlichere Beschreibungen empfiehlt sich
das Studium der Man-Pages oder der Kauf eines entsprechenden Buches (Siehe
Anhang \ref{quellen}, `Quellen'). Am besten macht man nat<61>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
@ -85,10 +86,15 @@ 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{chgrp} (\ref{chgrp}): Gruppen-ID einer Datei <20>ndern
\item \texttt{chmod} (\ref{chmod}): Zugriffsrechte einer Datei <20>ndern
\item \texttt{chown} (\ref{chown}): Eigent<6E>mer einer Datei <20>ndern
\item \texttt{dirname} (\ref{dirname}): Den Pfad zu einer Datei (ohne den Namen) ausgeben
\item \texttt{find} (\ref{find}): Dateien suchen
\item \texttt{mkdir} (\ref{mkdir}): Verzeichnisse anlegen
\item \texttt{mv} (\ref{mv}): Dateien verschieben
\item \texttt{rm} (\ref{rm}): Dateien l<>schen
\item \texttt{rmdir} (\ref{rmdir}): Verzeichnisse 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}
@ -148,6 +154,13 @@ Verf
\section{... und H<>mmer}\label{haemmer}
Um es noch einmal zu betonen: \textbf{Dies ist keine vollst<73>ndige
Kommandoreferenz!} Es werden nur die wichtigsten Kommandos vorgestellt, und
deren Funktion wird in den meisten F<>llen auch nur kurz angerissen. F<>r
ausgiebigere Informationen empfehle ich entsprechende B<>cher (siehe Anhang
\ref{quellen}, `Quellen') und vor allem die Man-Pages.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{awk}\label{awk}\index{awk=\texttt{awk}|(textbf}
@ -170,18 +183,14 @@ der eigentlichen Datei wird zur
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{bc}\label{bc}\index{bc=\texttt{bc}|(textbf}
Mit dem Kommando \texttt{bc} verf<EFBFBD>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 \texttt{bc} handelt es sich, <20>hnlich wie bei \texttt{expr} um einen
Taschenrechner. Allerdings verf<72>gt dieses Kommando um eine vergleichsweise
komplexe Syntax, die auch Berechnungen mit hoher Genauigkeit zulassen.
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}).
F<EFBFBD>r einfache Grundrechenaufgaben wie das Inkrementieren von Variablen sollte
man entweder die eingebaute Arithmetik-Expansion der Shell (Siehe
\ref{arithmetikexpansion}) oder das wesentlich ressourcenfreundlichere
\texttt{expr} (Siehe \ref{expr}) benutzen.
\index{bc=\texttt{bc}|)}
@ -211,6 +220,87 @@ werden.
\index{cat=\texttt{cat}|)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{chgrp}\label{chgrp}\index{chgrp=\texttt{chgrp}|(textbf}
Jede Datei geh<65>rt einem Benutzer und einer Gruppe. Letzteres l<><6C>t sich mit
\texttt{chgrp} einstellen. Als Parameter wird der Name oder die ID der Gruppe,
sowie ein oder mehrere Dateinamen <20>bergeben. Verzeichnisse k<>nnen rekursiv mit
dem Parameter \texttt{-R} bearbeitet werden.
Der Eingent<6E>mer der Datei wird mit \texttt{chown} (Abschnitt \ref{chown})
festgelegt.
\index{chgrp=\texttt{chgrp}|)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{chmod}\label{chmod}\index{chmod=\texttt{chmod}|(textbf}
In unixoiden Systemen verf<72>gt jede Datei <20>ber eine Reihe von Attributen. Damit
kann eine Menge gemacht werden, f<>r den vollen Funktionsumfang empfiehlt sich
das Studium der Man-Page oder einer umfangreicheren Kommandoreferenz. Hier nur
das wichtigste in K<>rze:
Die Syntax lautet \texttt{chmod [options] mode file...}.
Die einzig wichtige Option ist, analog zu \texttt{chgrp} und \texttt{chown} der
Parameter \texttt{-R} f<>r die rekursive Bearbeitung von Verzeichnissen.
In der Syntax steht `file' f<>r einen oder mehrere Dateinamen.
Den Modus einer Datei sieht man, indem man \texttt{ls -l} darauf ansetzt, die
Ausgabe wird im entsprechenden Abschnitt (\ref{ls}) beschrieben.
Dort ist von den drei `rwx-Bl<42>cken' die Rede, die die Berechtigungen f<>r User
(u), Group (g) und Other (o) angeben. Genau die k<>nnen mittels \texttt{chmod}
gesteuert werden. Zus<75>tzlich gibt es hier noch die Angabe All (a), mit denen
die Rechte f<>r alle Benutzer ver<65>ndert werden k<>nnen.
Hier wird der Modus gesteuert, indem direkt angegeben wird f<>r wen welche
Rechte gelten sollen. Mit `+' werden die Rechte erweitert, `-' nimmt Rechte
und mit `=' werden die Rechte hart gesetzt.
\texttt{chmod u+x datei} macht die Datei f<>r den Besitzer ausf<73>hrbar. Mit
\texttt{chmod u=rw,go=r datei} werden die Rechte auf `rw-r--r--' gesetzt, der
Besitzer kann lesen und schreiben, alle anderen nur lesen.
Neben dieser Art der Notation gibt es noch eine~--~wesentlich
g<EFBFBD>ngigere~--~numerische Schreibweise. Dabei werden die Berechtigungen in Form
von Zahlen angegeben. Dabei werden drei Zahlen von eins bis sieben benutzt.
Deren Bedeutung ergibt sich, wenn man sich die drei Stellen `rwx' als Bin<69>rzahl
vorstellt. Das x steht an der niederwertigsten Stelle, erh<72>lt also den Wert 1.
Das w steht f<>r die 2 und r f<>r 4. In Summe ergeben diese Zahlen die
Berechtigung. Also ist `rwx' gleichbedeutend mit 4+2+1=7. `rw' entspricht
4+2=6. Die reine Leseberechtigung `r' bleibt als 4 stehen.
Zur Verdeutlichung ein paar Beispiele, wo es m<>glich ist in beiden Notationen:
\LTXtable{\textwidth}{tab_kommandos_chmod_beispiele.tex}
Am wichtigsten sind also die Aufrufe \texttt{chmod 644 datei} und \texttt{chmod
755 datei}, je nachdem ob die Datei ausf<73>hrbar sein soll oder nicht.
\index{chmod=\texttt{chmod}|)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{chown}\label{chown}\index{chown=\texttt{chown}|(textbf}
Mit \texttt{chown} lassen sich Benutzer- und Gruppen-ID von Dateien und
Verzeichnissen festlegen. Mit dem Parameter \texttt{-R} sogar rekursiv f<>r
Verzeichnisse.
Ein einzelner Parameter gibt die User-ID oder den Namen des zuk<75>nfigen
Benutzers an, in der Form name:gruppe k<>nnen sowohl User- als auch Gruppen-ID
gleichzeitig ge<67>ndert werden.
Will man lediglich die Gruppen-ID <20>ndern, benutzt man das Kommando
\texttt{chgrp} (Abschnitt \ref{chgrp}).
\index{chown=\texttt{chown}|)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{chpasswd}\label{script}\index{chpasswd=\texttt{chpasswd}|(textbf}
@ -245,7 +335,7 @@ 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.
Verzeichnisse~--~auch leere~--~k<>nnen nur mit \texttt{-R} kopiert werden.
\index{cp=\texttt{cp}|)}
@ -295,10 +385,34 @@ der Praxis oft als sehr hilfreich:
\index{echo=\texttt{echo}|)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{eval}\label{eval}\index{eval=\texttt{eval}|(textbf}
TODO!!! eval
\index{eval=\texttt{eval}|)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{expr}\label{expr}\index{expr=\texttt{expr}|(textbf}
TODO!!! expr
Mit dem Kommando \texttt{expr} verf<72>gt die Shell praktisch <20>ber einen
Taschenrechner f<>r einfache Berechnungen. F<>r komplexe Aufgaben bietet sich das
Tool \texttt{bc} an, n<>heres dazu steht in Abschnitt \ref{bc}.
Genau genommen kann man mit \texttt{expr} nicht nur Berechnungen
durch\-f<EFBFBD>h\-ren, sondern ganz allgemein `Ausdr<64>cke evaluieren'. Damit ist
gemeint, da<64> es zum Beispiel auch Operatoren f<>r Pattern-Matching gibt. Die
wichtigsten Operatoren lauten wie folgt:
\LTXtable{\textwidth}{tab_kommandos_expr_parameter.tex}
Bei einigen Sonderzeichen ist deren Bedeutung in der Shell zu ber<65>cksichtigen,
sie sind also durch Anf<6E>hrungszeichen oder Backslashes zu quoten:
\texttt{i=`expr \$i \textbackslash{}* 3`}.
Eine andere M<>glichkeit f<>r einfache Rechnungen besteht in der sogenannten
Arithmetik-Expansion (Siehe \ref{arithmetikexpansion}).
\index{expr=\texttt{expr}|)}
@ -317,9 +431,9 @@ Siehe auch: Abschnitt \ref{beispiele_suchen_dateien}.
\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.
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<EFBFBD>rer Ausdr<EFBFBD>cke (siehe \ref{mustererkennung}) gesucht werden.
Die folgende Tabelle stellt einige der vielen Parameter vor:
@ -354,15 +468,62 @@ die ganze Wahrheit.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{killall}\label{killall}\index{killall=\texttt{killall}|(textbf}
TODO!!! killall
Im Abschnitt <20>ber \texttt{kill} (\ref{kill}) wird beschrieben, wie man ein
Signal an einen Proze<7A> schickt, dessen ID bekannt ist. Kennt man die ID nicht,
oder will man das Signal an mehrere Prozesse schicken, kann dieses Kommando
eine gro<72>e Hilfe darstellen.
Mit dem Parameter \texttt{-i} wird vor jedem Signal interaktiv gefragt, ob es
geschickt werden soll. Mit \texttt{-v} wird angegeben, ob die Signale
erfolgreich versandt wurden, \texttt{-q} hingegen unterdr<64>ckt die Ausgaben.
Da ein Proze<7A> nach einem Signal nicht notwendigerweise sofort stirbt, gibt es
eine Option \texttt{-w}. Diese Veranla<6C>t \texttt{killall} zu warten, bis alle
Empf<EFBFBD>nger tot sind. Dieser Parameter ist allerdings mit Vorsicht zu genie<69>en:
Wenn der Proze<7A> sich weigert zu sterben, wartet \texttt{killall} ewig.
Eine <20>hnliche Funktionalit<69>t bietet auch das Kommando \texttt{pkill} (Abschnitt
\ref{pkill}), \texttt{killall} hat aber den Vorteil da<64> es auf mehr Systemen
zur Verf<72>gung steht.
\index{killall=\texttt{killall}|)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{ls}\label{ls}\index{ls=\texttt{ls}|(textbf}
Die linke Spalte der Ausgabe zeigt die bestehenden Berechtigungen. Es ist ein
Block in der Form `drwxrwxrwx'. An Stelle des d k<>nnen auch andere Buchstaben
stehen, hier wird der Dateityp angegeben, also ob es sich um eine einfache
Datei (-), ein Verzeichnis (d), einen Link (l) oder <20>hnliches\footnote{Siehe
Man-Page} handelt. An Stelle der rwx-Bl<42>cke k<>nnen auch Striche stehen, die
stehen f<>r nicht gesetzte Attribute.
TODO!!! ls
\index{ls=\texttt{ls}|)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{mkdir}\label{mkdir}\index{mkdir=\texttt{mkdir}|(textbf}
Mit diesem Kommando werden Verzeichnisse angelegt. Dabei kann mit \texttt{-m}
angegeben werden, welche Berechtigungen das Verzeichnis bekommen soll. Mit
\texttt{-p} werden bei Bedarf auch Parent-Verzeichnisse angelegt, es entsteht
also ein kompletter Pfad.
Entfernen lassen sich Verzeichnisse mit \texttt{rmdir} (Abschnitt \ref{rmdir}).
\index{mkdir=\texttt{mkdir}|)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{mv}\label{mv}\index{mv=\texttt{mv}|(textbf}
TODO!!! mv
Dateien und Verzeichnisse k<>nnen mit dem Kommando \texttt{mv} verschoben
werden. Falls am Ziel schon Dateien existieren erzwingt der Parameter
\texttt{-f} die Aktion, die alten Dateien werden <20>berschrieben. Mit \texttt{-i}
wird der Vorgang interaktiv, vor jeder Dateibewegung wird nachgefragt.
\index{mv=\texttt{mv}|)}
@ -370,7 +531,24 @@ TODO!!! mv
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{pgrep}\label{pgrep}\index{pgrep=\texttt{pgrep}|(textbf}
TODO!!! pgrep
Eine h<>ufig wiederkehrende Aufgabe ist es, zu sehen ob ein bestimmter Proze<7A>
existiert oder nicht. Falls das Kommando \texttt{pgrep} zur Verf<72>gung steht,
kannn man auf das Konstrukt mit \texttt{ps} und \texttt{grep} verzichten. Der
folgende Aufruf liefert alle Proze<7A>-IDs, deren Name httpd enth<74>lt, inclusive
des vollen Kommandos:
\texttt{pgrep -lf httpd}
<EFBFBD>ber weitere Parameter l<><6C>t sich genauer spezifizieren, wonach gesucht werden
soll, hier die wichtigsten:
\LTXtable{\textwidth}{tab_kommandos_pgrep_parameter.tex}
Die Ausgabe enth<74>lt per Default nur die Proze<7A>-IDs der Fundstellen. Diese l<><6C>t
sich als Parameter f<>r andere Programme benutzen. Das folgende Beispiel liefert
detaillierte Informationen <20>ber alle xterm-Prozesse:
\texttt{ps -fp \$(pgrep -d, -x xterm)}
Siehe auch: Abschnitt \ref{beispiele_suchen_prozesse}.
@ -380,7 +558,24 @@ Siehe auch: Abschnitt \ref{beispiele_suchen_prozesse}.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{pkill}\label{pkill}\index{pkill=\texttt{pkill}|(textbf}
TODO!!! pkill
Dieses Kommando ist eng verwandt mit \texttt{pgrep} (Siehe Abschnitt
\ref{pgrep}), es versteht im Wesentlichen die gleichen Parameter. Allerdings
werden die Fundstellen hier nicht ausgegeben. Wie der Name schon andeutet,
werden hiermit Prozesse umgebracht. Da man hier mit einem Kommando unter
Umst<EFBFBD>nden viele Prozesse beendet, sollten \textbf{die verwendeten Parameter
genau unter die Lupe} genommen werden, um `Kollateralsch<63>den' zu vermeiden. :-)
Es besteht auch die M<>glichkeit, den Prozessen andere Signale zuzuschicken,
diese Funktion wird im Abschnitt zu \texttt{kill} (\ref{kill}) n<>her
beschrieben. Das folgende Kommando veranla<6C>t beispielsweise den Syslog-Daemon,
seine Konfiguration neu einzulesen:
\texttt{pkill -HUP syslogd}
Das Kommando \texttt{killall} (Abschnitt \ref{killall}) bietet eine <20>hnliche
Funktionalit<EFBFBD>t, allerdings fehlen ihm einige Parameter. Trotzdem sollte im
Zweifel \texttt{killall} benutzt werden, da es auf mehr Systemen zur Verf<72>gung
steht.
\index{pkill=\texttt{pkill}|)}
@ -429,7 +624,7 @@ 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.
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}
@ -460,11 +655,37 @@ Timeout oder ein EOF auf.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{rm}\label{rm}\index{rm=\texttt{rm}|(textbf}
TODO!!! rm
Mit diesem Kommando k<>nnen Dateien und Verzeichnisse gel<65>scht werden. Dabei
kann man vorsichtig vorgehen, indem man mit \texttt{-i} daf<61>r sorgt, da<64> jeder
L<EFBFBD>schvorgang best<73>tigt werden mu<6D>. Oder rabiat, indem man mit \texttt{-f} das
L<EFBFBD>schen erzwingt.
Verzeichnisse k<>nnen mit dem Parameter \texttt{-R} entfernt werden, im
Gegensatz zu \texttt{rmdir} werden dann auch s<>mtliche enthaltenen Dateien und
Unterverzeichnisse gel<65>scht.
Die GNU-Version von \texttt{rm} unterst<73>tzt zus<75>tzlich den Parameter
\texttt{-v}, mit dem jeder L<>schvorgang ausgegeben wird.
\index{rm=\texttt{rm}|)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{rmdir}\label{rmdir}\index{rmdir=\texttt{rmdir}|(textbf}
Mit \texttt{rmdir} werden Verzeichnisse gel<65>scht. Das funktioniert nur, wenn
sie leer sind. Mit \texttt{-p} kann ein kompletter Verzeichnispfad gel<65>scht
werden, will sagen: Alle h<>her liegenden Verzeichnisse im angegebenen Pfad
werden gel<65>scht. Voraussetzung ist hier nat<61>rlich auch, da<64> die Verzeichnisse
nichts au<61>er dem angegebenen Unterverzeichnis enthalten.
Angelegt werden Verzeichnisse mit \texttt{mkdir} (Abschnitt \ref{mkdir}),
nicht-leere Verzeichnisse k<>nnen rekursiv mit \texttt{rm -r} (Abschnitt
\ref{rm}) gel<65>scht werden.
\index{rmdir=\texttt{rmdir}|)}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{script}\label{script}\index{script=\texttt{script}|(textbf}
@ -492,7 +713,22 @@ TODO!!! sed
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{seq}\label{seq}\index{seq=\texttt{seq}|(textbf}
TODO!!! seq
Oft wird eine auf- oder absteigende Sequenz aufeinanderfolgender Zahlen
ben<EFBFBD>tigt, beispielsweise um eine Schleife 100 mal zu durchlaufen. Es ist nicht
sehr performant bei jedem Schleifendurchlauf hochzuz<75>hlen und dann die
entstandene Zahl mit dem Limit zu vergleichen. Daher nimmt man an der Stelle
\texttt{seq} zur Hilfe.
Die zu z<>hlenden Werte werden durch drei unterschiedliche Arten der
Parametrisierung definiert: Ein Aufruf in der Form \texttt{seq 10} gibt die
Zahlen von 1 bis 10 aus. Mit \texttt{seq 10 20} wird von 10 bis 20 gez<65>hlt, und
\texttt{seq 20 -2 10} z<>hlt in zweierschritten r<>ckw<6B>rts von 20 nach 10.
Per default kommen die Werte zeilenweise, mit dem Parameter \texttt{-s} kann
aber auch ein anderes Trennzeichen definiert werden. Will man etwas numerieren
und sp<73>ter nach den Zahlen sortieren, ist es sinnvoll wenn `schmalere' Zahlen
mit f<>hrenden Nullen aufgef<65>llt werden. Das erreicht man mit dem Parameter
\texttt{-w}.
\index{seq=\texttt{seq}|)}
@ -500,7 +736,16 @@ TODO!!! seq
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{sleep}\label{sleep}\index{sleep=\texttt{sleep}|(textbf}
TODO!!! sleep
Das Kommando \texttt{sleep} veranla<6C>t die Shell, f<>r eine angegebene Zeit zu
warten. Die Zeit wird dabei in Sekunden angegeben.
In der GNU-Variante von \texttt{sleep} kann die Einheit der angegebenen
Zeitspanne durch Suffixe definiert werden: \texttt{sleep 10s} schl<68>ft zehn
Sekunden, \texttt{sleep 10m} zehn Minuten. Genauso werden Stunden (h) und Tage
(d) definiert.
Au<EFBFBD>erdem kann die GNU-Variante auch mit nicht-Integer Zeiten arbeiten:
\texttt{sleep 0.5} schl<68>ft eine halbe Sekunde.
\index{sleep=\texttt{sleep}|)}
@ -508,7 +753,34 @@ TODO!!! sleep
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{sort}\label{sort}\index{sort=\texttt{sort}|(textbf}
TODO!!! sort
Mit diesem Befehl wird wie der Name schon andeutet sortiert. Wenn kein
Dateiname als Parameter angegeben wird, liest \texttt{sort} von der
Standard-Eingabe. Geschrieben wird immer auf der Standard-Ausgabe.
Man kann sich vorstellen, da<64> ein solches Kommando recht flexibel sein mu<6D>,
daher stehen eine Menge Parameter zur Verf<72>gung:
\LTXtable{\textwidth}{tab_kommandos_sort_parameter.tex}
Die Sortierung nach der Spalte (mit \texttt{-k}) ist etwas tricky. Die genaue
Syntax wird in der Man-Page mit \texttt{-k POS1[,POS2]} angegeben, das bedeutet
man mu<6D> einen Parameter angeben, man kann bei Bedarf einen zweiten angeben.
Bei der Sortierung wird dann der Bereich ab POS1, bzw. der Bereich zwischen
POS1 und POS2 ber<65>cksichtigt.
Dabei lautet die Syntax f<>r POS \texttt{F[.C][OPTS]}. Dabei gibt F die
Feldnummer an (siehe Parameter \texttt{-t}). Wenn nicht nach dem Feld an sich
sortiert werden soll, kann C die Position des Zeichens innerhalb des Feldes
angeben. Und als ob das noch nicht kompliziert genug w<>re, kann man dem ganzen
Konstrukt noch einen einbuchstabigen Parameter f<>r die Sortier-Option mitgeben.
Wenn das angegebene Feld nicht existiert wird nach der ganzen Zeile sortiert.
OK, Beispiele:
\LTXtable{\textwidth}{tab_kommandos_sort_beispiele.tex}
Weitere Parameter verr<72>t wie immer die Man-Page.
\index{sort=\texttt{sort}|)}
@ -530,7 +802,12 @@ sobald sie an die Datei angeh
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{tee}\label{tee}\index{tee=\texttt{tee}|(textbf}
TODO!!! tee
Dies ist praktisch ein T-St<53>ck f<>r Pipes. \texttt{tee} liest von seiner
Standard-Eingabe, und gibt alle Eingaben direkt auf der Standard-Ausgabe wieder
aus. Nebenbei werden die Ausgaben in eine oder mehrere Dateien geschrieben.
Wenn die Ausgabedateien schon existieren, werden sie <20>berschrieben. Dieses
Verhalten kann mit dem Parameter \texttt{-a} ge<67>ndert werden.
\index{tee=\texttt{tee}|)}
@ -558,7 +835,15 @@ Referenzdatei angepa
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{wc}\label{wc}\index{wc=\texttt{wc}|(textbf}
TODO!!! wc
Wie der Name schon suggeriert\footnote{Oder etwa nicht?!? ;-)} kann man mit
diesem Kommando W<>rter z<>hlen (word count). Gez<65>hlt wird entweder in einer
Datei, oder~--~wenn kein Dateiname angegeben wurde~--~in der Standardeingabe.
Weitaus h<>ufiger wird aber der Parameter \texttt{-l} benutzt, mit dem sich die
Zeilen z<>hlen lassen. Weiterhin kann man Bytes (\texttt{-c}) oder Zeichen
(\texttt{-m}) z<>hlen lassen.
Der Parameter \texttt{-L} gibt die L<>nge der l<>ngsten enthaltenen Zeile aus.
\index{wc=\texttt{wc}|)}

121
wie_sieht_ein_shell_skript_aus.tex
View File

@ -1,6 +1,12 @@
% $Id$
\chapter{Wie sieht ein Shell-Skript aus?}
Wie schon erw<72>hnt, kann ein Shell-Skript beinahe alles, was eine `richtige' Programmiersprache auch kann. Bei der Entwicklung sollte man nur bedenken, da<64> gerade die Ausf<73>hrung von externen Kommandos --- und das ist eine der Standard-Techniken bei der Shell-Programmierung --- nur sehr langsam vonstatten geht. F<>r Anwendungen bei denen z. B. viele Rechnungen oder Stringbearbeitungen gemacht werden m<>ssen, sollte man also ggf. die Benutzung einer anderen Sprache, beispielsweise Perl\index{Perl}, in Erw<72>gung ziehen.
Wie schon erw<72>hnt, kann ein Shell-Skript beinahe alles, was eine `richtige'
Programmiersprache auch kann. Bei der Entwicklung sollte man nur bedenken, da<64>
gerade die Ausf<73>hrung von externen Kommandos~--~und das ist eine der
Standard-Techniken bei der Shell-Programmierung~--~nur sehr langsam vonstatten
geht. F<>r Anwendungen bei denen z. B. viele Rechnungen oder Stringbearbeitungen
gemacht werden m<>ssen, sollte man also ggf. die Benutzung einer anderen
Sprache, beispielsweise Perl\index{Perl}, in Erw<72>gung ziehen.
In der Shell stehen viele Mechanismen zur Verf<72>gung, die auch aus anderen Sprachen bekannt sind. Um den Umfang dieses Dokuments nicht zu sprengen, werden an dieser Stelle nur die wichtigsten vorgestellt.
@ -51,7 +57,12 @@ Auf den meisten Systemen befindet sich im Pfad der Eintrag \texttt{\~{}/bin} bzw
\subsection{R<EFBFBD>ckgabewerte}\label{exitcode}\index{R<EFBFBD>ckgabewert|(textbf}\index{Exit-Code|see{R<EFBFBD>ckgabewert}}\index{Exit-Status|see{R<EFBFBD>ckgabewert}}
Wenn unter Unix ein Proze<7A> beendet wird, gibt er einen R<>ckgabewert (auch Exit-Code oder Exit-Status genannt) an seinen aufrufenden Proze<7A> zur<75>ck. So kann der Mutterproze<7A> kontrollieren, ob die Ausf<73>hrung des Tochterprozesses ohne Fehler beendet wurde. In einigen F<>llen (z. B. \texttt{grep}\index{grep=\texttt{grep}}) werden unterschiedliche Exit-Codes f<>r unterschiedliche Ereignisse benutzt.
Wenn unter Unix ein Proze<7A> beendet wird, gibt er einen R<>ckgabewert (auch
Exit-Code oder Exit-Status genannt) an seinen aufrufenden Proze<7A> zur<75>ck. So
kann der Mutterproze<7A> kontrollieren, ob die Ausf<73>hrung des Tochterprozesses
ohne Fehler beendet wurde. In einigen F<>llen (z. B.
\texttt{grep}\index{grep=\texttt{grep}}) werden unterschiedliche Exit-Codes f<>r
unterschiedliche Ereignisse benutzt.
Dieser R<>ckgabewert wird bei der interaktiven Benutzung der Shell nur selten
benutzt, da Fehlermeldungen direkt vom Benutzer abgelesen werden k<>nnen. Aber
@ -64,25 +75,67 @@ Beschreibung der Kommandos \texttt{if}\index{if=\texttt{if}} (\ref{if}),
\texttt{until}\index{until=\texttt{until}} (\ref{until}), sowie in dem
Abschnitt <20>ber Befehlsformen (\ref{befehlsformen}).
In der Bourne-Shell wird der Exit-Code des letzten aufgerufenen Programms in der Variable \texttt{\$?}\index{\$?=\texttt{\$?}} abgelegt. <20>blicherweise geben Programme den Wert 0 zur<75>ck, bei irgendwelchen Problemen einen von 0 verschiedenen Wert. Das wird im folgenden Beispiel deutlich:
\LTXtable{\textwidth}{tab_beisp_exitcode.tex}
Normalerweise wird man den Exit-Code nicht in dieser Form abfragen. Sinnvoller ist folgendes Beispiel, in dem eine Datei erst gedruckt wird, und dann --- falls der Ausdruck erfolgreich war --- gel<65>scht wird:
\LTXtable{\textwidth}{tab_beisp_exitcode_lpr.tex}
N<EFBFBD>heres zur Verkn<6B>pfung von Aufrufen steht im Kapitel <20>ber Befehlsformen (\ref{befehlsformen}). Beispiele zur Benutzung von R<>ckgabewerten in Schleifen finden sich im Anhang unter \ref{beisp_schleifen_exitcode}.
In der Bourne-Shell wird der Exit-Code des letzten aufgerufenen Programms in
der Variable \texttt{\$?}\index{\$?=\texttt{\$?}} abgelegt. <20>blicherweise geben
Programme den Wert 0 zur<75>ck, bei irgendwelchen Problemen einen von 0
verschiedenen Wert. Das wird im folgenden Beispiel deutlich:
\LTXtable{\textwidth}{tab_beisp_exitcode.tex}
Normalerweise wird man den Exit-Code nicht in dieser Form abfragen. Sinnvoller
ist folgendes Beispiel, in dem eine Datei erst gedruckt wird, und dann~--~falls
der Ausdruck erfolgreich war ~--~el<65>scht wird:
\LTXtable{\textwidth}{tab_beisp_exitcode_lpr.tex}
N<EFBFBD>heres zur Verkn<6B>pfung von Aufrufen steht im Kapitel <20>ber Befehlsformen
(\ref{befehlsformen}). Beispiele zur Benutzung von R<>ckgabewerten in Schleifen
finden sich im Anhang unter \ref{beisp_schleifen_exitcode}.
Auch Shell-Skripte k<>nnen einen R<>ckgabewert an aufrufende Prozesse
zur<EFBFBD>ckgeben. Wie das geht, steht in dem Abschnitt zu \texttt{exit}
(\ref{exit}).
Auch Shell-Skripte k<>nnen einen R<>ckgabewert an aufrufende Prozesse zur<75>ckgeben. Wie das geht, steht in dem Abschnitt zu \texttt{exit} (\ref{exit}).
\index{R<EFBFBD>ckgabewert|)}
\section{Variablen}\index{Variablen|(textbf}
In einem Shell-Skript hat man --- genau wie bei der interaktiven Nutzung der Shell --- M<>glichkeiten, <20>ber Variablen zu verf<72>gen. Anders als in den meisten modernen Programmiersprachen gibt es aber keine Datentypen\index{Datentypen} wie Ganzzahlen, Flie<69>kommazahlen oder Strings\footnote{Bei einigen modernen Shells (\texttt{csh}\index{C-Shell}, \texttt{tcsh}\index{TENEX-C-Shell}, \texttt{ksh}\index{Korn-Shell}, \texttt{bash}\index{Bourne-Again-Shell}, \texttt{zsh}\index{Z-Shell}...) hat man die M<>glichkeit, Variablentypen zu vereinbaren. In der Bourne-Shell\index{Bourne-Shell} nicht.}. Alle Variablen werden als String gespeichert, wenn die Variable die Funktion einer Zahl <20>bernehmen soll, dann mu<6D> das verarbeitende Programm die Variable entsprechend interpretieren\footnote{F<EFBFBD>r arithmetische Operationen steht das Programm \texttt{expr}\index{expr=\texttt{expr}} zur Verf<72>gung (siehe Z<>hlschleifen-Beispiel unter \ref{while})}.
In einem Shell-Skript hat man~--~genau wie bei der interaktiven Nutzung der
Shell~--~M<>glichkeiten, <20>ber Variablen zu verf<72>gen. Anders als in den meisten
modernen Programmiersprachen gibt es aber keine Datentypen\index{Datentypen}
wie Ganzzahlen, Flie<69>kommazahlen oder Strings\footnote{Bei einigen modernen
Shells (\texttt{csh}\index{C-Shell}, \texttt{tcsh}\index{TENEX-C-Shell},
\texttt{ksh}\index{Korn-Shell}, \texttt{bash}\index{Bourne-Again-Shell},
\texttt{zsh}\index{Z-Shell}...) hat man die M<>glichkeit, Variablentypen zu
vereinbaren. In der Bourne-Shell\index{Bourne-Shell} nicht.}. Alle Variablen
werden als String gespeichert, wenn die Variable die Funktion einer Zahl
<EFBFBD>bernehmen soll, dann mu<6D> das verarbeitende Programm die Variable entsprechend
interpretieren\footnote{F<EFBFBD>r arithmetische Operationen steht das Programm
\texttt{expr}\index{expr=\texttt{expr}} zur Verf<72>gung (siehe
Z<EFBFBD>hlschleifen-Beispiel unter \ref{while})}.
Man mu<6D> bei der Benutzung von Variablen sehr aufpassen, wann die Variable expandiert\footnote{Mit \emph{Expansion}\index{Expansion} ist das Ersetzen des Variablennamens durch den Inhalt gemeint} wird und wann nicht. Grunds<64>tzlich werden Variablen w<>hrend der Ausf<73>hrung des Skriptes immer an den Stellen ersetzt, an denen sie stehen. Das passiert in jeder Zeile, unmittelbar bevor sie ausgef<65>hrt wird. Es ist also auch m<>glich, in einer Variable einen Shell-Befehl abzulegen. Im Folgenden kann dann der Variablenname an der Stelle des Befehls stehen. Um die Expansion einer Variable zu verhindern, benutzt man das Quoting\index{Quoting} (siehe unter \ref{quoting}).
Man mu<6D> bei der Benutzung von Variablen sehr aufpassen, wann die Variable
expandiert\footnote{Mit \emph{Expansion}\index{Expansion} ist das Ersetzen des
Variablennamens durch den Inhalt gemeint} wird und wann nicht. Grunds<64>tzlich
werden Variablen w<>hrend der Ausf<73>hrung des Skriptes immer an den Stellen
ersetzt, an denen sie stehen. Das passiert in jeder Zeile, unmittelbar bevor
sie ausgef<65>hrt wird. Es ist also auch m<>glich, in einer Variable einen
Shell-Befehl abzulegen. Im Folgenden kann dann der Variablenname an der Stelle
des Befehls stehen. Um die Expansion einer Variable zu verhindern, benutzt man
das Quoting\index{Quoting} (siehe unter \ref{quoting}).
Wie aus diversen Beispielen hervorgeht, belegt man eine Variable, indem man dem Namen mit dem Gleichheitszeichen einen Wert zuweist. Dabei darf zwischen dem Namen und dem Gleichheitszeichen keine Leerstelle stehen, ansonsten erkennt die Shell den Variablennamen nicht als solchen und versucht, ein gleichnamiges Kommando auszuf<75>hren --- was meistens durch eine Fehlermeldung quittiert wird.
Wie aus diversen Beispielen hervorgeht, belegt man eine Variable, indem man dem
Namen mit dem Gleichheitszeichen einen Wert zuweist. Dabei darf zwischen dem
Namen und dem Gleichheitszeichen keine Leerstelle stehen, ansonsten erkennt die
Shell den Variablennamen nicht als solchen und versucht, ein gleichnamiges
Kommando auszuf<75>hren~--~was meistens durch eine Fehlermeldung quittiert wird.
Wenn man auf den Inhalt einer Variablen zugreifen m<>chte, leitet man den
Variablennamen durch ein \texttt{\$}-Zeichen ein. Alles was mit einem
\texttt{\$} anf<6E>ngt wird von der Shell als Variable angesehen und entsprechend
behandelt (expandiert).
Wenn man auf den Inhalt einer Variablen zugreifen m<>chte, leitet man den Variablennamen durch ein \texttt{\$}-Zeichen ein. Alles was mit einem \texttt{\$} anf<6E>ngt wird von der Shell als Variable angesehen und entsprechend behandelt (expandiert).
\index{Variablen|)}
@ -271,7 +324,11 @@ Bei der Shell-Programmierung verf
\subsection{Kommentare\label{kommentare}\index{Kommentar|(textbf} (\texttt{\#})}\index{\#=\texttt{\#}|see{Kommentar}}
Kommentare in der Shell beginnen immer mit dem Nummern-Zeichen (\verb\#\). Dabei spielt es keine Rolle, ob das Zeichen am Anfang der Zeile steht, oder hinter irgendwelchen Befehlen. Alles von diesem Zeichen bis zum Zeilenende wird nicht beachtet (bis auf eine Ausnahme --- siehe unter \ref{auswahl_der_shell}).
Kommentare in der Shell beginnen immer mit dem Nummern-Zeichen (\verb\#\).
Dabei spielt es keine Rolle, ob das Zeichen am Anfang der Zeile steht, oder
hinter irgendwelchen Befehlen. Alles von diesem Zeichen bis zum Zeilenende wird
nicht beachtet (bis auf eine Ausnahme~--~siehe unter \ref{auswahl_der_shell}).
\index{Kommentar|)}
@ -330,9 +387,21 @@ durch die Eingabe von \verb\count\.\nopagebreak
\subsection{Bedingungen (\texttt{[ ]})}\label{bedingungen}\index{Bedingungen|see{test}}\index{[ ]=\texttt{[ ]}|see{test}}\index{test=\texttt{test}|(textbf}
Da die Standard-Shell keine arithmetischen oder logischen Ausdr<64>cke auswerten kann\footnote{\texttt{if} und Konsorten pr<70>fen nur den R<>ckgabewert\index{R<EFBFBD>ckgabewert} eines aufgerufenen Programmes --- 0 bedeutet `true', alles andere bedeutet `false', siehe auch \ref{exitcode}.}, mu<6D> dazu ein externes Programm benutzt werden. Dieses Programm hei<65>t \verb\test\\index{test=\texttt{test}}. <20>blicherweise besteht auf allen Systemen auch noch ein Link namens \verb\[\ auf dieses Programm. Dieser Link ist fast absolut gleichwertig zu benutzen (in dieser Form wird allerdings eine abschlie<69>ende Klammer nach der Bedingung erwartet). Dementsprechend ist es auch zwingend erforderlich, nach der Klammer ein Leerzeichen zu schreiben. Das dient dazu, Bedingungen in \verb\if\-Abfragen u. <20>. lesbarer zu machen.
Da die Standard-Shell keine arithmetischen oder logischen Ausdr<64>cke auswerten
kann\footnote{\texttt{if} und Konsorten pr<70>fen nur den
R<EFBFBD>ckgabewert\index{R<EFBFBD>ckgabewert} eines aufgerufenen Programmes~--~0 bedeutet
`true', alles andere bedeutet `false', siehe auch \ref{exitcode}.}, mu<6D> dazu
ein externes Programm benutzt werden. Dieses Programm hei<65>t
\verb\test\\index{test=\texttt{test}}. <20>blicherweise besteht auf allen Systemen
auch noch ein Link namens \verb\[\ auf dieses Programm. Dieser Link ist fast
absolut gleichwertig zu benutzen (in dieser Form wird allerdings eine
abschlie<EFBFBD>ende Klammer nach der Bedingung erwartet). Dementsprechend ist es auch
zwingend erforderlich, nach der Klammer ein Leerzeichen zu schreiben. Das dient
dazu, Bedingungen in \verb\if\-Abfragen u. <20>. lesbarer zu machen.
Das \verb\test\-Programm bietet sehr umfangreiche Optionen an. Dazu geh<65>ren Dateitests und Vergleiche von Zeichenfolgen oder ganzen Zahlen. Diese Bedingungen k<>nnen auch durch Verkn<6B>pfungen kombiniert werden.
Das \verb\test\-Programm bietet sehr umfangreiche Optionen an. Dazu geh<65>ren
Dateitests und Vergleiche von Zeichenfolgen oder ganzen Zahlen. Diese
Bedingungen k<>nnen auch durch Verkn<6B>pfungen kombiniert werden.
\medskip\medskip\emph{Dateitests:}\index{Dateitests}\nopagebreak
\LTXtable{\textwidth}{tab_bedingungen_dateitests.tex}
@ -387,12 +456,28 @@ In den Mustern sind die gleichen Meta-Zeichen\index{Meta-Zeichen} erlaubt wie be
\subsection{for\ldots}\label{for}\index{for=\texttt{for}|(textbf}\index{Schleife>for-=\texttt{for}-|see{for}}\index{in=\texttt{in}|see{for}}\index{in=\texttt{in}|see{case}}\index{do=\texttt{do}|see{for}}\index{do=\texttt{do}|see{while}}\index{do=\texttt{do}|see{until}}\index{do=\texttt{done}|see{for}}\index{do=\texttt{done}|see{while}}\index{do=\texttt{done}|see{until}}
Dieses Konstrukt <20>hnelt nur auf den ersten Blick seinen Pendants aus anderen Programmiersprachen. In anderen Sprachen wird die \texttt{for}-Schleife meistens dazu benutzt, eine Z<>hlvariable <20>ber einen bestimmten Wertebereich iterieren zu lassen (\texttt{for i = 1 to 100\ldots next}). In der Shell dagegen wird die Laufvariable nicht mit aufeinanderfolgenden Zahlen belegt, sondern mit einzelnen Werten aus einer anzugebenden Liste\footnote{Wenn man trotzdem eine Laufvariable\index{Laufvariable} braucht, mu<6D> man dazu die \texttt{while}-Schleife\index{while=\texttt{while}} `mi<6D>brauchen' (siehe unter \ref{while}).}.
Dieses Konstrukt <20>hnelt nur auf den ersten Blick seinen Pendants aus anderen
Programmiersprachen. In anderen Sprachen wird die \texttt{for}-Schleife
meistens dazu benutzt, eine Z<>hlvariable <20>ber einen bestimmten Wertebereich
iterieren zu lassen (\texttt{for i = 1 to 100\ldots next}). In der Shell
dagegen wird die Laufvariable nicht mit aufeinanderfolgenden Zahlen belegt,
sondern mit einzelnen Werten aus einer anzugebenden Liste\footnote{Wenn man
trotzdem eine Laufvariable\index{Laufvariable} braucht, mu<6D> man dazu die
\texttt{while}-Schleife\index{while=\texttt{while}} `mi<6D>brauchen' (siehe unter
\ref{while}).}.
Die Syntax der \texttt{for}-Schleife lautet wie folgt:\nopagebreak
\LTXtable{\textwidth}{tab_for.tex}
Die \textsl{Befehle} werden ausgef<65>hrt, wobei der Variablen \textsl{x} nacheinander die Werte aus der \textsl{Liste} zugewiesen werden. Wie man sieht ist die Angabe der \textsl{Liste} optional, wenn sie nicht angegeben wird, nimmt \textsl{x} der Reihe nach alle Werte aus \texttt{\$@} (in dieser vordefinierten Variablen liegen die Aufrufparameter --- siehe unter \ref{vordefinierte_variablen}) an. Wenn die Ausf<73>hrung eines Schleifendurchlaufs bzw der ganzen Schleife abgebrochen werden soll, m<>ssen die Kommandos \texttt{continue}\index{continue=\texttt{continue}} (\ref{continue}) bzw. \texttt{break}\index{break=\texttt{break}} (\ref{break}) benutzt werden.
Die \textsl{Befehle} werden ausgef<65>hrt, wobei der Variablen \textsl{x}
nacheinander die Werte aus der \textsl{Liste} zugewiesen werden. Wie man sieht
ist die Angabe der \textsl{Liste} optional, wenn sie nicht angegeben wird,
nimmt \textsl{x} der Reihe nach alle Werte aus \texttt{\$@} (in dieser
vordefinierten Variablen liegen die Aufrufparameter~--~siehe unter
\ref{vordefinierte_variablen}) an. Wenn die Ausf<73>hrung eines
Schleifendurchlaufs bzw der ganzen Schleife abgebrochen werden soll, m<>ssen die
Kommandos \texttt{continue}\index{continue=\texttt{continue}} (\ref{continue})
bzw. \texttt{break}\index{break=\texttt{break}} (\ref{break}) benutzt werden.
\medskip\emph{Beispiele:}\nopagebreak
\LTXtable{\textwidth}{tab_beisp_for.tex}
@ -441,7 +526,7 @@ Die Syntax der \texttt{until}-Schleife lautet wie folgt:\nopagebreak
Die \textsl{Bedingung} wird dabei <20>blicherweise, genau wie bei der
\texttt{if}-Anweisung, mit mit dem Befehl
\texttt{test}\index{test=\texttt{test}} (siehe unter \ref{bedingungen})
formuliert. Wenn die Ausf<EFBFBD>hrung eines Schleifendurchlaufs bzw der ganzen
formuliert. Wenn die Aus\-f<EFBFBD>h\-rung eines Schleifendurchlaufs bzw der ganzen
Schleife abgebrochen werden soll, m<>ssen die Kommandos
\texttt{continue}\index{continue=\texttt{continue}} (\ref{continue}) bzw.
\texttt{break}\index{break=\texttt{break}} (\ref{break}) benutzt werden.