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

Initial revision

Browse Source
This commit is contained in:
rschaten
2001-07-02 12:52:18 +00:00
commit 961448f7ce
61 changed files with 2500 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

402
Makefile Normal file
View File

@ -0,0 +1,402 @@
#
# LaTeX Makefile
# --------------
#
# Author : s.m.vandenoord@student.utwente.nl (Stefan van den Oord)
# Date : July 15, 1999
#
# This Makefile is a generic makefile for LaTeX documents. Distribute it
# as you wish, but please don't edit or remove this initial comment.
#
# The Makefile can be used by setting the environment variable "MAKEFILES",
# e.g. export MAKEFILES=~/data/TeX/Makefile.
# It requires GNU Make and bash or better, like zsh. Simply sh is not
# sufficient, I believe. The first few lines of the Makefile contains
# the executables that are used, edit them to point to the executables
# on your system.
#
# DISCLAIMER: Using this Makefile is fully at your own risk. I am not
# responsible for anything! So if crucial files are removed
# by the Makefile, it is your own problem. But you should
# have backups anyway. :-)
#
# Usage
# -----
# The Makefile can do the following things for you:
# - generate PostScript equivalents of XFig figures;
# - run makeindex and BibTeX, but only if necessary;
# - compile the .dvi file, running LaTeX as many times as needed;
# - run XDvi with the compiled .dvi file;
# - create a PostScript equivalent of the .dvi file;
# - generate a HTML equivalent of the .dvi file (if Latex2HTML is
# installed);
# - remove all generated output.
# The Makefile is in some points even RCS aware.
#
# In many cases, you don't even have to tell the Makefile which LaTeX
# file it has to compile. The Makefile uses the following strategy:
# 1. Check if the environment variable LATEXTARGET is set; if it is,
# generate $LATEXTARGET.dvi.
# 2. If there is only one .tex file, use that one.
# 3. Check if there is a LaTeX file that has the same basename as the
# directory. For example, if the directory is named "Thesis" and
# there is a file "Thesis.tex", "Thesis.dvi" is generated.
#
# Invocation
# ----------
# When the MAKEFILES environment variable is set, you can use the
# following commands:
# - make latexhelp
# Prints an overview of the available commands.
# - make latexfigures
# Only generate the PostScript equivalents of XFig figures.
# - make file.dvi
# Generates the specified DVI file.
# - make file.ps
# Generates the DVI file and then runs dvips.
# - make latex
# Use the above explained strategy to find out what has to be
# generated, and generate it.
# - make view
# Do a make latex and then run XDvi.
# - make latexps
# Do a make latex and then run dvips.
# - make html
# Do a make latex and then use LaTeX2HTML to create the HTML equivalent.
# To do this, the following environment variables are used:
# * HTMLDIR : the base dir in which the output is written. For example,
# if HTMLDIR=~/public_html/LaTeX, and the file that is
# generated is "Thesis", the output will be written in the
# directory ~/public_html/LaTeX/Thesis.
# * LATEX2HTML_OPTS : if you want to pass options to LaTeX2HTML, put
# them in this variable.
# - make latexclean
# This command removes all generated output. CAUTION: the files that are
# removed are thought out pretty well, but it is possible that files are
# removed that you wanted to keep! Check below what files are removed if
# you want to be certain!
# Note that a file figure.eps is only removed if a file figure.fig exists.
# (Even if the file figure.fig exists, but is checked in using RCS, the
# file figure.eps will be removed.)
#
# Tip
# ---
# For some projects it is useful to have a separate Makefile in the project's
# directory. For example, when you use RCS, you could add functionality for
# automatic checkouts of the right files (adding dependencies is sufficient;
# GNU Make rocks :-).
# The command "latexclean" is declared so that you can add your own
# functionality in the project's Makefile; instead of one colon, declare it
# with two colons if you want to do that.
# For example:
# latexclean::
# rm -f foo.bar
# This way both the origional definition in this Makefile and your own are
# used.
#
# Changes:
# - March 22, 1999:
# Added -o $@ to the dvips invocation.
# - June 3, 1999:
# Removed the target "all" from the help output.
# - June 4, 1999:
# 'latexclean' now only removes a DVI files if there is a TeX file
# with the same name.
# - June 17, 1999:
# Removed the `find' command in the latexclean target. This is because
# the option '-maxdepth' is Linux-specific. And `ls' is simpler anyway.
# :-)
# - July 15, 1999:
# The variables "LATEX", "BIBTEX", etc. are now taken from the environment
# if they are defined there.
#.SILENT:
SHELL=/bin/bash
ifndef LATEX
LATEX=latex
endif
ifndef BIBTEX
BIBTEX=bibtex
endif
ifndef DVIPS
DVIPS=dvips
endif
ifndef MAKEINDEX
MAKEINDEX=makeindex
endif
ifndef DVIVIEWER
DVIVIEWER=xdvi
endif
ifndef LATEX2HTML
LATEX2HTML=latex2html
endif
ifndef SED
SED=sed
endif
ifndef PDFLATEX
PDFLATEX=pdflatex
endif
ifndef THUMBPDF
THUMBPDF=thumbpdf
endif
FIGURES=$(wildcard *.fig)
FIGUREOBJS=$(FIGURES:.fig=.eps)
TEXFILES=$(wildcard *.tex)
#test: latexhelp
# Disable standard pattern rule:
%.dvi: %.tex
# Do not delete the following targets:
.PRECIOUS: %.aux %.bbl %.eps %.ind
%.aux: %.tex $(FIGUREOBJS) $(TEXFILES)
@$(LATEX) $*
# Look for citations. Make sure grep never returns an error code.
@grep "^\\\\citation" *.aux > .btmp.new || true
# If the citations are not changed, don't do anything. Otherwise replace
# the .btmp file to make sure Bibtex will be run.
@if ( diff .btmp.new .btmp >& /dev/null ); then \
rm .btmp.new; \
else \
mv .btmp.new .btmp; \
fi
@if [ -f $*.idx ]; then cp $*.idx .itmp.new; else touch .itmp.new; fi
@if ( diff .itmp.new .itmp >& /dev/null ); then \
rm .itmp.new; \
else \
mv .itmp.new .itmp; \
fi
.btmp:
%.bbl: $(BIBFILES) .btmp
# Only use BibTeX if \bibliography occurs in the document. In that case,
# run BibTeX and recompile. .btmp is touched to prevent useless making
# next time.
@if ( grep "^\\\\bibliography{" $*.tex > /dev/null ); then \
$(BIBTEX) $*; \
touch .rerun; \
fi
@touch .btmp
.itmp:
%.ind: .itmp
@if [ -f $*.idx ]; then \
cat $*.idx | $(SED) -e 's/ *{/{/g;s/ *}/}/g;s/ *=/=/g' > temp.idx; \
rm $*.idx; \
mv temp.idx $*.idx; \
$(MAKEINDEX) -g -s rene.ist $*; \
touch .rerun; \
touch .itmp; \
fi
%.eps:%.fig
@echo Generating figure $@...
@fig2dev -L ps $< $@
%.dvi: %.aux %.ind %.bbl
# Make sure the dvi-file exists; if not: recompile.
@if [ ! -f $*.dvi ]; then \
touch .rerun; \
fi
@if [ -f .rerun ]; then \
rm .rerun; \
$(LATEX) $*; \
else \
$(MAKE) $*.aux; \
fi
# While references et al. are changed: recompile.
@while ( grep Rerun $*.log > /dev/null ); do \
$(LATEX) $*; \
done
# Touch the figureobjects to prevent making next time
@if [ -n "$(FIGUREOBJS)" ]; then \
touch $(FIGUREOBJS); \
touch $*.aux; \
fi
@if [ -f $*.ind ]; then \
touch $*.ind; \
fi
%.pdf: %.aux %.ind %.bbl
# Make sure the pdf-file exists; if not: recompile.
@if [ ! -f $*.pdf ]; then \
touch .rerun; \
fi
@if [ -f .rerun ]; then \
rm .rerun; \
$(PDFLATEX) $*; \
$(THUMBPDF) $*; \
$(PDFLATEX) $*; \
else \
$(MAKE) $*.aux; \
fi
# While references et al. are changed: recompile.
@while ( grep Rerun $*.log > /dev/null ); do \
$(PDFLATEX) $*; \
$(THUMBPDF) $*; \
$(PDFLATEX) $*; \
done
# Touch the figureobjects to prevent making next time
@if [ -n "$(FIGUREOBJS)" ]; then \
touch $(FIGUREOBJS); \
touch $*.aux; \
fi
@if [ -f $*.ind ]; then \
touch $*.ind; \
fi
latex:
# Below the 'true' is included to prevent unnecessarily many errors.
@if [ -n "${LATEXTARGET}" ]; then \
$(MAKE) ${LATEXTARGET}.dvi; \
true; \
else \
if [ `ls *.tex | wc -l` = "1" ]; then \
$(MAKE) `basename \`ls *.tex\` .tex`.dvi; \
true; \
else \
$(MAKE) `echo $$PWD|tr '/' '\n'|tail -1`.dvi; \
true; \
fi; \
fi
pdflatex:
# Below the 'true' is included to prevent unnecessarily many errors.
@if [ -n "${LATEXTARGET}" ]; then \
$(MAKE) ${LATEXTARGET}.pdf; \
true; \
else \
if [ `ls *.tex | wc -l` = "1" ]; then \
$(MAKE) `basename \`ls *.tex\` .tex`.pdf; \
true; \
else \
$(MAKE) `echo $$PWD|tr '/' '\n'|tail -1`.pdf; \
true; \
fi; \
fi
latexfigures:
@for i in $(FIGUREOBJS); do \
$(MAKE) $$i; \
done
view:
# Below the 'true' is included to prevent unnecessarily many errors.
@if [ -n "${LATEXTARGET}" ]; then \
$(MAKE) ${LATEXTARGET}.dvi && \
$(DVIVIEWER) ${LATEXTARGET}.dvi; \
true; \
else \
if [ `ls *.tex | wc -l` = "1" ]; then \
$(MAKE) `basename \`ls *.tex\` .tex`.dvi && \
$(DVIVIEWER) `basename \`ls *.tex\` .tex`.dvi; \
true; \
else \
$(MAKE) `echo $$PWD|tr '/' '\n'|tail -1`.dvi && \
$(DVIVIEWER) `echo $$PWD|tr '/' '\n'|tail -1`.dvi; \
true; \
fi; \
fi
%.ps: %.dvi
$(DVIPS) -o $@ $<
latexps:
@if [ -n "${LATEXTARGET}" ]; then \
$(MAKE) ${LATEXTARGET}.ps && \
true; \
else \
if [ `ls *.tex | wc -l` = "1" ]; then \
$(MAKE) `basename \`ls *.tex\` .tex`.ps && \
true; \
else \
$(MAKE) `echo $$PWD|tr '/' '\n'|tail -1`.ps && \
true; \
fi; \
fi
html: .html
.html:
@if [ -n "${LATEXTARGET}" ]; then \
if [ -n "${HTMLDIR}" ]; then \
$(MAKE) ${LATEXTARGET}.dvi; \
$(LATEX2HTML) $(LATEX2HTML_OPTS) -dir $(HTMLDIR)/$(LATEXTARGET) $(LATEXTARGET) && \
chmod a+rx $(HTMLDIR)/$(LATEXTARGET) && \
chmod a+r $(HTMLDIR)/$(LATEXTARGET)/* && \
touch .html; \
else \
echo Set variable HTMLDIR\!; \
fi; \
else \
echo Set variable LATEXTARGET\!; \
fi
latexhelp:
@echo "LaTeX Makefile Options"
@echo "----------------------"
@echo ""
@echo "Environment variables:"
@echo " LATEXTARGET Filename to make (without extension)"
@echo " HTMLDIR Directory for HTML-output"
@echo " FIGURES Figures that have to be compiled"
@echo ""
@echo "Targets:"
@echo " <name>.dvi Make the given dvi file"
@echo " latex Make the LATEXTARGET or <dirname>.dvi"
@echo " pdflatex Make the LATEXTARGET or <dirname>.pdf"
@echo " latexps Make the LATEXTARGET or <dirname>.ps"
@echo " view Make and view the LATEXTARGET or <dirname>.dvi"
@echo " html Make the LATEXTARGET or <dirname>.dvi and generate HTML output"
@echo " latexhelp This overview"
@echo " latexclean Remove all generated files"
latexclean::
@rm -f *.log *.aux *.bbl *.blg *.ilg *.toc *.lof *.lot *.idx *.ind .html .btmp .itmp .rerun *~
@rm -f thumb[0-9][0-9][0-9].png
@rm -f thumbdta.tex thumbpdf.pdf
@for i in *.eps; do \
if [ -f "`basename $$i .eps`.fig" ]; then \
rm -f $$i; \
elif ( rcs `basename $$i .eps`.fig >& /dev/null ); then \
rm -f $$i; \
fi \
done
@for i in *.dvi; do \
if [ -f "`basename $$i .dvi`.tex" ]; then \
rm -f $$i; \
fi \
done
@for i in *.pdf; do \
if [ -f "`basename $$i .pdf`.tex" ]; then \
rm -f $$i; \
fi \
done

324
beispiele.tex Normal file
View File

@ -0,0 +1,324 @@
\chapter{Beispiele}
\section{Schleifen und R<>ckgabewerte}\label{beisp_schleifen_exitcode}\index{Schleife}\index{R<EFBFBD>ckgabewert}
Man kann mit einer \texttt{until}\index{until=\texttt{until}}- bzw. mit einer \texttt{while}\index{while=\texttt{while}}-Schleife schnell kleine aber sehr n<>tzliche Tools schreiben, die einem l<>stige Aufgaben abnehmen.
\subsection{Schleife, bis ein Kommando erfolgreich war}
Angenommen, bei der Benutzung eines Rechners tritt ein Problem auf, bei dem nur der Administrator helfen kann. Dann m<>chte man informiert werden, sobald dieser an seinem Arbeitsplatz ist. Man kann jetzt in regelm<6C><6D>igen Abst<73>nden das Kommando \texttt{who}\index{who=\texttt{who}} ausf<73>hren, und dann in der Ausgabe nach dem Eintrag `\texttt{root}' suchen. Das ist aber l<>stig.
Einfacher geht es, wenn wir uns ein kurzes Skript schreiben, das alle 30 Sekunden automatisch <20>berpr<70>ft, ob der Admin angemeldet ist. Wir erreichen das mit dem folgenden Code:
\footnotesize
\index{\^=\texttt{\^}}\index{Anf<EFBFBD>hrungszeichen}\index{Pipe}\index{grep=\texttt{grep}}\index{sleep=\texttt{sleep}}\index{who=\texttt{who}}
\begin{listing}[2]{1}
#!/bin/sh
until who | grep "^root "
do sleep 30
done
echo Big Brother is watching you!
\end{listing}
\normalsize
Das Skript f<>hrt also so lange das Kommando aus, bis die Ausf<73>hrung erfolgreich war. Dabei wird die Ausgabe von \texttt{who}\index{who=\texttt{who}} mit einer Pipe (\ref{datenstrom}) in das \texttt{grep}\index{grep=\texttt{grep}}-Kommando umgeleitet. Dieses sucht darin nach einem Auftreten von `\texttt{root~}' am Zeilenanfang. Der R<>ckgabewert von \texttt{grep}\index{grep=\texttt{grep}} ist 0 wenn das Muster\index{Mustererkennung} gefunden wird, 1 wenn es nicht gefunden wird und 2 wenn ein Fehler auftrat. Damit der Rechner nicht die ganze Zeit mit dieser Schleife besch<63>ftigt ist, wird im Schleifenk<6E>rper ein \texttt{sleep 30}\index{sleep=\texttt{sleep}} ausgef<65>hrt, um den Proze<7A> f<>r 30 Sekunden schlafen zu schicken. Sobald der Admin sich eingeloggt hat, wird eine entsprechende Meldung ausgegeben.
\subsection{Schleife, bis ein Kommando erfolglos war}
Analog zum vorhergehenden Beispiel kann man auch ein Skript schreiben, das meldet, sobald sich ein Benutzer abgemeldet hat. Dazu ersetzen wir nur die \texttt{until}- Schleife durch eine entsprechende \texttt{while}-Schleife:
\footnotesize
\index{\^=\texttt{\^}}\index{Anf<EFBFBD>hrungszeichen}\index{grep=\texttt{grep}}\index{Pipe}\index{sleep=\texttt{sleep}}\index{who=\texttt{who}}
\begin{listing}[2]{1}
#!/bin/sh
while who | grep "^root "
do sleep 30
done
echo Die Katze ist aus dem Haus, Zeit, da<64> die M<>use tanzen!
\end{listing}
\normalsize
Die Schleife wird n<>mlich dann so lange ausgef<65>hrt, bis \texttt{grep}\index{grep=\texttt{grep}} einen Fehler (bzw. eine erfolglose Suche) zur<75>ckmeldet.
\section{Eine Datei zeilenweise bearbeiten}
\texttt{cat datei.txt | while read i}
TODO!!!
Achtung! while ist eine Subshell - Daten m<>ssen hochgereicht werden.
\section{Ein typisches Init-Skript}\label{init-skript}\index{Init-Skript}
Dieses Skript dient dazu, den Apache HTTP-Server zu starten. Es wird w<>hrend des Bootvorgangs gestartet, wenn der dazugeh<65>rige Runlevel initialisiert wird.
Das Skript mu<6D> mit einem Parameter\index{Parameter} aufgerufen werden. M<>glich sind hier \textsl{start}, \textsl{stop}, \textsl{status}, \textsl{restart} und \textsl{reload}. Wenn falsche Parameter\index{Parameter} <20>bergeben wurden, wird eine entsprechende Meldung angezeigt.
Das Ergebnis der Ausf<73>hrung wird mit Funktionen\index{Funktion} dargestellt, die aus der Datei \texttt{/etc/rc.d/init.d/functions} stammen. Ebenfalls in dieser Datei sind Funktionen, die einen Dienst starten oder stoppen.
\begin{flushright}
Zun<EFBFBD>chst wird festgelegt, da<64> dieses Skript in der Bourne-Shell ausgef<65>hrt werden soll (\ref{auswahl_der_shell}).
\end{flushright}
\footnotesize
\begin{listing}[2]{1}
#!/bin/sh
\end{listing}
\normalsize
\begin{flushright}
Dann folgen Kommentare\index{Kommentar}, die den Sinn des Skriptes erl<72>utern (\ref{kommentare}).
\end{flushright}
\footnotesize
\begin{listingcont}
#
# Startup script for the Apache Web Server
#
# chkconfig: 345 85 15
# description: Apache is a World Wide Web server. It is \
# used to serve HTML files and CGI.
# processname: httpd
# pidfile: /var/run/httpd.pid
# config: /etc/httpd/conf/access.conf
# config: /etc/httpd/conf/httpd.conf
# config: /etc/httpd/conf/srm.conf
\end{listingcont}
\normalsize
\begin{flushright}
Jetzt wird die Datei mit den Funktionen\index{Funktion} eingebunden (\ref{source}).
\end{flushright}
\footnotesize
\index{source=\texttt{source}}
\begin{listingcont}
# Source function library.
. /etc/rc.d/init.d/functions
\end{listingcont}
\normalsize
\begin{flushright}
Hier werden die Aufrufparameter ausgewertet (\ref{case}).
\end{flushright}
\footnotesize
\index{\$n=\texttt{\$}$n$}\index{Anf<EFBFBD>hrungszeichen}\index{case=\texttt{case}}
\begin{listingcont}
# See how we were called.
case "$1" in
start)
echo -n "Starting httpd: "
\end{listingcont}
\normalsize
\begin{flushright}
Nachdem eine Meldung <20>ber den auszuf<75>hrenden Vorgang ausgegeben wurde, wird die Funktion \texttt{daemon} aus der Funktionsbibliothek ausgef<65>hrt. Diese Funktion startet das Programm, dessen Name hier als Parameter\index{Parameter} <20>bergeben wird. Dann gibt sie eine Meldung <20>ber den Erfolg aus.
\end{flushright}
\footnotesize
\begin{listingcont}
daemon httpd
echo
\end{listingcont}
\normalsize
\begin{flushright}
Jetzt wird ein Lock-File\footnote{Ein Lock-File signalisiert anderen Prozessen, da<64> ein bestimmter Proze<7A> bereits gestartet ist. So kann ein zweiter Aufruf verhindert werden.} angelegt.
\end{flushright}
\footnotesize
\index{Anf<EFBFBD>hrungszeichen}\index{touch=\texttt{touch}}
\begin{listingcont}
touch /var/lock/subsys/httpd
;;
stop)
echo -n "Shutting down http: "
\end{listingcont}
\normalsize
\begin{flushright}
Hier passiert im Prinzip das gleiche wie oben, nur da<64> mit der Funktion \texttt{killproc} der Daemon angehalten wird.
\end{flushright}
\footnotesize
\begin{listingcont}
killproc httpd
echo
\end{listingcont}
\normalsize
\begin{flushright}
Danach werden Lock-File und PID-File\footnote{In einem sogenannten PID-File hinterlegen einige Prozesse ihre Proze<7A>-ID, um anderen Programmen den Zugriff zu erleichtern (z. B. um den Proze<7A> anzuhalten etc).} gel<65>scht.
\end{flushright}
\footnotesize
\begin{listingcont}
rm -f /var/lock/subsys/httpd
rm -f /var/run/httpd.pid
;;
status)
\end{listingcont}
\normalsize
\begin{flushright}
Die Funktion \texttt{status} stellt fest, ob der entsprechende Daemon bereits l<>uft, und gibt das Ergebnis aus.
\end{flushright}
\footnotesize
\begin{listingcont}
status httpd
;;
restart)
\end{listingcont}
\normalsize
\begin{flushright}
Bei Aufruf mit dem Parameter\index{Parameter} \textsl{restart} ruft sich das Skript zwei mal selbst auf (in \texttt{\$0} steht der Aufrufname des laufenden Programms). Einmal, um den Daemon zu stoppen, dann, um ihn wieder zu starten.
\end{flushright}
\footnotesize
\index{\$n=\texttt{\$}$n$}\index{Anf<EFBFBD>hrungszeichen}
\begin{listingcont}
$0 stop
$0 start
;;
reload)
echo -n "Reloading httpd: "
\end{listingcont}
\normalsize
\begin{flushright}
Hier sendet die \texttt{killproc}-Funktion dem Daemon ein Signal\index{Signal} das ihm sagt, da<64> er seine Konfiguration neu einlesen soll.
\end{flushright}
\footnotesize
\index{\$n=\texttt{\$}$n$}\index{Anf<EFBFBD>hrungszeichen}
\begin{listingcont}
killproc httpd -HUP
echo
;;
*)
echo "Usage: $0 {start|stop|restart|reload|status}"
\end{listingcont}
\normalsize
\begin{flushright}
Bei aufruf mit einem beliebigen anderen Parameter\index{Parameter} wird eine Kurzhilfe ausgegeben. Dann wird daf<61>r gesorgt, da<64> das Skript mit dem Exit-Code 1 beendet wird. So kann festgestellt werden, ob das Skript ordnungsgem<65><6D> beendet wurde (\ref{exit}).
\end{flushright}
\footnotesize
\index{exit=\texttt{exit}}
\begin{listingcont}
exit 1
esac
exit 0
\end{listingcont}
\normalsize
\section{Parameter<EFBFBD>bergabe in der Praxis}\label{beisp_parameter}\index{Parameter}
Es kommt in der Praxis sehr oft vor, da<64> man ein Skript schreibt, dem derAnwender Parameter\index{Parameter} <20>bergeben soll. Wenn das nur eine Kleinigkeit ist (zum Beispiel ein Dateiname), dann fragt man einfach die entsprechenden vordefinierten Variablen (\ref{vordefinierte_variablen}) ab. Sollen aber `richtige' Parameter\index{Parameter} eingesetzt werden, die sich so einsetzen lassen wie man es von vielen Kommandozeilentools gewohnt ist, dann benutzt man das Hilfsprogramm \texttt{getopt}\label{getopt}\index{getopt=\texttt{getopt}}. Dieses Programm parst die originalen Parameter\index{Parameter} und gibt sie in `standardisierter' Form zur<75>ck.
Das soll an folgendem Skript verdeutlicht werden. Das Skript kennt die Optionen \texttt{-a} und \texttt{-b}. Letzterer Option mu<6D> ein zus<75>tzlicher Wert mitgegeben werden. Alle anderen Parameter\index{Parameter} werden als Dateinamen interpretiert.
\footnotesize
\index{\$@=\texttt{\$@}}\index{Anf<EFBFBD>hrungszeichen}\index{Backticks}\index{!|!|=\texttt{!|!|}}\index{getopt=\texttt{getopt}}\index{OR}\index{set=\texttt{set}}
\begin{listing}[2]{1}
#!/bin/sh
set -- `getopt "ab:" "$@"` || {
\end{listing}
\normalsize
\begin{flushright}
Das \texttt{set}\index{set=\texttt{set}}-Kommando belegt den Inhalt der vordefinierten Variablen (\ref{vordefinierte_variablen}) neu, so da<64> es aussieht, als ob dem Skript die R<>ckgabewerte von \texttt{getopt}\index{getopt=\texttt{getopt}} <20>bergeben wurden. Man mu<6D> die beiden Minuszeichen angeben, da sie daf<61>r sorgen, da<64> die Aufrufparameter an \texttt{getopt}\index{getopt=\texttt{getopt}} und nicht an die Shell selbst <20>bergeben werden. Die originalen Parameter\index{Parameter} werden von \texttt{getopt}\index{getopt=\texttt{getopt}} untersucht und modifiziert zur<75>ckgegeben: \texttt{a} und \texttt{b} werden als Parameter\index{Parameter} Markiert, \texttt{b} sogar mit der M<>glichkeit einer zus<75>tzlichen Angabe.
Wenn dieses Kommando fehlschl<68>gt ist das ein Zeichen daf<61>r, da<64> falsche Parameter\index{Parameter} <20>bergeben wurden. Also wird nach einer entsprechenden Meldung das Programm mit Exit-Code 1 verlassen.
\end{flushright}
\footnotesize
\index{\$n=\texttt{\$}$n$}\index{Null-Befehl}\index{!>\&=\texttt{!>\&}}\index{!==\texttt{!=}}\index{Anf<EFBFBD>hrungszeichen}\index{Backticks}\index{basename=\texttt{basename}}
\begin{listingcont}
echo "Anwendung: `basename $0` [-a] [-b Name] Dateien" 1>&2
exit 1
}
echo "Momentan steht in der Kommandozeile folgendes: $*"
aflag=0 name=NONE
while :
do
\end{listingcont}
\normalsize
\begin{flushright}
In einer Endlosschleife\index{Endlosschleife}, die man mit Hilfe des Null-Befehls (\texttt{:}, \ref{null-befehl}) baut, werden die `neuen' Parameter\index{Parameter} der Reihe nach untersucht. Wenn ein \texttt{-a} vorkommt, wird die Variable \texttt{aflag} gesetzt. Bei einem \texttt{-b} werden per \texttt{shift}\index{shift=\texttt{shift}} alle Parameter\index{Parameter} nach Links verschoben, dann wird der Inhalt des n<>chsten Parameters\index{Parameter} in der Variablen \texttt{name} gesichert.
\end{flushright}
\footnotesize
\index{!==\texttt{!=}}\index{\$n=\texttt{\$}$n$}\index{Anf<EFBFBD>hrungszeichen}\index{case=\texttt{case}}\index{shift=\texttt{shift}}
\begin{listingcont}
case "$1" in
-a) aflag=1 ;;
-b) shift; name="$1" ;;
--) break ;;
\end{listingcont}
\normalsize
\begin{flushright}
Wenn ein \texttt{-{}-} erscheint, ist das ein Hinweis darauf, da<64> die Liste der Parameter\index{Parameter} abgearbeitet ist. Dann wird per \texttt{break}\index{break=\texttt{break}} (\ref{break}) die Endlosschleife unterbrochen. Die Aufrufparameter enthalten jetzt nur noch die eventuell angegebenen Dateinamen, die jetzt von dem Restlichen Skript wie gewohnt weiterverarbeitet werden k<>nnen.
\end{flushright}
\footnotesize
\index{shift=\texttt{shift}}
\begin{listingcont}
esac
shift
done
shift
\end{listingcont}
\normalsize
\begin{flushright}
Am Ende werden die Feststellungen ausgegeben.
\end{flushright}
\footnotesize
\index{\$*=\texttt{\$*}}\index{Anf<EFBFBD>hrungszeichen}
\begin{listingcont}
echo "aflag=$aflag / Name = $name / Die Dateien sind $*"
\end{listingcont}
\normalsize
\section{Fallensteller: Auf Traps
reagieren}\label{traps}\index{trap=\texttt{trap}|(}\index{Signal|(}
Ein laufendes Shell-Skript kann durch Druck auf die Interrupt-Taste (normalerweise \Ovalbox{CTRL}-\Ovalbox{C}) unterbrochen werden. Durch Druck auf diese Taste wird ein Signal an den entsprechenden Proze<7A> gesandt, das ihn bittet sich zu beenden. Dieses Signal hei<65>t SIGINT (f<>r SIGnal INTerrupt) und tr<74>gt die Nummer 2. Das kann ein kleines Problem darstellen, wenn das Skript sich tempor<6F>re Dateien angelegt hat, da diese nach der Ausf<73>hrung nur noch unn<6E>tig Platz verbrauchen und eigentlich gel<65>scht werden sollten. Man kann sich sicher auch noch wichtigere F<>lle vorstellen, in denen ein Skript bestimmte Aufgaben auf jeden Fall erledigen mu<6D>, bevor es sich beendet.
Es gibt eine Reihe weiterer Signale, auf die ein Skript reagieren kann. Alle sind in der Man-Page von \texttt{signal} beschrieben. Hier die wichtigsten:\nopagebreak
\LTXtable{\textwidth}{tab_signale.tex}
Wie l<>st man jetzt dieses Problem? Gl<47>cklicherweise verf<72>gt die Shell <20>ber das \texttt{trap}-Kommando, mit dessen Hilfe man auf diese Signale reagieren kann. Die Anwendung soll in folgendem Skript beispielhaft dargestellt werden.
Das Skript soll eine komprimierte Textdatei mittels \texttt{zcat} in ein tempor<6F>res File entpacken, dieses mit \texttt{pg} seitenweise anzeigen und nachher wieder l<>schen.
\footnotesize
\index{!==\texttt{!=}}
\begin{listing}[2]{1}
#!/bin/sh
stat=1
temp=/tmp/zeige$$
\end{listing}
\normalsize
\begin{flushright}
Zun<EFBFBD>chst werden zwei Variablen belegt, die im weiteren Verlauf benutzt werden sollen. In \texttt{stat} wird der Wert abgelegt, den das Skript im Falle eines Abbruchs als Exit-Status zur<75>ckliefern soll. Die Variable \texttt{temp} enth<74>lt den Namen f<>r eine tempor<6F>re Datei. Dieser setzt sich zusammen aus \texttt{/tmp/zeige} und der Proze<7A>nummer des laufenden Skripts. So soll sichergestellt werden, da<64> noch keine Datei mit diesem Namen existiert.
\end{flushright}
\footnotesize
\index{Ticks}\index{!>\&=\texttt{!>\&}}\index{\$n=\texttt{\$}$n$}\index{Ticks}\index{Anf<EFBFBD>hrungszeichen}\index{Backticks}\index{basename=\texttt{basename}}
\begin{listingcont}
trap 'rm -f $temp; exit $stat' 0
trap 'echo "`basename $0`: Ooops..." 1>&2' 1 2 15
\end{listingcont}
\normalsize
\begin{flushright}
Hier werden die Traps definiert. Bei Signal 0 wird die tempor<6F>re Datei gel<65>scht und der Wert aus der Variable \texttt{stat} als Exit-Code zur<75>ckgegeben. Dabei wird dem \texttt{rm}-Kommando der Parameter\index{Parameter} \texttt{-f} mitgegeben, damit keine Fehlermeldung ausgegeben wird, falls die Datei (noch) nicht existiert. Dieser Fall tritt bei jedem Beenden des Skriptes auf, also sowohl bei einem normalen Ende, als auch beim Exit-Kommando, bei einem Interrupt oder bei einem Kill\index{kill=\texttt{kill}}. Der zweite Trap reagiert auf die Signale 1, 2 und 15. Das hei<65>t, er wird bei jedem unnormalen Ende ausgef<65>hrt. Er gibt eine entsprechende Meldung auf die Standard-Fehlerausgabe (\ref{datenstrom}) aus. Danach wird das Skript beendet, und der erste Trap wird ausgef<65>hrt.
\end{flushright}
\footnotesize
\index{\$\#=\texttt{\$\#}}\index{!==\texttt{!=}}\index{!>=\texttt{!>}}\index{\$n=\texttt{\$}$n$}\index{Anf<EFBFBD>hrungszeichen}\index{case=\texttt{case}}
\begin{listingcont}
case $# in
1) zcat "$1" > $temp
pg $temp
stat=0
;;
\end{listingcont}
\normalsize
\begin{flushright}
Jetzt kommt die eigentliche Funktionalit<69>t des Skriptes: Das \texttt{case}-Kommando (\ref{case}) testet die Anzahl der <20>bergebenen Parameter\index{Parameter}. Wenn genau ein Parameter\index{Parameter} <20>bergeben wurde, entpackt \texttt{zcat} die Datei, die im ersten Parameter\index{Parameter} angegeben wurde, in die tempor<6F>re Datei. Dann folgt die Seitenweise Ausgabe mittels \texttt{pg}. Nach Beendigung der Ausgabe wird der Status in der Variablen auf 0 gesetzt, damit beim Skriptende der korrekte Exit-Code zur<75>ckgegeben wird.
\end{flushright}
\footnotesize
\index{!>\&=\texttt{!>\&}}\index{\$n=\texttt{\$}$n$}\index{Anf<EFBFBD>hrungszeichen}\index{Backticks}\index{basename=\texttt{basename}}
\begin{listingcont}
*) echo "Anwendung: `basename $0` Dateiname" 1>&2
esac
\end{listingcont}
\normalsize
\begin{flushright}
Wenn \texttt{case} eine andere Parameterzahl feststellt, wird eine Meldung mit der Aufrufsyntax auf die Standard-Fehlerausgabe geschrieben.
\end{flushright}
\index{trap=\texttt{trap}|)}\index{Signal|)}

10
quellen.tex Normal file
View File

@ -0,0 +1,10 @@
\chapter{Quellen}
\begin{itemize}
\item Bash Reference Manual (\texttt{http://www.gnu.org/manual/bash-2.02/\\bashref.html})
\item Unix In A Nutshell (\texttt{http://www.oreilly.com/catalog/unixnut3/})
\item Unix Power Tools (\texttt{http://www.oreilly.com/catalog/upt2/})
\item Von DOS nach Linux HOWTO (\texttt{http://www.tu-harburg.de/\\\~{}semb2204/dlhp/HOWTO/DE-DOS-nach-Linux-HOWTO.html})
\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}

34
rene.ist Normal file
View File

@ -0,0 +1,34 @@
% [rene.ist] 23.02.97 R.Scholz <mrz@informatik.uni-jena.de>
%
% Style-Datei f<>r makeindex.
% Aufruf: makeindex [-c] -g -s rene[.ist] tex-file
actual '=' % = statt @
quote '!' % ! statt "
level '>' % > statt !
preamble
"\n \\begin{theindex}\n"
postamble
"\n\n \\end{theindex}\n"
item_x1 "\\hspace{\\stretch{2}} \n \\subitem "
item_x2 "\\hspace{\\stretch{2}} \n \\subsubitem "
delim_0 "\\dotfill "
delim_1 "\\dotfill "
delim_2 "\\dotfill "
suffix_2p "f."
suffix_3p "ff."
% The next lines will produce some warnings when
% running Makeindex as they try to cover two different
% versions of the program:
%lethead_prefix "{\\bfseries\\hfil "
%lethead_suffix "\\hfil}\\nopagebreak\n"
%lethead_flag 0
heading_prefix "{\\bfseries\\hfil " % vor Buchstabe einf<6E>gen
heading_suffix "\\hfil}\\nopagebreak\n" % nach Buchstabe einf<6E>gen
headings_flag 1 % <20>berschriften ein (Gro<72>buchstaben)
symhead_positive "Symbole"
numhead_positive "Zahlen"

51
schmutzige_tricks.tex Normal file
View File

@ -0,0 +1,51 @@
\chapter{Schmutzige Tricks :-)}
Eigentlich sind diese Tricks gar nicht so schmutzig. Hier ist lediglich eine
Sammlung von Beispielen, die genial einfach oder genial gut programmiert sind.
Das bedeutet nicht, da<64> jeder Shell-Programmierer diese Techniken benutzen
sollte. Ganz im Gegenteil. Einige Mechanismen bergen Gefahren, die nicht auf
den ersten Blick erkennbar sind.
Mit anderen Worten: \textbf{Wenn Du diese Techniken nicht verstehst, dann
benutze sie nicht!}
Die Intention hinter diesem Abschnitt ist es, dem gelangweilten Skripter etwas
interessantes zum Lesen zu geben. Das inspiriert dann vielleicht dazu, doch
einmal in den fortgeschrittenen Bereich vorzusto<74>en, neue Techniken
kennenzulernen. Au<41>erdem kann das Wissen <20>ber gewisse Techniken eine gro<72>e
Hilfe beim Lesen fremder Skripte darstellen, die eventuell von diesen Techniken
Gebrauch machen.
Diese Techniken sind nicht `auf meinem Mist gewachsen', sie stammen vielmehr
aus Skripten, die mir im Laufe der Zeit in die Finger gekommen sind. Ich danke
an dieser Stelle den klugen K<>pfen, die sich solche Sachen einfallen lassen
haben.
\section{Die Tar-Br<42>cke}
TODO!!!
\section{Binaries inside}
TODO!!!
\subsection{Bin<EFBFBD>re Here-Dokumente}
TODO!!!
\subsection{Schwanz ab!}
TODO!!!
\section{Dateien, die es nicht gibt}
TODO!!!
\subsection{Speichern in nicht existente Dateien}
TODO!!!
\subsection{Daten aus einer Subshell hochreichen}
TODO!!!

156
shell.tex Normal file
View File

@ -0,0 +1,156 @@
%==============================================================================
% LaTeX-Schema-Datei schema.tex
%==============================================================================
%==============================================================================
% Vorspann
%==============================================================================
\newif\ifpdf % Feststellen, ob wir PDF oder DVI
% erzeugen
\ifx\pdfoutput\undefined
\pdffalse % Wir haben kein PDFLaTeX
\else
\pdftrue % Wir haben PDFLaTeX
\fi
\ifpdf % PDF-Einstellungen
\pdfoutput=1
\pdfcompresslevel=9
\pdfinfo{
/Author (Ronald Schaten)
/CreationDate (D:20000301170300) % (D:YYYYMMDDhhmmss)
% /ModDate (D:19980212201000) % ModDate is similar
/Title (Shell-Programmierung)
/Subject (Shell-Programmierung)
/Keywords (Shell)
}
\pdfcatalog{ % Catalog dictionary of PDF output.
/PageMode /UseOutlines
/URI (http://www.fi.muni.cz/)
}
\else % Nicht-PDF-Einstellungen
\fi
% Dokumentstil f<>r Buch
\documentclass[a4paper,12pt,draft,twoside]{book}
\usepackage{german} % deutsches Paket f<>r Umlaute
%\usepackage{t1enc} % DC-Font mit 8 Bit verwenden
\usepackage[latin1]{inputenc} % Codepage latin1
%\usepackage{graphicx} % Grafikpaket f<>r Bilder laden
%\DeclareGraphicsRule{.tif}{bmp}{}{} % Grafikformate
\usepackage{tabularx} % f<>r Tabellen <20>ber die Seitenbreite
\usepackage{longtable} % f<>r Tabellen <20>ber die Seitenbreite
\usepackage{supertabular} % f<>r Tabellen <20>ber die Seitenbreite
\usepackage{ltxtable} % f<>r Tabellen <20>ber die Seitenbreite
\ifpdf % PDF-Einstellungen
\usepackage{thumbpdf}
\else % Nicht-PDF-Einstellungen
\fi
\usepackage{makeidx} % Index wird sp<73>ter eingef<65>gt
\makeindex % durch \printindex
\usepackage{tocbibind} % TOC, Index etc. kommt in die TOC
\usepackage{fancybox} % K<>stchen f<>r Tastendarstellung
\usepackage{fancyhdr} % Kopf- und Fu<46>zeilen
\pagestyle{fancy}
\renewcommand{\chaptermark}[1]{\markboth{#1}{}}
\renewcommand{\sectionmark}[1]{\markright{\thesection\ #1}}
\fancyhf{}
\fancyhead[RE]{\bfseries\leftmark}
\fancyhead[LO]{\bfseries\rightmark}
\fancyhead[RO,LE]{\bfseries\thepage}
\renewcommand{\headrulewidth}{0.5pt}
\addtolength{\headheight}{2.5pt}
\fancypagestyle{plain}{
\fancyhead{}
\renewcommand{\headrulewidth}{0pt}
\fancyfoot[C]{\bfseries\thepage}
}
\usepackage{moreverb} % F<>r Listings
\newcommand{\STRUT}{\rule{0in}{3ex}} % Ein vertikaler Abstand f<>r Tabellen
\clubpenalty=10000 % gegen Schusterjungen
\widowpenalty=10000 % gegen Hurenkinder
%==============================================================================
% Anfang des Dokuments
%==============================================================================
\begin{document} % hiermit mu<6D> jedes Dokument beginnen
\vspace*{.75in} % Die Titelseite
\thispagestyle{empty}
\begin{centering}
\rule{5in}{.04in}\\ \vspace{.25in}
\Huge {\bf SHELL\\ \vspace{.4in} PROGRAMMIERUNG}\\ \vspace{.1in}
\rule{5in}{.04in}\\ \vspace{.5in}
\large \today\\ \vspace{.75in}
\large von\\ \vspace{.3in}
\LARGE {\bf Ronald Schaten} \\ \vspace{.6in}
\large ronald@schatenseite.de\\
\large http://www.schatenseite.de/\\
\end{centering}
\newpage
\thispagestyle{empty} % eine Leerseite
~\vfill
\footnotesize
Copyright \copyright{} 2001 Ronald Schaten (\texttt{ronald@schatenseite.de})\bigskip
Die aktuellste Version dieses Dokumentes befindet sich im World Wide Web auf meiner Homepage (\texttt{http://www.schatenseite.de/}).\bigskip
Dieses Dokument ist entstanden, weil ich f<>r mich selbst eine kompakte <20>bersicht zu diesem Thema haben wollte. Ich beabsichtige nicht, damit in irgendeiner Form Kommerz zu machen. Ich stelle es frei zur Verf<72>gung, in der 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 weitergegeben werden.}\bigskip
Ich danke folgenden Personen, die mir bei der Durchsicht behilflich waren und durch ihre konstruktive Kritik zu Verbesserungen beigetragen haben (in chronologischer Reihenfolge ihres Eingreifens):
\begin{list}{$\bullet$}{\itemsep=-0.5cm}
\item J<>rgen Ilse (\texttt{ilse@asys-h.de})\\
\item Christian Perle (\texttt{christian.perle@tu-clausthal.de})\\
\item Andreas Metzler (\texttt{ametzler@downhill.at.eu.org})\\
\item Johannes Kolb (\texttt{johannes.kolb@web.de})\\
\end{list}
Und ich bitte alle Leser, auf eventuelle Fehler zu achten und mich darauf aufmerksam zu machen. Auch abgesehen davon freue ich mich <20>ber jede R<>ckmeldung.
\normalsize
\newpage
\pagenumbering{roman}
\renewcommand{\headrulewidth}{0.5pt}
\setcounter{tocdepth}{3}
\tableofcontents
\newpage
\pagenumbering{arabic}
% Haupttextteil
\include{was_ist_die_shell}
\include{wofuer_shell_programmierung}
\include{wie_sieht_ein_shell_skript_aus}
\include{nuetzliche_shell-kommandos}
\include{wo_sind_unterschiede_zu_dos_batchdateien}
\appendix
\include{beispiele}
\include{schmutzige_tricks}
\include{quellen}
\printindex % Index einf<6E>gen
%==============================================================================
% Ende des Dokuments
%==============================================================================
\end{document}
\ifpdf % PDF-Einstellungen
\bye
\else % Nicht-PDF-Einstellungen
\fi
%==============================================================================
% Ende von schema.tex
%==============================================================================

24
tab_bedingungen_dateitests.tex Normal file
View File

@ -0,0 +1,24 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{-b }\textsl{Datei} & Die \textsl{Datei} existiert und ist ein blockorientiertes Ger<65>t \tabularnewline\STRUT
\texttt{-c }\textsl{Datei} & Die \textsl{Datei} existiert und ist ein zeichenorientiertes Ger<65>t \tabularnewline\STRUT
\texttt{-d }\textsl{Datei} & Die \textsl{Datei} existiert und ist ein Verzeichnis \tabularnewline\STRUT
\texttt{-f }\textsl{Datei} & Die \textsl{Datei} existiert und ist eine regul<75>re Datei \tabularnewline\STRUT
\texttt{-g }\textsl{Datei} & Die \textsl{Datei} existiert, und das Gruppen-ID-Bit\index{Gruppen-ID-Bit} ist gesetzt \tabularnewline\STRUT
\texttt{-h }\textsl{Datei} & Die \textsl{Datei} existiert und ist ein symbolischer Link\index{Link} \tabularnewline\STRUT
\texttt{-k }\textsl{Datei} & Die \textsl{Datei} existiert, und das Sticky-Bit\index{Sticky-Bit} ist gesetzt \tabularnewline\STRUT
\texttt{-p }\textsl{Datei} & Die \textsl{Datei} existiert und ist eine Named Pipe \tabularnewline\STRUT
\texttt{-r }\textsl{Datei} & Die \textsl{Datei} existiert und ist lesbar \tabularnewline\STRUT
\texttt{-s }\textsl{Datei} & Die \textsl{Datei} existiert und ist nicht leer \tabularnewline\STRUT
\texttt{-t }\textsl{[n]} & Der offene Dateideskriptor\index{Dateideskriptor} \textsl{n} geh<65>rt zu einem Terminal; Vorgabe f<>r \textsl{n} ist 1. \tabularnewline\STRUT
\texttt{-u }\textsl{Datei} & Die \textsl{Datei} existiert und das Setuid-Bit\index{Setuid-Bit} ist gesetzt \tabularnewline\STRUT
\texttt{-w }\textsl{Datei} & Die \textsl{Datei} existiert und ist beschreibbar \tabularnewline\STRUT
\texttt{-x }\textsl{Datei} & Die \textsl{Datei} existiert und ist ausf<73>hrbar
\end{longtable}

16
tab_bedingungen_ganzzahlvergleiche.tex Normal file
View File

@ -0,0 +1,16 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\textsl{n1}\texttt{ -eq }\textsl{n2} & \textsl{n1} ist gleich \textsl{n2} \tabularnewline\STRUT
\textsl{n1}\texttt{ -ge }\textsl{n2} & \textsl{n1} ist gr<67><72>er oder gleich \textsl{n2} \tabularnewline\STRUT
\textsl{n1}\texttt{ -gt }\textsl{n2} & \textsl{n1} ist gr<67><72>er als \textsl{n2} \tabularnewline\STRUT
\textsl{n1}\texttt{ -le }\textsl{n2} & \textsl{n1} ist kleiner oder gleich \textsl{n2} \tabularnewline\STRUT
\textsl{n1}\texttt{ -lt }\textsl{n2} & \textsl{n1} ist kleiner \textsl{n2} \tabularnewline\STRUT
\textsl{n1}\texttt{ -ne }\textsl{n2} & \textsl{n1} ist ungleich \textsl{n2}
\end{longtable}

14
tab_bedingungen_kombinationen.tex Normal file
View File

@ -0,0 +1,14 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{(}\textsl{Bedingung}\texttt{)}\index{( )=\texttt{( )}|textbf} & Wahr, wenn die \textsl{Bedingung} zutrifft (wird f<>r die Gruppierung verwendet). Den Klammern mu<6D> ein \texttt{\textbackslash} vorangestellt werden. \tabularnewline\STRUT
\texttt{! }\textsl{Bedingung}\index{!!=\texttt{!!}|textbf} & Wahr, wenn die \textsl{Bedingung} nicht zutrifft (NOT\index{NOT}\index{Negation|see{NOT}}). \tabularnewline\STRUT
\textsl{Bedingung1}\texttt{ -a }\textsl{Bedingung2} & Wahr, wenn beide Bedingungen zutreffen (AND\index{AND}\index{Und-Verkn<6B>pfung|see{AND}}). \tabularnewline\STRUT
\textsl{Bedingung1}\texttt{ -o }\textsl{Bedingung2} & Wahr, wenn eine der beiden Bedingungen zutrifft (OR\index{OR}\index{Oder-Verkn<6B>pfung|see{OR}}).
\end{longtable}

15
tab_bedingungen_zeichenfolgen.tex Normal file
View File

@ -0,0 +1,15 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{-n }\textsl{s1} & Die L<>nge der Zeichenfolge \textsl{s1} ist ungleich Null \tabularnewline\STRUT
\texttt{-z }\textsl{s1} & Die L<>nge der Zeichenfolge \textsl{s1} ist gleich Null \tabularnewline\STRUT
\textsl{s1}\texttt{ = }\textsl{s2}\index{!==\texttt{!=}} & Die Zeichenfolgen \textsl{s1} und \textsl{s2} sind identisch \tabularnewline\STRUT
\textsl{s1}\texttt{ != }\textsl{s2}\index{!!!==\texttt{!!!=}|textbf} & Die Zeichenfolgen \textsl{s1} und \textsl{s2} sind \textsl{nicht} identisch \tabularnewline\STRUT
\textsl{Zeichenfolge} & Die \textsl{Zeichenfolge} ist nicht Null
\end{longtable}

18
tab_befehlsformen.tex Normal file
View File

@ -0,0 +1,18 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\textsl{Befehl}\texttt{ \&} & Ausf<73>hrung von \textsl{Befehl} im Hintergrund \tabularnewline\STRUT
\textsl{Befehl1}\texttt{ ; }\textsl{Befehl2} & Befehlsfolge, f<>hrt mehrere Befehle nacheinander aus \tabularnewline\STRUT
\texttt{(}\textsl{Befehl1}\texttt{ ; }\textsl{Befehl2}\texttt{)} & Subshell\index{Subshell}, behandelt \textsl{Befehl1} und \textsl{Befehl2} als Befehlsblock und f<>hrt sie in einer Subshell aus \tabularnewline\STRUT
\texttt{\{ }\textsl{Befehl1}\texttt{ ; }\textsl{Befehl2}\texttt{ \}} & Befehlsblock; alle Befehle werden in der momentanen Shell ausgef<65>hrt, aber die Ausgaben werden behandelt, als ob nur ein Befehl ausgef<65>hrt w<>rde \tabularnewline\STRUT
\textsl{Befehl1}\texttt{ | }\textsl{Befehl2} & Pipe\index{Pipe}, verwendet die Ausgabe von \textsl{Befehl1} als Eingabe f<>r \textsl{Befehl2} \tabularnewline\STRUT
\textsl{Befehl1}\texttt{ `}\textsl{Befehl2}\texttt{`} & Befehls-Substitution, verwendet die Ausgabe von \textsl{Befehl2} als Argumente\index{Parameter}\index{Argument|see{Parameter}} f<>r \textsl{Befehl1} \tabularnewline\STRUT
\textsl{Befehl1}\texttt{ \&\& }\textsl{Befehl2} & AND\index{AND}, f<>hrt zuerst \textsl{Befehl1} und dann (wenn \textsl{Befehl1} erfolgreich war) \textsl{Befehl2} aus\footnote{Einen <20>hnlichen Mechanismus kennt man aus verschiedenen Programmiersprachen unter dem Begriff \textsl{Kurzschlu<EFBFBD>auswertung}\index{Kurzschlu<EFBFBD>auswertung} bzw. \textsl{lazy evaluation}\index{Lazy Evaluation|see{Kurzschlu<EFBFBD>auswertung}}.} \tabularnewline\STRUT
\textsl{Befehl1}\texttt{ || }\textsl{Befehl2} & OR\index{OR}, entweder \textsl{Befehl1} ausf<73>hren oder \textsl{Befehl2} (Wenn \textsl{Befehl1} nicht erfolgreich war)
\end{longtable}

16
tab_beisp_bedingungen.tex Normal file
View File

@ -0,0 +1,16 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{while test \$\# -gt 0}\index{\$\#=\texttt{\$\#}} & Solange Argumente\index{Parameter} vorliegen\ldots \tabularnewline\STRUT
\texttt{while [ -n \dq\$1\dq~]}\index{\$n=\texttt{\$}$n$} & Solange das erste Argument\index{Parameter} nicht leer ist\ldots\index{Anf<EFBFBD>hrungszeichen} \tabularnewline\STRUT
\texttt{if [ \$count -lt 10 ]} & Wenn \texttt{\$count} kleiner 10\ldots \tabularnewline\STRUT
\texttt{if [ -d RCS ]} & Wenn ein Verzeichnis RCS existiert\ldots \tabularnewline\STRUT
\texttt{if [ \dq\$Antwort\dq~!= \dq j\dq~]}\index{!!!==\texttt{!!!=}} & Wenn die Antwort nicht \dq j\dq~ ist\ldots\index{Anf<EFBFBD>hrungszeichen} \tabularnewline\STRUT
\texttt{if [ ! -r \dq\$1\dq~-o ! -f \dq\$1\dq~]}\index{!!=\texttt{!!}}\index{\$n=\texttt{\$}$n$} & Wenn das erste Argument\index{Parameter} keine lesbare oder regul<75>re Datei ist\ldots\index{Anf<EFBFBD>hrungszeichen}
\end{longtable}

18
tab_beisp_befehlsformen.tex Normal file
View File

@ -0,0 +1,18 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{\$ nroff }\textsl{Datei}\texttt{ \&} & Formatiert die \textsl{Datei} im Hintergrund \tabularnewline\STRUT
\texttt{\$ cd; ls} & Sequentieller Ablauf \tabularnewline\STRUT
\texttt{\$ (date; who; pwd) > logfile}\index{!>=\texttt{!>}} & F<>hrt die Befehle in einer Subshell\index{Subshell} aus und lenkt alle Ausgaben um \tabularnewline\STRUT
\texttt{\$ \{ date; who; pwd \} > logfile}\index{!>=\texttt{!>}} & Lenkt alle Ausgaben um \tabularnewline\STRUT
\texttt{\$ sort }\textsl{Datei}\texttt{ | lp} & Sortiert die \textsl{Datei} und druckt sie\index{sort=\texttt{sort}} \tabularnewline\STRUT
\texttt{\$ vi `grep -l ifdef *.c`}\index{*=\texttt{*}}\index{grep=\texttt{grep}} & Editiert die mittels grep gefundenen Dateien \tabularnewline\STRUT
\texttt{\$ grep }\textsl{XX Datei}\texttt{ \&\& lp }\textsl{Datei}\index{grep=\texttt{grep}} & Druckt die \textsl{Datei}, wenn sie \textsl{XX} enth<74>lt\index{AND} \tabularnewline\STRUT
\texttt{\$ grep }\textsl{XX Datei}\texttt{ || lp }\textsl{Datei}\index{grep=\texttt{grep}} & Druckt die \textsl{Datei}, wenn sie \textsl{XX} nicht enth<74>lt\index{OR}
\end{longtable}

27
tab_beisp_case.tex Normal file
View File

@ -0,0 +1,27 @@
\begin{longtable}{|X l|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\multicolumn{2}{|X|}{\textsl{Mit dem ersten Argument\index{Parameter} in der Befehlszeile wird die entsprechende Aktion festgelegt:}} \\
\multicolumn{2}{|X|}{\texttt{case \$1 in~~\# nimmt das erste Argument}\index{\$n=\texttt{\$}$n$}} \\
\multicolumn{2}{|X|}{\texttt{~Ja|Nein) response=1;;}\index{!==\texttt{!=}}} \\
\multicolumn{2}{|X|}{\texttt{~~~-[tT]) table=TRUE;;}\index{!==\texttt{!=}}} \\
\multicolumn{2}{|X|}{\texttt{~~~~~~~*) echo \dq Unbekannte Option\dq; exit 1;;}} \\
\multicolumn{2}{|X|}{\texttt{esac}} \\
\multicolumn{2}{|X|}{\STRUT\textsl{Lies die Zeilen von der Standard-Eingabe\index{Standard-Eingabe}, bis eine Zeile mit einem einzelnen Punkt eingegeben wird:}} \\
\multicolumn{2}{|X|}{\texttt{while :~~\# Null-Befehl (immer wahr, siehe unter \ref{null-befehl})}\index{Null-Befehl}} \\
\multicolumn{2}{|X|}{\texttt{do}} \\
\multicolumn{2}{|X|}{\texttt{~echo \dq Zum Beenden . eingeben ==> \textbackslash c\dq}\index{Anf<EFBFBD>hrungszeichen}} \\
\multicolumn{2}{|X|}{\texttt{~read line~~\# read: Zeile von StdIn einlesen}\index{read=\texttt{read}}} \\
\multicolumn{2}{|X|}{\texttt{~case \dq\$line\dq~in}\index{Anf<EFBFBD>hrungszeichen}} \\
\multicolumn{2}{|X|}{\texttt{~~.) echo \dq Ausgefuehrt\dq}\index{Anf<EFBFBD>hrungszeichen}} \\
\multicolumn{2}{|X|}{\texttt{~~~~~break;;}} \\
\multicolumn{2}{|X|}{\texttt{~~*) echo \dq\$line\dq ;;}\index{Anf<EFBFBD>hrungszeichen}} \\
\multicolumn{2}{|X|}{\texttt{~esac}} \\
\multicolumn{2}{|X|}{\texttt{done}} \\
\end{longtable}

15
tab_beisp_datenstroeme.tex Normal file
View File

@ -0,0 +1,15 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{\$ cat }\textsl{Datei1}\texttt{ > }\textsl{Neu} & Schreibt den Inhalt der \textsl{Datei1} in die Datei \textsl{Neu}\index{cat=\texttt{cat}} \tabularnewline\STRUT
\texttt{\$ cat }\textsl{Datei2 Datei3}\texttt{ >{}> }\textsl{Neu} & H<>ngt den Inhalt der \textsl{Datei2} und der \textsl{Datei3} an die Datei \textsl{Neu} an\index{cat=\texttt{cat}} \tabularnewline\STRUT
\texttt{\$ mail }\textsl{name}\texttt{ < }\textsl{Neu} & Das Programm \texttt{mail} liest den Inhalt der Datei \textsl{Neu} \tabularnewline\STRUT
\texttt{\$ ls -l | grep }\textsl{\dq txt\dq}\texttt{ | sort } & Die Ausgabe des Befehls \texttt{ls -l} (Verzeichnisinhalt) wird an das Kommando \texttt{grep} weitergegeben, das darin nach \textsl{\dq txt\dq} sucht. Alle Zeilen die das Muster\index{Mustererkennung} enthalten werden anschlie<69>end an \texttt{sort} <20>bergeben und landen dann sortiert auf der Standard-Ausgabe.\index{grep=\texttt{grep}}\index{sort=\texttt{sort}} \tabularnewline\STRUT
\texttt{\$ grep }\textsl{\dq txt\dq}\texttt{ * 2>\&1 | less } & In allen Dateien wird nach \textsl{\dq txt\dq} gesucht. Wenn dabei Fehler auftreten (weil z. B. auch Verzeichnisse im aktuellen Verzeichnis sind), werden die Fehlermeldungen an \texttt{less} weitergegeben. Dort werden sie dann seitenweise ausgegeben.\index{grep=\texttt{grep}}\index{less=\texttt{less}}
\end{longtable}

12
tab_beisp_datenstroeme_cdparanoia.tex Normal file
View File

@ -0,0 +1,12 @@
\begin{longtable}{|X l|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\multicolumn{2}{|X|}{\texttt{cdrdao read-toc -{}-datafile - cd.toc}} \\
\multicolumn{2}{|X|}{\texttt{cdparanoia -q -R 1- - | cdrdao write -{}-buffers 64 cd.toc}} \\
\end{longtable}

16
tab_beisp_datenstroeme_here-dokument.tex Normal file
View File

@ -0,0 +1,16 @@
\begin{longtable}{|X l|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\multicolumn{2}{|X|}{\texttt{cat << }\textsl{EOF}} \\
\multicolumn{2}{|X|}{~~~Dieser Text wird zeilenweise ausgegeben,} \\
\multicolumn{2}{|X|}{~~~bis ein einzelnes EOF kommt.} \\
\multicolumn{2}{|X|}{\textsl{EOF}} \\
\hline
\multicolumn{2}{|X|}{Ein Here-Dokument: Nach dem \texttt{ << } wird ein sogenannter Delimiter angegeben. Alle folgenden Zeilen werden an die Standard-Eingabe von \texttt{cat} <20>bergeben. Der Text wird durch ein erneutes Vorkommen des Delimiters (einzeln und am Zeilenanfang) beendet.\index{cat=\texttt{cat}}} \\
\end{longtable}

17
tab_beisp_exitcode.tex Normal file
View File

@ -0,0 +1,17 @@
\begin{longtable}{|X l|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\multicolumn{2}{|X|}{\texttt{\$ cp datei /tmp}} \\
\multicolumn{2}{|X|}{\texttt{\$ echo \$?}} \\
\multicolumn{2}{|X|}{\texttt{0}} \\
\multicolumn{2}{|X|}{\STRUT\texttt{\$ cp datie /tmp}} \\
\multicolumn{2}{|X|}{\texttt{cp: datie: Datei oder Verzeichnis nicht gefunden}} \\
\multicolumn{2}{|X|}{\texttt{\$ echo \$?}} \\
\multicolumn{2}{|X|}{\texttt{1}} \\
\end{longtable}

11
tab_beisp_exitcode_lpr.tex Normal file
View File

@ -0,0 +1,11 @@
\begin{longtable}{|X l|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\multicolumn{2}{|X|}{\texttt{\$ lpr datei \&\& rm datei}\index{\&\&=\texttt{\&\&}}} \\
\end{longtable}

29
tab_beisp_for.tex Normal file
View File

@ -0,0 +1,29 @@
\begin{longtable}{|X l|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\multicolumn{2}{|X|}{\textsl{Seitenweises Formatieren der Dateien, die auf der Befehlszeile angegeben wurden, und speichern des jeweiligen Ergebnisses:}} \\
\multicolumn{2}{|X|}{\texttt{for file do}} \\
\multicolumn{2}{|X|}{\texttt{~pr \$file > \$file.tmp~~\# pr: Formatiert Textdateien}\index{!>=\texttt{!>}}} \\
\multicolumn{2}{|X|}{\texttt{done}} \\
\multicolumn{2}{|X|}{\STRUT\textsl{Durchsuche Kapitel zur Erstellung einer Wortliste (wie \texttt{fgrep -f}):}} \\
\multicolumn{2}{|X|}{\texttt{for item in `cat program\_list`~~\# cat: Datei ausgeben}\index{cat=\texttt{cat}}\index{Backticks}} \\
\multicolumn{2}{|X|}{\texttt{do}} \\
\multicolumn{2}{|X|}{\texttt{~echo \dq Pruefung der Kapitel auf\dq}\index{Anf<EFBFBD>hrungszeichen}} \\
\multicolumn{2}{|X|}{\texttt{~echo \dq Referenzen zum Programm \$item ...\dq}\index{Anf<EFBFBD>hrungszeichen}} \\
\multicolumn{2}{|X|}{\texttt{~grep -c \dq\$item.[co]\dq~chap*~~\# grep: nach Muster\index{Mustererkennung} suchen}\index{[abc]=\texttt{[}\textsl{abc}\texttt{]}}\index{Anf<EFBFBD>hrungszeichen}\index{grep=\texttt{grep}}} \\
\multicolumn{2}{|X|}{\texttt{done}} \\
\multicolumn{2}{|X|}{\STRUT\textsl{Ermittle einen Ein-Wort-Titel aus jeder Datei und verwende ihn als neuen Dateinamen:}} \\
\multicolumn{2}{|X|}{\texttt{for file do}} \\
\multicolumn{2}{|X|}{\texttt{~name=`sed -n 's/NAME: //p' \$file`}\index{!==\texttt{!=}}\index{Backticks}\index{Ticks}} \\
\multicolumn{2}{|X|}{\texttt{~~~~~~~~~~\# sed: Skriptsprache zur}\index{sed=\texttt{sed}}} \\
\multicolumn{2}{|X|}{\texttt{~~~~~~~~~~\# Textformatierung}} \\
\multicolumn{2}{|X|}{\texttt{~mv \$file \$name~~\# mv: Datei verschieben}} \\
\multicolumn{2}{|X|}{\texttt{~~~~~~~~~~~~~~~~~\# bzw. umbenennen}} \\
\multicolumn{2}{|X|}{\texttt{done}} \\
\end{longtable}

16
tab_beisp_funktionen.tex Normal file
View File

@ -0,0 +1,16 @@
\begin{longtable}{|X l|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\multicolumn{2}{|X|}{\texttt{count () \{}} \\
\multicolumn{2}{|X|}{\texttt{~ls -1 | wc -l~~\# ls: Liste aller Dateien im Verzeichnis}\index{Pipe}} \\
\multicolumn{2}{|X|}{\texttt{~~~~~~~~~~~~~~~~\#~~~~~Mit Parameter -1 einspaltig}} \\
\multicolumn{2}{|X|}{\texttt{~~~~~~~~~~~~~~~~\# wc: Word-Count, z<>hlt W<>rter}\index{wc=\texttt{wc}}} \\
\multicolumn{2}{|X|}{\texttt{~~~~~~~~~~~~~~~~\#~~~~~Mit Parameter -l Zeilen}} \\
\multicolumn{2}{|X|}{\texttt{\}}} \\
\end{longtable}

16
tab_beisp_if.tex Normal file
View File

@ -0,0 +1,16 @@
\begin{longtable}{|X l|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\multicolumn{2}{|X|}{\textsl{F<EFBFBD>ge eine 0 vor Zahlen kleiner 10 ein:}} \\
\multicolumn{2}{|X|}{\texttt{if [ \$counter -lt 10 ]; then}\index{;=\texttt{;}}} \\
\multicolumn{2}{|X|}{\texttt{~number=0\$counter; else number=\$counter; fi}\index{!==\texttt{!=}}} \\
\multicolumn{2}{|X|}{\STRUT\textsl{L<EFBFBD>sche ein Verzeichnis, wenn es existiert:}} \\
\multicolumn{2}{|X|}{\texttt{if [ -d \$dir ]; then}\index{!!=\texttt{!!}}\index{;=\texttt{;}}} \\
\multicolumn{2}{|X|}{\texttt{~rmdir \$dir; fi~~\# rmdir: Verzeichnis l<>schen}} \\
\end{longtable}

13
tab_beisp_metazeichen.tex Normal file
View File

@ -0,0 +1,13 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\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
\end{longtable}

33
tab_beisp_muster.tex Normal file
View File

@ -0,0 +1,33 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{Haus} & Die Zeichenfolge \textsl{Haus}. \tabularnewline\STRUT
\texttt{\^{}Haus} & \textsl{Haus} am Zeilenanfang. \tabularnewline\STRUT
\texttt{Haus\$} & \textsl{Haus} am Zeilenende. \tabularnewline\STRUT
\texttt{\^{}Haus\$} & \textsl{Haus} als einziges Wort in einer Zeile. \tabularnewline\STRUT
\texttt{[Hh]aus} & \textsl{Haus} oder \textsl{haus}. \tabularnewline\STRUT
\texttt{Ha[unl]s} & \textsl{Haus}, \textsl{Hals} oder \textsl{Hans}. \tabularnewline\STRUT
\texttt{[\^{}HML]aus} & Weder \textsl{Haus}, noch \textsl{Maus}, noch \textsl{Laus}. Jedoch mu<6D> die Zeichenfolge \textsl{aus} enthalten sein. \tabularnewline\STRUT
\texttt{Ha.s} & Der dritte Buchstabe ist ein beliebiges Zeichen. \tabularnewline\STRUT
\texttt{\^{}...\$} & Jede Zeile mit genau drei Zeichen. \tabularnewline\STRUT
\texttt{\^{}\textbackslash.} & Jede Zeile, die mit einem Punkt beginnt. \tabularnewline\STRUT
\texttt{\^{}\textbackslash.[a-z][a-z]} & Jede Zeile, die mit einem Punkt und zwei Kleinbuchstaben\index{Kleinbuchstaben} beginnt. \tabularnewline\STRUT
\texttt{\^{}\textbackslash.[a-z]\textbackslash\{2\textbackslash\}} & Wie oben, jedoch nur in grep und sed zul<75>ssig. \tabularnewline\STRUT
\texttt{\^{}[\^{}.]} & Jede Zeile, die nicht mit einem Punkt beginnt. \tabularnewline\STRUT
\texttt{Fehler*} & \textsl{Fehle} (!), \textsl{Fehler}, \textsl{Fehlers}, etc. \tabularnewline\STRUT
\texttt{\dq Wort\dq} & Ein Wort in Anf<6E>hrungszeichen. \tabularnewline\STRUT
\texttt{\dq *Wort\dq *} & Ein Wort mit beliebig vielen (auch keinen) Anf<6E>hrungszeichen. \tabularnewline\STRUT
\texttt{[A-Z][A-Z]*} & Ein oder mehrere Gro<72>buchstaben\index{Gro<EFBFBD>buchstaben}. \tabularnewline\STRUT
\texttt{[A-Z]+} & Wie oben, jedoch nur in egrep und awk zul<75>ssig. \tabularnewline\STRUT
\texttt{[A-Z].*} & Ein Gro<72>buchstabe\index{Gro<EFBFBD>buchstaben}, gefolgt von keinem oder beliebig vielen Zeichen. \tabularnewline\STRUT
\texttt{[A-Z]*} & Kein, ein oder mehrere Gro<72>buchstaben\index{Gro<EFBFBD>buchstaben}. \tabularnewline\STRUT
\texttt{[a-zA-Z]} & Ein Buchstabe. \tabularnewline\STRUT
\texttt{[\^{}0-9a-zA-Z]} & Symbole (weder Buchstaben noch Zahlen). \tabularnewline\STRUT
\texttt{[0-9a-zA-Z]} & Jedes Alphanumerische Zeichen.
\end{longtable}

14
tab_beisp_muster_egrep.tex Normal file
View File

@ -0,0 +1,14 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{[567]} & Eine der Zahlen \textsl{5}, \textsl{6} oder \textsl{7}. \tabularnewline\STRUT
\texttt{fuenf|sechs|sieben} & Eines der Worte \textsl{fuenf}, \textsl{sechs} oder \textsl{sieben}. \tabularnewline\STRUT
\texttt{80[234]?86} & \textsl{8086}, \textsl{80286}, \textsl{80386} oder \textsl{80486}. \tabularnewline\STRUT
\texttt{F(ahr|lug)zeug} & \textsl{Fahrzeug} oder \textsl{Flugzeug}.
\end{longtable}

13
tab_beisp_muster_ex.tex Normal file
View File

@ -0,0 +1,13 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{\textbackslash<The} & W<>rter wie \textsl{Theater} oder \textsl{Thema}. \tabularnewline\STRUT
\texttt{ung\textbackslash>} & W<>rter wie \textsl{Teilung} oder \textsl{Endung}. \tabularnewline\STRUT
\texttt{\textbackslash<Wort\textbackslash>} & Das Wort \textsl{Wort}.
\end{longtable}

12
tab_beisp_muster_sed.tex Normal file
View File

@ -0,0 +1,12 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{0\textbackslash\{5,\textbackslash\}} & F<>nf oder mehr Nullen in Folge. \tabularnewline\STRUT
\texttt{[0-9]-[0-9]\textbackslash\{3\textbackslash\}-[0-9]\textbackslash\{5\textbackslash\}-[0-9X]} & ISBN-Nummern in der Form \textsl{n-nnn-nnnnn-n}, das letzte Zeichen kann auch ein X sein.
\end{longtable}

15
tab_beisp_nullbefehl.tex Normal file
View File

@ -0,0 +1,15 @@
\begin{longtable}{|X l|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\multicolumn{2}{|X|}{\texttt{if who | grep \$1 > /dev/null~~\# who: Liste der Benutzer}\index{Pipe}\index{\$n=\texttt{\$}$n$}\index{!>=\texttt{!>}}\index{who=\texttt{who}}} \\
\multicolumn{2}{|X|}{\texttt{~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\# grep: Suche nach Muster}} \\
\multicolumn{2}{|X|}{\texttt{then :~~~~~~~~~~~~~~~~~~~~~~~~\# tut nichts}} \\
\multicolumn{2}{|X|}{\texttt{~else echo \dq Benutzer \$1 ist nicht angemeldet\dq}\index{Anf<EFBFBD>hrungszeichen}} \\
\multicolumn{2}{|X|}{\texttt{fi}} \\
\end{longtable}

18
tab_beisp_quoting.tex Normal file
View File

@ -0,0 +1,18 @@
\begin{longtable}{|X l|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\multicolumn{2}{|X|}{\texttt{\$ echo 'Ticks \dq sch<63>tzen\dq~Anf<6E>hrungszeichen'}} \\
\multicolumn{2}{|X|}{\texttt{Ticks \dq sch<63>tzen\dq~Anf<6E>hrungszeichen}} \\
\multicolumn{2}{|X|}{\STRUT\texttt{\$ echo \dq Ist dies ein \textbackslash\dq Sonderfall\textbackslash\dq ?\dq}} \\
\multicolumn{2}{|X|}{\texttt{Ist dies ein \dq Sonderfall\dq ?}} \\
\multicolumn{2}{|X|}{\STRUT\texttt{\$ echo \dq Sie haben `ls | wc -l` Dateien in `pwd`\dq}\index{wc=\texttt{wc}}} \\
\multicolumn{2}{|X|}{\texttt{Sie haben 43 Dateien in /home/rschaten}} \\
\multicolumn{2}{|X|}{\STRUT\texttt{\$ echo \dq Der Wert von \textbackslash\$x ist \$x\dq}} \\
\multicolumn{2}{|X|}{\texttt{Der Wert von \$x ist 100}} \\
\end{longtable}

30
tab_beisp_sed-ex.tex Normal file
View File

@ -0,0 +1,30 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{s/.*/( \& )/} & Wiederholt die ganze Zeile, f<>gt aber Klammern hinzu. \tabularnewline\STRUT
\texttt{s/.*/mv \& \&.old/} & Formt eine Wortliste (ein Wort pro Zeile) zu \texttt{mv}-Befehlen um. \tabularnewline\STRUT
\texttt{/\^{}\$/d} & L<>scht Leerzeilen. \tabularnewline\STRUT
\texttt{:g/\^{}\$/d} & Wie oben, im ex-Editor. \tabularnewline\STRUT
\texttt{/\^{}[\Ovalbox{SPACE}\Ovalbox{TAB}]*\$/d} & L<>scht Leerzeilen und Zeilen, die nur aus Leerzeichen oder Tabulatoren bestehen. \tabularnewline\STRUT
\texttt{/\^{}[\Ovalbox{SPACE}\Ovalbox{TAB}]*\$/d} & L<>scht Leerzeilen und Zeilen, die nur aus Leerzeichen oder Tabulatoren bestehen. \tabularnewline\STRUT
\texttt{:g/\^{}[\Ovalbox{SPACE}\Ovalbox{TAB}]*\$/d} & Wie oben, im ex-Editor. \tabularnewline\STRUT
\texttt{/\Ovalbox{SPACE}\Ovalbox{SPACE}*/\Ovalbox{SPACE}/g} & Wandelt ein oder mehrere Leerzeichen in ein Leerzeichen um. \tabularnewline\STRUT
\texttt{:\%s/\Ovalbox{SPACE}\Ovalbox{SPACE}*/\Ovalbox{SPACE}/g} & Wie oben, im ex-Editor. \tabularnewline\STRUT
\texttt{:s/[0-9]/Element \&:/} & Wandelt (in der aktuellen Zeile) eine Zahl in ein Label f<>r ein Element um. \tabularnewline\STRUT
\texttt{:s} & Wiederholt die Substitution beim ersten Vorkommen. \tabularnewline\STRUT
\texttt{:\&} & Wie oben. \tabularnewline\STRUT
\texttt{:sg} & Wie oben, aber f<>r alle Vorkommen in einer Zeile. \tabularnewline\STRUT
\texttt{:\&g} & Wie oben. \tabularnewline\STRUT
\texttt{:\%\&g} & Wiederholt die Substitution im ganzen Puffer. \tabularnewline\STRUT
\texttt{:.,\$s/Wort/\textbackslash U\&/g} & Wandelt von der aktuellen bis zur letzten Zeile das Wort \textsl{Wort} in Gro<72>schreibung\index{Gro<EFBFBD>schreibung} um. \tabularnewline\STRUT
\texttt{:\%s/.*/\textbackslash L\&/} & Wandelt die gesamte Datei in Kleinschreibung um. \tabularnewline\STRUT
\texttt{:s/\textbackslash<./\textbackslash u\&/g} & Wandelt den ersten Buchstaben jedes Wortes in der aktuellen Zeile in Gro<72>schreibung\index{Gro<EFBFBD>schreibung} um. \tabularnewline\STRUT
\texttt{:\%s/ja/nein/g} & Ersetzt das Wort \textsl{ja} durch \textsl{nein}. \tabularnewline\STRUT
\texttt{:\%s/Ja/\~{}/g} & Ersetzt global ein anderes Wort (\textsl{Ja}) durch \textsl{nein} (Wiederverwendung des vorherigen Ersatzmusters).
\end{longtable}

17
tab_beisp_until.tex Normal file
View File

@ -0,0 +1,17 @@
\begin{longtable}{|X l|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\multicolumn{2}{|X|}{\textsl{Warten, bis sich der Administrator einloggt:}} \\
\multicolumn{2}{|X|}{\texttt{until who | grep \dq root\dq; do}\index{;=\texttt{;}}\index{Anf<EFBFBD>hrungszeichen}\index{who=\texttt{who}}} \\
\multicolumn{2}{|X|}{\texttt{~~~~~~~~~~\# who: Liste der Benutzer}} \\
\multicolumn{2}{|X|}{\texttt{~~~~~~~~~~\# grep: Suchen nach Muster}\index{Mustererkennung}} \\
\multicolumn{2}{|X|}{\texttt{~sleep 2~~\# sleep: warten}\index{sleep=\texttt{sleep}}} \\
\multicolumn{2}{|X|}{\texttt{done}} \\
\multicolumn{2}{|X|}{\texttt{echo \dq Der Meister ist anwesend\dq}\index{Anf<EFBFBD>hrungszeichen}} \\
\end{longtable}

16
tab_beisp_variablen_substitution.tex Normal file
View File

@ -0,0 +1,16 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{\$ \textsl{h}=\textsl{hoch} \textsl{r}=\textsl{runter} \textsl{l}=} & Weist den drei Variablen Werte zu, wobei \textsl{l} einen leeren Wert erh<72>lt. \tabularnewline\STRUT
\texttt{\$ echo \$\{h\}sprung} & Gibt \textsl{hochsprung} aus. Die Klammern m<>ssen gesetzt werden, damit \textsl{h} als Variablenname erkannt werden kann. \tabularnewline\STRUT
\texttt{\$ echo \$\{h-\$r\}} & Gibt \textsl{hoch} aus, da die Variable \textsl{h} belegt ist. Ansonsten w<>rde der Wert von \textsl{r} ausgegeben. \tabularnewline\STRUT
\texttt{\$ echo \$\{tmp-`date`\}} & Gibt das aktuelle Datum aus, wenn die Variable \textsl{tmp} nicht gesetzt ist.\footnote{Der Befehl \texttt{date} gibt das Datum zur<75>ck.} \tabularnewline\STRUT
\texttt{\$ echo \$\{l:=\$r\}} & Gibt \textsl{runter} aus, da die Variable \textsl{l} keinen Wert enth<74>lt. Gleichzeitig wird \textsl{l} der Wert von \textsl{r} zugewiesen. \tabularnewline\STRUT
\texttt{\$ echo \$l} & Gibt \textsl{runter} aus, da \textsl{l} jetzt den gleichen Inhalt hat wie \textsl{r}.
\end{longtable}

16
tab_beisp_while.tex Normal file
View File

@ -0,0 +1,16 @@
\begin{longtable}{|X l|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\multicolumn{2}{|X|}{\textsl{Zeilenweise Ausgabe aller Aufrufparameter:}\index{Parameter}} \\
\multicolumn{2}{|X|}{\texttt{while [ -n \dq\$1\dq ]; do}\index{\$n=\texttt{\$}$n$}\index{;=\texttt{;}}\index{Anf<EFBFBD>hrungszeichen}} \\
\multicolumn{2}{|X|}{\texttt{~echo \$1}} \\
\multicolumn{2}{|X|}{\texttt{~shift~~\# mit shift werden die Parameter nach}\index{shift=\texttt{shift}}\index{Parameter}} \\
\multicolumn{2}{|X|}{\texttt{~~~~~~~~\# Links geshiftet (aus \$2 wird \$1)}} \\
\multicolumn{2}{|X|}{\texttt{done}} \\
\end{longtable}

17
tab_beisp_while_for.tex Normal file
View File

@ -0,0 +1,17 @@
\begin{longtable}{|X l|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\multicolumn{2}{|X|}{\textsl{Ausgabe der Zahlen von 1 bis 100:}} \\
\multicolumn{2}{|X|}{\texttt{i=1}\index{!==\texttt{!=}}} \\
\multicolumn{2}{|X|}{\texttt{while [ \$i -le 100 ]}} \\
\multicolumn{2}{|X|}{\texttt{do}} \\
\multicolumn{2}{|X|}{\texttt{~echo \$i}} \\
\multicolumn{2}{|X|}{\texttt{~i=`expr \$i + 1`}\index{expr=\texttt{expr}}\index{+=\texttt{+}}\index{!==\texttt{!=}}\index{Backticks}} \\
\multicolumn{2}{|X|}{\texttt{done}} \\
\end{longtable}

11
tab_break.tex Normal file
View File

@ -0,0 +1,11 @@
\begin{longtable}{|X l|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\multicolumn{2}{|X|}{\texttt{break }\textsl{[ n ]}} \\
\end{longtable}

15
tab_case.tex Normal file
View File

@ -0,0 +1,15 @@
\begin{longtable}{|X l|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\multicolumn{2}{|X|}{\texttt{case }\textsl{Wert}\texttt{ in}} \\
\multicolumn{2}{|X|}{\texttt{~}\textsl{Muster1}\texttt{) }\textsl{Befehle1}\texttt{;;}} \\
\multicolumn{2}{|X|}{\texttt{~}\textsl{Muster2}\texttt{) }\textsl{Befehle2}\texttt{;;}} \\
\multicolumn{2}{|X|}{\texttt{~\vdots}} \\
\multicolumn{2}{|X|}{\texttt{esac}} \\
\end{longtable}

11
tab_continue.tex Normal file
View File

@ -0,0 +1,11 @@
\begin{longtable}{|X l|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\multicolumn{2}{|X|}{\texttt{continue }\textsl{[ n ]}} \\
\end{longtable}

16
tab_datenstroeme_deskriptoren.tex Normal file
View File

@ -0,0 +1,16 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\textsl{Befehl}\texttt{ >\&}\textsl{n} & Standard-Ausgabe von \textsl{Befehl} an den Dateideskriptor \textsl{n} <20>bergeben. \tabularnewline\STRUT
\textsl{Befehl m}\texttt{>\&}\textsl{n} & Der gleiche Vorgang, nur wird die Ausgabe, die normalerweise an den Dateideskriptor \textsl{m} geht, an den Dateideskriptor \textsl{n} <20>bergeben. \tabularnewline\STRUT
\textsl{Befehl}\texttt{ >\&-} & Schlie<69>t die Standard-Ausgabe. \tabularnewline\STRUT
\textsl{Befehl}\texttt{ <\&}\textsl{n} & Standard-Eingabe f<>r \textsl{Befehl} wird vom Dateideskriptor \textsl{n} <20>bernommen. \tabularnewline\STRUT
\textsl{Befehl m}\texttt{<\&}\textsl{n} & Der gleiche Vorgang, nur wird die Eingabe, die normalerweise vom Dateideskriptor \textsl{m} stammt, aus dem Dateideskriptor \textsl{n} <20>bernommen. \tabularnewline\STRUT
\textsl{Befehl}\texttt{ <\&-} & Schlie<69>t die Standard-Eingabe.
\end{longtable}

15
tab_datenstroeme_einfach.tex Normal file
View File

@ -0,0 +1,15 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\textsl{Befehl}\texttt{ > }\textsl{Datei} & Standard-Ausgabe von \textsl{Befehl} in \textsl{Datei} schreiben. Die \textsl{Datei} wird <20>berschrieben, wenn sie schon bestand. \tabularnewline\STRUT
\textsl{Befehl}\texttt{ >{}> }\textsl{Datei} & Standard-Ausgabe von \textsl{Befehl} an \textsl{Datei} anh<6E>ngen. Die \textsl{Datei} wird erstellt, wenn sie noch nicht bestand\footnote{In einigen sehr alten Versionen der \texttt{sh}\index{Bourne-Shell} und in der \texttt{csh}\index{C-Shell} wird die Datei nicht erstellt. Um hier sicherzugehen, sollte die Datei vorher mittels \texttt{touch}\index{touch=\texttt{touch}} erstellt werden.}. \tabularnewline\STRUT
\textsl{Befehl}\texttt{ < }\textsl{Datei} & Standard-Eingabe f<>r \textsl{Befehl} aus \textsl{Datei} lesen. \tabularnewline\STRUT
\textsl{Befehl}\texttt{ << }\textsl{Delimiter} & Ein Here-Dokument: Der \textsl{Befehl} erh<72>lt den folgenden Abschnitt als Standard-Eingabe. Der Abschnitt endet, sobald der Delimiter am Zeilenanfang gefunden wird. Der Delimiter kann beliebig gew<65>hlt werden (siehe Beispiel). \tabularnewline\STRUT
\textsl{Befehl1}\texttt{ | }\textsl{Befehl2} & Die Standard-Ausgabe von \textsl{Befehl1} wird an die Standard-Eingabe von \textsl{Befehl2} <20>bergeben. Mit diesem Mechanismus k<>nnen Programme als `Filter' f<>r den Datenstrom eingesetzt werden. Das verwendete Zeichen hei<65>t Pipe.
\end{longtable}

15
tab_datenstroeme_kanaele.tex Normal file
View File

@ -0,0 +1,15 @@
\begin{longtable}{|X|X|X|X|}
% KILLED & LINE!!!! \kill
\hline
Dateideskriptor & Name & Gebr<62>uchliche Abk<62>rzung & Typischer Standard \\
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
0 & Standard-Eingabe & stdin & Tastatur \tabularnewline\STRUT
1 & Standard-Ausgabe & stdout & Terminal\index{Terminal} \tabularnewline\STRUT
2 & Fehlerausgabe & stderr & Terminal
\end{longtable}

14
tab_datenstroeme_mehrfach.tex Normal file
View File

@ -0,0 +1,14 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\textsl{Befehl}\texttt{ 2> }\textsl{Datei} & Fehlerausgabe von \textsl{Befehl} in \textsl{Datei} schreiben. Die Standard-Ausgabe bleibt unver<65>ndert (z. B. auf dem Terminal). \tabularnewline\STRUT
\textsl{Befehl}\texttt{ > }\textsl{Datei}\texttt{ 2>\&1} & Fehlerausgabe und Standard-Ausgabe von \textsl{Befehl} werden in die \textsl{Datei} geschrieben. \tabularnewline\STRUT
\textsl{Befehl}\texttt{ > }\textsl{D1}\texttt{ 2> }\textsl{D2} & Standard-Ausgabe erfolgt in die Datei \textsl{D1}; Fehlerausgabe in die Datei \textsl{D2}. \tabularnewline\STRUT
\textsl{Befehl}\texttt{ | tee }\textsl{Dateien} & Die Ausgaben von \textsl{Befehl} erfolgen an der Standard-Ausgabe (in der Regel: Terminal), zus<75>tzlich wird sie vom Kommando \texttt{tee} in die \textsl{Dateien} geschrieben.\index{tee=\texttt{tee}}
\end{longtable}

11
tab_exit.tex Normal file
View File

@ -0,0 +1,11 @@
\begin{longtable}{|X l|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\multicolumn{2}{|X|}{\texttt{exit }\textsl{[ n ]}} \\
\end{longtable}

14
tab_for.tex Normal file
View File

@ -0,0 +1,14 @@
\begin{longtable}{|X l|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\multicolumn{2}{|X|}{\texttt{for }\textsl{x [}\texttt{ in }\textsl{Liste ]}} \\
\multicolumn{2}{|X|}{\texttt{do}} \\
\multicolumn{2}{|X|}{\texttt{~}\textsl{Befehle}} \\
\multicolumn{2}{|X|}{\texttt{done}} \\
\end{longtable}

17
tab_if.tex Normal file
View File

@ -0,0 +1,17 @@
\begin{longtable}{|X l|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\multicolumn{2}{|X|}{\texttt{if }\textsl{Bedingung1}} \\
\multicolumn{2}{|X|}{\texttt{then }\textsl{Befehle1}} \\
\multicolumn{2}{|X|}{\textsl{[}\texttt{ elif }\textsl{Bedingung2}} \\
\multicolumn{2}{|X|}{\texttt{ then }\textsl{Befehle2 ]}} \\
\multicolumn{2}{|X|}{\texttt{ \vdots}} \\
\multicolumn{2}{|X|}{\textsl{[}\texttt{ else }\textsl{Befehle3 ]}} \\
\multicolumn{2}{|X|}{\texttt{fi}} \\
\end{longtable}

19
tab_metazeichen.tex Normal file
View File

@ -0,0 +1,19 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{*} & Eine Folge von keinem, einem oder mehreren Zeichen \tabularnewline\STRUT
\texttt{?} & Ein einzelnes Zeichen \tabularnewline\STRUT
\texttt{[}\textsl{abc}\texttt{]} & <20>bereinstimmung mit einem beliebigen Zeichen in der Klammer \tabularnewline\STRUT
\texttt{[}\textsl{a}\texttt{-}\textsl{q}\texttt{]} & <20>bereinstimmung mit einem beliebigen Zeichen aus dem angegebenen Bereich \tabularnewline\STRUT
\texttt{[!}\textsl{abc}\texttt{]} & <20>bereinstimmung mit einem beliebigen Zeichen, das nicht in der Klammer ist\footnote{Bei einigen <20>lteren Versionen der Bash mu<6D> an Stelle des Rufzeichens ein \texttt{\^} geschrieben werden.} \tabularnewline\STRUT
\texttt{\~} & Home-Verzeichnis des aktuellen Benutzers\index{Home-Verzeichnis} \tabularnewline\STRUT
\texttt{\~{}}\textsl{name} & Home-Verzeichnis des Benutzers \textsl{name} \tabularnewline\STRUT
\texttt{\~{}+} & Aktuelles Verzeichnis \tabularnewline\STRUT
\texttt{\~{}-} & Vorheriges Verzeichnis
\end{longtable}

20
tab_mustererkennung_ersatzmuster.tex Normal file
View File

@ -0,0 +1,20 @@
\begin{longtable}{|l|c|c|c|X|}
% KILLED & LINE!!!! \kill
\hline
~ & ex & sed & ed & ~ \\
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{\textbackslash} & $\bullet$ & $\bullet$ & $\bullet$ & Sonderbedeutung des n<>chsten Zeichens aufheben. \tabularnewline\STRUT
\texttt{\textbackslash\textsl{n}} & $\bullet$ & $\bullet$ & $\bullet$ & Verwendet das in \texttt{\textbackslash( \textbackslash)} gespeicherte Muster erneut. \tabularnewline\STRUT
\texttt{\&} & $\bullet$ & $\bullet$ & ~ & Verwendet das vorherige Suchmuster erneut. \tabularnewline\STRUT
\texttt{\~} & $\bullet$ & ~ & ~ & Verwendet das vorherige Ersatzmuster erneut. \tabularnewline\STRUT
\texttt{\textbackslash u \textbackslash U} & $\bullet$ & ~ & ~ & <20>ndert das (die) Zeichen auf Gro<72>schreibung\index{Gro<EFBFBD>schreibung}. \tabularnewline\STRUT
\texttt{\textbackslash l \textbackslash L} & $\bullet$ & ~ & ~ & <20>ndert das (die) Zeichen auf Kleinschreibung\index{Kleinschreibung}. \tabularnewline\STRUT
\texttt{\textbackslash E} & $\bullet$ & ~ & ~ & Hebt das vorangegangene \texttt{\textbackslash U} oder \texttt{\textbackslash L} auf. \tabularnewline\STRUT
\texttt{\textbackslash e} & $\bullet$ & ~ & ~ & Hebt das vorangegangene \texttt{\textbackslash u} oder \texttt{\textbackslash l} auf.
\end{longtable}

20
tab_mustererkennung_ersatzsonderzeichen.tex Normal file
View File

@ -0,0 +1,20 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{\textbackslash} & Hebt die spezielle Bedeutung des n<>chsten Zeichens auf. \tabularnewline\STRUT
\texttt{\textbackslash\textsl{n}} & Ruft das \textsl{n}te Muster aus dem Puffer ab (siehe oben, unter \texttt{\textbackslash( \textbackslash)}. Dabei ist \textsl{n} eine Zahl zwischen 1 und 9. \tabularnewline\STRUT
\texttt{\&} & Verwendet das vorherige Suchmuster erneut als Teil eines Ersatzmusters. \tabularnewline\STRUT
\texttt{\~} & Verwendet das vorherige Ersatzmuster erneut im momentanen Ersatzmuster. \tabularnewline\STRUT
\texttt{\textbackslash u} & <20>ndert das erste Zeichen des Ersatzmusters auf Gro<72>schreibung\index{Gro<EFBFBD>schreibung}. \tabularnewline\STRUT
\texttt{\textbackslash U} & <20>ndert alle Zeichen des Ersatzmusters auf Gro<72>schreibung\index{Gro<EFBFBD>schreibung}. \tabularnewline\STRUT
\texttt{\textbackslash l} & <20>ndert das erste Zeichen des Ersatzmusters auf Kleinschreibung\index{Kleinschreibung}. \tabularnewline\STRUT
\texttt{\textbackslash L} & <20>ndert alle Zeichen des Ersatzmusters auf Kleinschreibung\index{Kleinschreibung}. \tabularnewline\STRUT
\texttt{\textbackslash e} & Hebt das vorangegangene \texttt{\textbackslash u} oder \texttt{\textbackslash l} auf. \tabularnewline\STRUT
\texttt{\textbackslash E} & Hebt das vorangegangene \texttt{\textbackslash U} oder \texttt{\textbackslash L} auf.
\end{longtable}

25
tab_mustererkennung_muster.tex Normal file
View File

@ -0,0 +1,25 @@
\begin{longtable}{|l|c|c|c|c|c|c|c|X|}
% KILLED & LINE!!!! \kill
\hline
~ & ed & ex & vi & sed & awk & grep & egrep & ~ \tabularnewline
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{.} & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & Ein beliebiges Zeichen. \tabularnewline\STRUT
\texttt{*} & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & Kein, ein oder mehrere Vorkommen des vorhergehenden Ausdrucks. \tabularnewline\STRUT
\texttt{\^} & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & Zeilenanfang. \tabularnewline\STRUT
\texttt{\$} & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & Zeilenende. \tabularnewline\STRUT
\texttt{\textbackslash} & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & Hebt die Sonderbedeutung des folgenden Zeichens auf. \tabularnewline\STRUT
\texttt{[ ]} & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & $\bullet$ & Ein Zeichen aus einer Gruppe. \tabularnewline\STRUT
\texttt{\textbackslash( \textbackslash)} & $\bullet$ & $\bullet$ & ~ & $\bullet$ & ~ & ~ & ~ & Speichert das Muster zur sp<73>teren Wiederholung. \tabularnewline\STRUT
\texttt{\textbackslash\{ \textbackslash\}} & $\bullet$ & ~ & ~ & $\bullet$ & ~ & $\bullet$ & ~ & Vorkommensbereich. \tabularnewline\STRUT
\texttt{\textbackslash< \textbackslash>} & $\bullet$ & $\bullet$ & $\bullet$ & ~ & ~ & ~ & ~ & Wortanfang oder -ende. \tabularnewline\STRUT
\texttt{+} & ~ & ~ & ~ & ~ & $\bullet$ & ~ & $\bullet$ & Ein oder mehrere Vorkommen des vorhergehenden Ausdrucks. \tabularnewline\STRUT
\texttt{?} & ~ & ~ & ~ & ~ & $\bullet$ & ~ & $\bullet$ & Kein oder ein Vorkommen des vorhergehenden Ausdrucks. \tabularnewline\STRUT
\texttt{|} & ~ & ~ & ~ & ~ & $\bullet$ & ~ & $\bullet$ & Trennt die f<>r die <20>bereinstimmung verf<72>gbaren Alternativen. \tabularnewline\STRUT
\texttt{( )} & ~ & ~ & ~ & ~ & $\bullet$ & ~ & $\bullet$ & Gruppiert Ausdr<64>cke f<>r den Test.
\end{longtable}

23
tab_mustererkennung_sonderzeichen.tex Normal file
View File

@ -0,0 +1,23 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{.} & Steht f<>r ein beliebiges \emph{einzelnes} Zeichen, mit Ausnahme des Zeilenendezeichens. \tabularnewline\STRUT
\texttt{*} & Steht f<>r eine beliebige (auch leere) Menge des einzelnen Zeichens vor dem Sternchen. Das vorangehende Zeichen kann auch ein regul<75>rer Ausdruck sein. Beispielsweise steht \texttt{.*} f<>r eine beliebige Anzahl eines beliebigen Zeichens. \tabularnewline\STRUT
\texttt{\^} & <20>bereinstimmung, wenn der folgende Ausdruck am Zeilenanfang\index{Zeilenanfang} steht. \tabularnewline\STRUT
\texttt{\$} & <20>bereinstimmung, wenn der vorhergehende Ausdruck am Zeilenende\index{Zeilenende} steht. \tabularnewline\STRUT
\texttt{\textbackslash} & Schaltet die Sonderbedeutung des nachfolgenden Zeichens ab. \tabularnewline\STRUT
\texttt{[ ]} & Steht f<>r \emph{ein} beliebiges Zeichen aus der eingeklammerten Gruppe. Mit einem Bindestrich kann man einen Bereich aufeinanderfolgender Zeichen ausw<73>hlen (\texttt{[a-e]}). Ein Zirkumflex (\texttt{\^}) wirkt als Umkehrung: \texttt{[\^{}a-z]} erfa<66>t alle Zeichen, die keine Kleinbuchstaben sind. Ein Bindestrich oder eine schlie<69>ende eckige Klammer am Listenanfang werden als Teil der Liste angesehen, alle anderen Sonderzeichen verlieren in der Liste ihre Bedeutung. \tabularnewline\STRUT
\texttt{\textbackslash( \textbackslash)} & Speichert das Muster zwischen \texttt{\textbackslash(} und \texttt{\textbackslash)} in einem speziellen Puffer. In einer Zeile k<>nnen bis zu neun solcher Puffer belegt werden. In Substitutionen k<>nnen sie <20>ber die Zeichenfolgen \texttt{\textbackslash 1} bis \texttt{\textbackslash 9} wieder benutzt werden. \tabularnewline\STRUT
\texttt{\textbackslash\{ \textbackslash\}} & Steht f<>r den Vorkommensbereich des unmittelbar vorhergehenden Zeichens. \texttt{\textbackslash\{}\textsl{n}\texttt{\textbackslash\}} bezieht sich auf genau \textsl{n} Vorkommen, \texttt{\textbackslash\{}\textsl{n}\texttt{,\textbackslash\}} auf mindestens \textsl{n} Vorkommen und \texttt{\textbackslash\{}\textsl{n}\texttt{,}\textsl{m}\texttt{\textbackslash\}} auf eine beliebige Anzahl von Vorkommen zwischen \textsl{n} und \textsl{m}. Dabei m<>ssen \textsl{n} und \textsl{m} im Bereich zwischen 0 und 256 liegen. \tabularnewline\STRUT
\texttt{\textbackslash< \textbackslash>} & Steht f<>r ein Zeichen am Anfang (\texttt{\textbackslash<}) oder am Ende (\texttt{\textbackslash>}) eines Wortes. \tabularnewline\STRUT
\texttt{+} & Steht f<>r ein oder mehrere Vorkommen des vorhergehenden regul<75>ren Ausdrucks (<28>quivalent zu \texttt{\{1,\}}). \tabularnewline\STRUT
\texttt{?} & Steht f<>r kein oder ein Vorkommen des vorhergehenden Ausdrucks (<28>quivalent zu \texttt{\{0,1\}}). \tabularnewline\STRUT
\texttt{|} & <20>bereinstimmung, wenn entweder der vorhergehende oder der nachfolgende regul<75>re Ausdruck <20>bereinstimmen. \tabularnewline\STRUT
\texttt{( )} & Steht f<>r die eingeschlossene Gruppe von regul<75>ren Ausdr<64>cken.
\end{longtable}

19
tab_quoting_sonderzeichen.tex Normal file
View File

@ -0,0 +1,19 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{;} & Befehls-Trennzeichen\index{Befehls>-Trennzeichen} \tabularnewline\STRUT
\texttt{\&} & Hintergrund-Verarbeitung \tabularnewline\STRUT
\texttt{( )} & Befehlsfolge\index{Befehls>-folge} \tabularnewline\STRUT
\texttt{|} & Pipe \tabularnewline\STRUT
\texttt{< > >\&} & Umlenkungssymbole \tabularnewline\STRUT
\texttt{* ? [ ] \~{} + - @ !} & Meta-Zeichen\index{Meta-Zeichen} f<>r Dateinamen \tabularnewline\STRUT
\texttt{` ` }(Backticks\footnote{Man erh<72>lt sie durch \Ovalbox{SHIFT} und die Taste neben dem Backspace.}) & Befehls-Substitution\index{Befehls>-Substitution} \tabularnewline\STRUT
\texttt{\$} & Variablen-Substitution\index{Variablen>-Substitution} \tabularnewline\STRUT
\texttt{\Ovalbox{NEWLINE} \Ovalbox{SPACE} \Ovalbox{TAB}} & Wort-Trennzeichen\footnote{Die Wort-Trennzeichen sind in der Variable \texttt{\$IFS}\index{\$IFS=\texttt{\$IFS}} abgelegt. Man kann diese Variable auch <20>berschreiben, um elegant Strings zu zerlegen.}
\end{longtable}

25
tab_quoting_zeichen.tex Normal file
View File

@ -0,0 +1,25 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{\dq~\dq} & (Anf<6E>hrungszeichen) Alles zwischen diesen Zeichen ist
buchstabengetreu zu interpretieren. Ausnahmen sind folgende Zeichen, die ihre
spezielle Bedeutung beibehalten: \texttt{\$ ` \dq} \tabularnewline\STRUT
\texttt{' '} & (Ticks\footnote{Sie liegen auf der Tastatur <20>ber der Raute.})
Alls zwischen diesen Zeichen wird w<>rtlich genommen, mit Ausnahme eines
weiteren \texttt{'} oder eines Backslashes (\texttt{\textbackslash})
\tabularnewline\STRUT
\texttt{\textbackslash} & (Backslash\index{Backslash}) Das Zeichen nach einem
\textbackslash wird w<>rtlich genommen. Anwendung z. B. innerhalb von
\texttt{\dq~\dq}, um \texttt{\dq}, \texttt{\$} und \texttt{`} zu entwerten.
H<EFBFBD>ufig verwendet zur Angabe von Leerzeichen (space) und Zeilenendezeichen, oder
um ein \textbackslash -Zeichen selbst anzugeben.
\end{longtable}

16
tab_signale.tex Normal file
View File

@ -0,0 +1,16 @@
\begin{longtable}{|l|l|X|}
% KILLED & LINE!!!! \kill
\hline
Nummer & Name & Bedeutung \\
\hline
% \endfirsthead
\endhead
\hline
\endfoot
% \endlastfoot
0 & Normal Exit & Wird durch das \texttt{exit}\index{exit=\texttt{exit}}-Kommando ausgel<65>st. \tabularnewline\STRUT
1 & SIGHUP & Wenn die Verbindung abbricht (z. B. wenn das Terminal geschlossen wird). \tabularnewline\STRUT
2 & SIGINT & Zeigt einen Interrupt an (\Ovalbox{CTRL}-\Ovalbox{C}). \tabularnewline\STRUT
15 & SIGTERM & Wird vom \texttt{kill}\index{kill=\texttt{kill}}-Kommando gesendet.
\end{longtable}

14
tab_until.tex Normal file
View File

@ -0,0 +1,14 @@
\begin{longtable}{|X l|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\multicolumn{2}{|X|}{\texttt{until }\textsl{Bedingung}} \\
\multicolumn{2}{|X|}{\texttt{do}} \\
\multicolumn{2}{|X|}{\texttt{~}\textsl{Befehle}} \\
\multicolumn{2}{|X|}{\texttt{done}} \\
\end{longtable}

16
tab_variablen_substitution.tex Normal file
View File

@ -0,0 +1,16 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\textsl{Variable}\texttt{=}\textsl{Wert} & Setzt die \textsl{Variable} auf den \textsl{Wert}. Dabei ist unbedingt darauf zu achten, da<64> zwischen dem Variablennamen und dem Gleichheitszeichen keine Leerzeichen stehen. \tabularnewline\STRUT
\texttt{\$\{}\textsl{Variable}\texttt{\}} & Nutzt den Wert von \textsl{Variable}. Die Klammern m<>ssen nicht mit angegeben werden, wenn die \textsl{Variable} von Trennzeichen umgeben ist. \tabularnewline\STRUT
\texttt{\$\{}\textsl{Variable}\texttt{:-}\textsl{Wert}\texttt{\}} & Nutzt den Wert von \textsl{Variable}. Falls die \textsl{Variable} nicht gesetzt ist, wird der \textsl{Wert} benutzt. \tabularnewline\STRUT
\texttt{\$\{}\textsl{Variable}\texttt{:=}\textsl{Wert}\texttt{\}} & Nutzt den Wert von \textsl{Variable}. Falls die \textsl{Variable} nicht gesetzt ist, wird der \textsl{Wert} benutzt, und \textsl{Variable} erh<72>lt den \textsl{Wert}. \tabularnewline\STRUT
\texttt{\$\{}\textsl{Variable}\texttt{:?}\textsl{Wert}\texttt{\}} & Nutzt den Wert von \textsl{Variable}. Falls die \textsl{Variable} nicht gesetzt ist, wird der \textsl{Wert} ausgegeben und die Shell beendet. Wenn kein \textsl{Wert} angegeben wurde, wird der Text \texttt{parameter null or not set} ausgegeben. \tabularnewline\STRUT
\texttt{\$\{}\textsl{Variable}\texttt{:+}\textsl{Wert}\texttt{\}} & Nutzt den \textsl{Wert}, falls die \textsl{Variable} gesetzt ist, andernfalls nichts.
\end{longtable}

20
tab_vordefinierte_variablen.tex Normal file
View File

@ -0,0 +1,20 @@
\begin{longtable}{|l|X|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\texttt{\$}$n$ & Aufrufparameter\index{Parameter} mit der Nummer $n$, $0<=n<=9$. \texttt{\$0} enth<74>lt den Namen des gerade laufenden Skripts. \tabularnewline\STRUT
\texttt{\$*} & Alle Aufrufparameter\index{Aufrufparameter|see{Parameter}}\index{Parameter}. \texttt{\dq\$*\dq} enth<74>lt alle Aufrufparameter in einem String. \tabularnewline\STRUT
\texttt{\$@} & Alle Aufrufparameter\index{Parameter}. \texttt{\dq\$@\dq} enth<74>lt alle Aufrufparameter\index{Parameter}, wobei jeder f<>r sich ein separater String bleibt. \tabularnewline\STRUT
\texttt{\$\#} & Anzahl der Aufrufparameter\index{Parameter} \tabularnewline\STRUT
\texttt{\$?} & R<>ckgabewert des letzten Kommandos \tabularnewline\STRUT
\texttt{\$\$} & Proze<7A>nummer der aktiven Shell \tabularnewline\STRUT
\texttt{\$!} & Proze<7A>nummer des letzten Hintergrundprozesses \tabularnewline\STRUT
\texttt{\$ERRNO} & Fehlernummer des letzten fehlgeschlagenen Systemaufrufs \tabularnewline\STRUT
\texttt{\$PWD} & Aktuelles Verzeichnis (wird durch \texttt{cd} gesetzt\footnote{Durch das Kommando \texttt{cd} wird das aktuelle Verzeichnis gewechselt.}) \tabularnewline\STRUT
\texttt{\$OLDPWD} & Vorheriges Verzeichnis (wird durch \texttt{cd} gesetzt)
\end{longtable}

14
tab_while.tex Normal file
View File

@ -0,0 +1,14 @@
\begin{longtable}{|X l|}
% KILLED & LINE!!!! \kill
\hline
\endfirsthead
\endhead
\endfoot
\hline
\endlastfoot
\multicolumn{2}{|X|}{\texttt{while }\textsl{Bedingung}} \\
\multicolumn{2}{|X|}{\texttt{do}} \\
\multicolumn{2}{|X|}{\texttt{~}\textsl{Befehle}} \\
\multicolumn{2}{|X|}{\texttt{done}} \\
\end{longtable}

45
was_ist_die_shell.tex Normal file
View File

@ -0,0 +1,45 @@
\chapter{Was ist die Shell?}\index{Shell}
Die Shell ist ein Programm, mit dessen Hilfe das System die Benutzerbefehle verstehen kann. Aus diesem Grund wird die Shell auch oft als Befehls- oder Kommandointerpreter bezeichnet.
\section{Sinn und Zweck}
In einem klassischen Unix-System (ohne die grafische Oberfl<66>che X) greifen die Benutzer <20>ber Terminals\index{Terminal} auf das System zu. Auf diesen Terminals k<>nnen nur Textzeichen dargestellt werden. Um dem Benutzer die Arbeit mit dem System effektiv m<>glich zu machen, gibt es die Shell. Die Shell wird dabei f<>r drei Hauptaufgaben benutzt:
\begin{itemize}
\item Interaktive Anwendung (Dialog)
\item Anwendungsspezifische Anpassung des Unix-Systemverhaltens (Belegen von Umgebungsvariablen)
\item Programmierung (Shell-Skripting). Zu diesem Zweck stehen einige Mechanismen zur Verf<72>gung, die aus Hochsprachen bekannt sind (Variablen, Datenstr<74>me, Funktionen usw.).
\end{itemize}
Urspr<EFBFBD>nglich handelte es sich dabei um ein relativ einfaches Programm, der Bourne Shell (wird oft auch Standard-Shell genannt). Dies ist praktisch die "`Mutter aller Shells"'. Aus dieser entwickelten sich im Laufe der Zeit mehrere Varianten, die alle ihre eigenen Vor- und Nachteile mit sich bringen. Da es unter Unix kein Problem darstellt den Kommandointerpreter auszutauschen, stehen auf den meisten Systemen mehrere dieser Shells zur Verf<72>gung. Welche Variante ein Benutzer verwenden m<>chte ist reine Geschmackssache.
\section{Die Qual der Wahl}
Um die Auswahl einer Shell zu erleichtern, werden hier die wichtigsten Varianten kurz vorgestellt. Sie sind aufgeteilt in Einfach- und Komfort-Shells. Die Komfort-Shells zeichnen sich durch komfortablere Funktionen zur interaktiven Bedienung aus, w<>hrend die Einfach-Versionen <20>blicherweise f<>r die Programmierung benutzt werden.
\medskip\emph{Einfach-Shells:}\nopagebreak
\begin{itemize}
\item Die Bourne-\index{Bourne-Shell|textbf}\index{Shell>Bourne-|see{Bourne-Shell}} oder Standard-Shell\index{Shell>Standard-|see{Bourne-Shell}}\index{Standard-Shell|see{Bourne-Shell}} (\texttt{sh}\index{sh=\texttt{sh}|see{Bourne-Shell}}) ist die kompakteste und einfachste Form. Sie bietet schon Mechanismen wie die Umlenkung der Ein- oder Ausgaben, Wildcards zur Abk<62>rzung von Dateinamen, Shell-Variablen und einen Satz interner Befehle zum Schreiben von Shell-Prozeduren. Neuere Versionen beherrschen auch das Job-Controlling\index{Job-Controlling}. F<>r die Entwicklung von Shell-Skripten sollte man sich auf diese Shell beschr<68>nken, da sie auf praktisch allen Systemen zur Verf<72>gung steht. So bleiben die Skripte portabel.
\item Die Korn-Shell\index{Korn-Shell|textbf}\index{Shell>Korn-|see{Korn-Shell}} (\texttt{ksh}\index{ksh=\texttt{ksh}|see{Korn-Shell}}), eine Weiterentwicklung der Bourne-Shell, erlaubt das editieren in der Befehlszeile. Au<41>erdem gibt es hier History\index{History}-Funktionen\footnote{History-Funktionen erm<72>glichen es dem Benutzer, einfach auf zur<75>ckliegende Befehle zur<75>ckgreifen zu k<>nnen.}, eine Ganzzahl-Arithmetik, verbesserte M<>glichkeiten zur Mustererkennung, Aliase\index{Aliase}\footnote{Ein Alias ist eine Abk<62>rzung f<>r einen Befehl. Beispielsweise kann man das H<>ufig benutzte \texttt{ls -la} einfach durch \texttt{la} ersetzen.} und das Job-Controlling\footnote{Unter Job-Controlling versteht man einen Mechanismus, mit dessen Hilfe der Benutzer die Ausf<73>hrung von Prozessen selektiv stoppen oder fortsetzen kann}\index{Job-Controlling}. Au<41>erdem bietet die Korn-Shell im Gegensatz zu fast allen anderen Shells die M<>glichkeit, Aliase und Shell-Funktionen an Subshells zu vererben.
\item Die C-Shell \index{C-Shell|textbf}\index{Shell>C-|see{C-Shell}} (\texttt{csh}\index{csh=\texttt{csh}|see{C-Shell}}) bietet <20>hnliche Annehmlichkeiten wie die Korn-Shell, lehnt sich aber in der Syntax sehr stark an die Programmiersprache C an. Sie sollte nach M<>glichkeit nicht zur Shell-Programmierung benutzt werden, da sie an vielen Stellen nicht so reagiert, wie man es erwarten sollte.
\end{itemize}
\medskip\emph{Komfort-Shells:}\nopagebreak
\begin{itemize}
\item Die Bourne-Again-Shell\index{Bourne-Again-Shell|textbf}\index{Shell>Bourne-Again-|see{Bourne-Again-Shell}}\index{Shell>Bash|see{Bourne-Again-Shell}} (\texttt{bash}\index{bash=\texttt{bash}|see{Bourne-Again-Shell}}) ist voll abw<62>rtskompatibel zur sh, bietet aber von allen Shells die komfortabelsten Funktionen f<>r das interaktive Arbeiten. Da die Bash ein GNU-Produkt ist, ist sie die Standard-Shell auf allen Linux-Systemen. Sie steht aber auch auf den meisten anderen Unixen zur Verf<72>gung.
Die Bash unterst<73>tzt Auto-Completion\index{Auto-Completion|textbf}\footnote{Mit Auto-Completion ist das automatische Vervollst<73>ndigen von Dateinamen\index{Dateinamen} gemeint.}, History-Funktionen, Aliase\index{Aliase}, eine Ganzzahl-Arithmetik und indizierte Arrays\index{Array}.
\item Die TENEX-C-Shell\index{TENEX-C-Shell|textbf}\index{Shell>TENEX-C-|see{TENEX-C-Shell}} (\texttt{tcsh}\index{tcsh=\texttt{tcsh}|see{TENEX-C-Shell}}) verh<72>lt sich zur C-Shell wie die Bourne-Again-Shell zur Standard-Shell. Sie ist voll kompatibel, bietet aber Komfort-Funktionen wie Kommandozeilen-Editierung, programmierbare Auto-Completion\index{Auto-Completion}, Rechtschreibhilfen und eine History.
\item Die Z-Shell\index{Z-Shell|textbf}\index{Shell>Z-|see{Z-Shell}} (\texttt{zsh}\index{zsh=\texttt{zsh}|see{Z-Shell}}) <20>hnelt der Korn-Shell, enth<74>lt aber viele Erweiterungen. Die Z-Shell unterst<73>tzt Kommandozeilen-Editing, programmierbares Auto-Completion\index{Auto-Completion}, Shell-Funktionen und eine History. Zudem ist eine Rechtschreibpr<70>fung eingebaut.
\end{itemize}
\medskip\emph{Exoten:}\medskip\nopagebreak
Desweiteren gibt es noch eine Reihe weiterer Shells, die aber nur selten eingesetzt werden. Dazu geh<65>ren die \texttt{ash}\index{ash|textbf}\index{Shell>ash=\texttt{ash}|see{ash}} (Ein Bourne-Shell-Clone f<>r Rechner mit wenig Speicher.), \texttt{rc}\index{rc|textbf}\index{Shell>rc=\texttt{rc}|see{rc}} (Noch ein Bourne-Shell-Clone, urspr<70>nglich aus AT\&T Plan 9. Klein, schnell und mit eine C-<2D>hnlichen Syntax.), \texttt{esh}\index{esh|textbf}\index{Shell>esh=\texttt{esh}|see{esh}} (Klein und schnell, bietet eine Lisp-<2D>hnliche Sprache), \texttt{sash}\index{sash|textbf}\index{Shell>sash=\texttt{sash}|see{sash}} (System Administrator's Shell - eine statisch gelinkte Shell mit integrierten Standard-Kommandos.).
Diese Liste ist bei weitem nicht vollst<73>ndig.

124
werkzeugkasten.tex Normal file
View File

@ -0,0 +1,124 @@
\chapter{N<EFBFBD>tzliche 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. ;-)
\section{Ein- und Ausgabe}
TODO!!!
\subsection{echo}
TODO!!!
\LTXtable{\textwidth}{tab_beisp_exitcode.tex}
\subsection{cat}
TODO!!!
\subsection{read}
TODO!!!
\section{Pfade und Dateien}
TODO!!!
\subsection{basename}
TODO!!!
\subsection{touch}
TODO!!!
\section{Pipes manipulieren}
TODO!!!
\subsection{grep}
TODO!!!
\subsection{sed}
TODO!!!
\subsection{awk}
TODO!!!
\subsection{sort}
TODO!!!
\subsection{tee}
TODO!!!
\subsection{wc}
TODO!!!
\section{Sonstige Befehle}
TODO!!!
\subsection{script}
TODO!!!
\subsection{seq}
TODO!!!
\subsection{expr}
TODO!!!
\subsection{bc}
TODO!!!
\subsection{kill}
TODO!!!
\subsection{sleep}
TODO!!!
\subsection{who}
TODO!!!

438
wie_sieht_ein_shell_skript_aus.tex Normal file
View File

@ -0,0 +1,438 @@
\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.
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.
\section{Grunds<EFBFBD>tzliches}
Zun<EFBFBD>chst soll die Frage gekl<6B>rt werden, wie man <20>berhaupt ein ausf<73>hrbares Shell-Skript schreibt. Dabei wird vorausgesetzt, da<64> dem Benutzer der Umgang mit mindestens einem Texteditor\index{Texteditor} (\texttt{vi}\index{vi=\texttt{vi}}, \texttt{emacs}\index{emacs=\texttt{emacs}} etc.) bekannt ist.
\subsection{HowTo}
Zun<EFBFBD>chst mu<6D> mit Hilfe des Editors eine Textdatei angelegt werden, in die der `Quelltext' geschrieben wird. Wie der aussieht, sollte man anhand der folgenden Abschnitte und der Beispiele im Anhang erkennen k<>nnen. Beim Schreiben sollte man nicht mit den Kommentaren\index{Kommentar} geizen, da ein Shell-Skript auch schon mal sehr unleserlich werden kann.
Nach dem Abspeichern der Datei unter einem geeigneten Namen\footnote{Bitte
\emph{nicht} den Namen \texttt{test}\index{test=\texttt{test}} verwenden. Es
existiert ein Unix-Systemkommando mit diesem Namen. Dieses steht fast immer
eher im Pfad, d. h. beim Kommando \texttt{test} w<>rde nicht das eigene Skript
ausgef<EFBFBD>hrt, sondern das Systemkommando. Dies ist einer der h<>ufigsten und
zugleich einer der verwirrendsten Anf<6E>ngerfehler. Mehr zu dem
\texttt{test}-Kommando unter \ref{bedingungen}.} mu<6D> die sie ausf<73>hrbar gemacht
werden. Das geht mit dem Unix-Kommando
\texttt{chmod}\index{chmod=\texttt{chmod}}. Rechte k<>nnen unter Unix getrennt
f<EFBFBD>r den Benutzer (user, \texttt{u}), die Gruppe (group, \texttt{g}) oder andere
(others, \texttt{o}) vergeben werden. Au<41>erdem kann man die Rechte f<>r alle
Gruppen zusammen (all, a) setzen. Man kann getrennt die Rechte f<>r das lesen
(read, \texttt{r}), das schreiben (write, \texttt{w}) und die Ausf<73>hrung
(execution, \texttt{x}) vergeben. Damit die Datei f<>r einen Benutzer wirklich
ausf<EFBFBD>hrbar ist, mu<6D> er das Lese- und das
Ausf<EFBFBD>hrungsrecht\index{Aus<EFBFBD>hrungsrecht} haben. Um die Rechte zu setzen, mu<6D> man
\texttt{chmod} in Parametern mitgeben, worauf sich das Kommando bezieht, ob das
Recht gesetzt (\texttt{+}) oder weggenommen (\texttt{-}) werden soll, und
welche Rechte gemeint sind. Damit alle Benutzer das Skript ausf<73>hren d<>rfen,
benutzt man das Kommando \texttt{chmod ugo+rx name} oder einfach \texttt{chmod
+rx name}. Mit \texttt{chmod u+x name} hat nur der Besitzer der Datei
Ausf<EFBFBD>hrungsrechte.
Dann kann das Skript gestartet werden. Da sich aus Sicherheitsgr<67>nden auf den meisten Systemen das aktuelle Verzeichnis nicht im Pfad des Benutzers befindet, mu<6D> man der Shell noch mitteilen, wo sie zu suchen hat: Mit \texttt{./name} wird versucht, im aktuellen Verzeichnis (\texttt{./}) ein Programm namens \texttt{name} auszuf<75>hren.
Auf den meisten Systemen befindet sich im Pfad der Eintrag \texttt{\~{}/bin} bzw. \texttt{/home/benutzername/bin}, das bedeutet da<64> man Skripte die immer wieder benutzt werden sollen dort ablegen kann, so da<64> sie auch ohne eine Pfadangabe gefunden werden. Wie der Pfad genau aussieht kann man an der Shell durch Eingabe von \texttt{echo \$PATH}\index{\$PATH=\texttt{\$PATH}} herausfinden.
\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.
Dieser R<>ckgabewert wird bei der interaktiven Benutzung der Shell nur selten benutzt. Aber in der Programmierung von Shell-Skripten ist er von unsch<63>tzbarem Wert. So kann das Skript automatisch entscheiden, ob bestimmte Aktionen ausgef<65>hrt werden sollen, die von anderen Aktionen ab\-h<EFBFBD>n\-gen. Beispiele dazu sieht man bei der Beschreibung der Kommandos \texttt{if}\index{if=\texttt{if}} (\ref{if}), \texttt{case}\index{case=\texttt{case}} (\ref{case}), \texttt{while}\index{while=\texttt{while}} (\ref{while}) und \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}.
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})}.
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.
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|)}
\section{Vordefinierte Variablen}\label{vordefinierte_variablen}\index{Variablen}\index{vordefinierte Variablen}
\index{\$n=\texttt{\$}$n$|(textbf}\index{\$*=\texttt{\$*}|(textbf}\index{\$@=\texttt{\$@}|(textbf}\index{\$\#=\texttt{\$\#}|(textbf}\index{\$?=\texttt{\$?}|(textbf}\index{\$\$=\texttt{\$\$}|(textbf}\index{\$!!=\texttt{\$!!}|(textbf}\index{\$ERRNO=\texttt{\$ERRNO}|(textbf}\index{\$PWD=\texttt{\$PWD}|(textbf}\index{\$OLDPWD=\texttt{\$OLDPWD}|(textbf}
\index{ERRNO=\texttt{ERRNO}|see{\$ERRNO}}\index{PWD=\texttt{PWD}|see{\$PWD}}\index{OLDPWD=\texttt{OLDPWD}|see{\$OLDPWD}}
Es gibt eine Reihe von vordefinierten Variablen, deren Benutzung ein wesentlicher Bestandteil des Shell-Programmierens ist.
Die wichtigsten eingebauten Shell-Variablen sind:\nopagebreak
\LTXtable{\textwidth}{tab_vordefinierte_variablen.tex}
\texttt{\$ERRNO}, \texttt{\$PWD} und \texttt{\$OLDPWD} werden nicht von jeder Shell gesetzt.
\index{\$n=\texttt{\$}$n$|)}\index{\$*=\texttt{\$*}|)}\index{\$@=\texttt{\$@}|)}\index{\$\#=\texttt{\$\#}|)}\index{\$?=\texttt{\$?}|)}\index{\$\$=\texttt{\$\$}|)}\index{\$!!=\texttt{\$!!}|)}\index{\$ERRNO=\texttt{\$ERRNO}|)}\index{\$PWD=\texttt{\$PWD}|)}\index{\$OLDPWD=\texttt{\$OLDPWD}|)}
\section{Variablen-Substitution}\index{Variablen>-Substitution|(textbf}\index{Substitution|see{Variablen-Subst.}}\index{Variablen|(textbf}
\index{!==\texttt{!=}|(textbf}\index{\$\{Variable\}=\texttt{\$\{}\textsl{Variable}\texttt{\}}|(textbf}\index{\$\{Variable:-Wert\}=\texttt{\$\{}\textsl{Variable}\texttt{:-}\textsl{Wert}\texttt{\}}|(textbf}\index{\$\{Variable:=Wert\}=\texttt{\$\{}\textsl{Variable}\texttt{:=}\textsl{Wert}\texttt{\}}|(textbf}\index{\$\{Variable:?Wert\}=\texttt{\$\{}\textsl{Variable}\texttt{:?}\textsl{Wert}\texttt{\}}|(textbf}\index{\$\{Variable:+Wert\}=\texttt{\$\{}\textsl{Variable}\texttt{:+}\textsl{Wert}\texttt{\}}|(textbf}
Unter Variablen-Substitution versteht man verschiedene Methoden um die Inhalte von Variablen zu benutzen. Das umfa<66>t sowohl die einfache Zuweisung eines Wertes an eine Variable als auch einfache M<>glichkeiten zur Fallunterscheidung. In den fortgeschritteneren Shell-Versionen (\texttt{bash}\index{Bourne-Again-Shell}, \texttt{ksh}\index{Korn-Shell}) existieren sogar M<>glichkeiten, auf Substrings von Variableninhalten zuzugreifen. In der Standard-Shell benutzt man f<>r einfache Aufgaben <20>blicherweise Tools wie \texttt{cut}, \texttt{basename}\index{basename=\texttt{basename}} oder \texttt{dirname}; komplexe Bearbeitungen erledigt der Stream-Editor \texttt{sed}\index{sed=\texttt{sed}}. Einleitende Informationen dazu finden sich im Kapitel <20>ber die Mustererkennung (\ref{mustererkennung}).
Die folgenden Mechanismen stehen in der Standard-Shell bereit, um mit Variablen zu hantieren. Bei allen Angaben ist der Doppelpunkt optional. Wenn er aber angegeben wird, mu<6D> die \textsl{Variable} einen Wert enthalten. \nopagebreak
\LTXtable{\textwidth}{tab_variablen_substitution.tex}
\medskip\emph{Beispiele:}\nopagebreak
\LTXtable{\textwidth}{tab_beisp_variablen_substitution.tex}
\index{!==\texttt{!=}|)}\index{\$\{Variable\}=\texttt{\$\{}\textsl{Variable}\texttt{\}}|)}\index{\$\{Variable:-Wert\}=\texttt{\$\{}\textsl{Variable}\texttt{:-}\textsl{Wert}\texttt{\}}|)}\index{\$\{Variable:=Wert\}=\texttt{\$\{}\textsl{Variable}\texttt{:=}\textsl{Wert}\texttt{\}}|)}\index{\$\{Variable:?Wert\}=\texttt{\$\{}\textsl{Variable}\texttt{:?}\textsl{Wert}\texttt{\}}|)}\index{\$\{Variable:+Wert\}=\texttt{\$\{}\textsl{Variable}\texttt{:+}\textsl{Wert}\texttt{\}}|)}
\index{Variablen>-Substitution|)}\index{Variablen|)}
\section{Quoting}\index{Quoting|(textbf}\label{quoting}
\index{Anf<EFBFBD>hrungszeichen|(textbf}\index{Ticks|(textbf}\index{Backslash|(textbf}\index{;=\texttt{;}|(textbf}\index{\&=\texttt{\&}|(textbf}\index{( )=\texttt{( )}|(textbf}\index{|=\texttt{|}|(textbf}\index{<=\texttt{<}|(textbf}\index{!>=\texttt{!>}|(textbf}\index{!>\&=\texttt{!>\&}|(textbf}\index{*=\texttt{*}|(textbf}\index{?=\texttt{?}|(textbf}\index{[ ]=\texttt{[ ]}|(textbf}\index{\~{}=\texttt{\~{}}|(textbf}\index{+=\texttt{+}|(textbf}\index{-=\texttt{-}|(textbf}\index{@=\texttt{@}|(textbf}\index{!!=\texttt{!!}|(textbf}\index{Backticks|(textbf}\index{\$=\texttt{\$}|(textbf}\index{[newline]=\texttt{[newline]}|(textbf}\index{[space]=\texttt{[space]}|(textbf}\index{[tab]=\texttt{[tab]}|(textbf}
\index{' '=\texttt{' '}|see{Ticks}}\index{` `=\texttt{` `}|see{Backticks}}\index{\dq~\dq=\texttt{\dq~\dq}|see{Anf<EFBFBD>hrungszeichen}}\index{\textbackslash=\texttt{\textbackslash}|see{Backslash}}
Dies ist ein sehr schwieriges Thema, da hier mehrere <20>hnlich aussehende Zeichen v<>llig verschiedene Effekte bewirken. Unix unterscheidet allein zwischen drei verschiedenen Anf<6E>hrungszeichen. Das Quoten dient dazu, bestimmte Zeichen mit einer Sonderbedeutung vor der Shell zu `verstecken' um zu verhindern, da<64> diese expandiert (ersetzt) werden.
Die folgenden Zeichen haben eine spezielle Bedeutung innerhalb der Shell:\nopagebreak
\LTXtable{\textwidth}{tab_quoting_sonderzeichen.tex}
Die folgenden Zeichen k<>nnen zum Quoten verwendet werden:\nopagebreak
\LTXtable{\textwidth}{tab_quoting_zeichen.tex}
\medskip\emph{Beispiele:}\nopagebreak
\LTXtable{\textwidth}{tab_beisp_quoting.tex}
\index{Anf<EFBFBD>hrungszeichen|)}\index{Ticks|)}\index{Backslash|)}\index{;=\texttt{;}|)}\index{\&=\texttt{\&}|)}\index{( )=\texttt{( )}|)}\index{|=\texttt{|}|)}\index{<=\texttt{<}|)}\index{!>=\texttt{!>}|)}\index{!>\&=\texttt{!>\&}|)}\index{*=\texttt{*}|)}\index{?=\texttt{?}|)}\index{[ ]=\texttt{[ ]}|)}\index{\~{}=\texttt{\~{}}|)}\index{+=\texttt{+}|)}\index{-=\texttt{-}|)}\index{@=\texttt{@}|)}\index{!!=\texttt{!!}|)}\index{Backticks|)}\index{\$=\texttt{\$}|)}\index{[newline]=\texttt{[newline]}|)}\index{[space]=\texttt{[space]}|)}\index{[tab]=\texttt{[tab]}|)}
\index{Quoting|)}
\section{Meta-Zeichen}\index{Meta-Zeichen|(textbf}\index{Wildcards|see{Metazeichen}}\index{Joker-Zeichen|see{Metazeichen}}\index{Platzhalter|see{Metazeichen}}
\index{*=\texttt{*}|(textbf}\index{?=\texttt{?}|(textbf}\index{[abc]=\texttt{[}\textsl{abc}\texttt{]}|(textbf}\index{[a-q]=\texttt{[}\textsl{a}\texttt{-}\textsl{q}\texttt{]}|(textbf}\index{[!!abc]=\texttt{[!!}\textsl{abc}\texttt{]}|(textbf}\index{Dateinamen|(textbf}
\index{\~{}=\texttt{\~{}}|(textbf}\index{\~{}name=\texttt{\~{}}\textsl{name}|(textbf}\index{\~{}+=\texttt{\~{}+}|(textbf}\index{\~{}-=\texttt{\~{}-}|(textbf}
Bei der Angabe von Dateinamen k<>nnen eine Reihe von Meta-Zeichen\footnote{Meta-Zeichen werden auch Wildcards, Joker-Zeichen oder Platzhalter genannt.} verwendet werden, um mehrere Dateien gleichzeitig anzusprechen oder um nicht den vollen Dateinamen ausschreiben zu m<>ssen.
Die wichtigsten Meta-Zeichen sind:\nopagebreak
\LTXtable{\textwidth}{tab_metazeichen.tex}
\medskip\emph{Beispiele:}\nopagebreak
\LTXtable{\textwidth}{tab_beisp_metazeichen.tex}
\index{*=\texttt{*}|)}\index{?=\texttt{?}|)}\index{[abc]=\texttt{[}\textsl{abc}\texttt{]}|)}\index{[a-q]=\texttt{[}\textsl{a}\texttt{-}\textsl{q}\texttt{]}|)}\index{[!!abc]=\texttt{[!!}\textsl{abc}\texttt{]}|)}\index{Dateinamen|)}
\index{\~{}=\texttt{\~{}}|)}\index{\~{}name=\texttt{\~{}}\textsl{name}|)}\index{\~{}+=\texttt{\~{}+}|)}\index{\~{}-=\texttt{\~{}-}|)}
\index{Meta-Zeichen|)}
\section{Klammer-Expansion}
man bash
/Brace Expansion
TODO!!!
\section{Mustererkennung}\index{Mustererkennung|(textbf}\label{mustererkennung}
\index{ed=\texttt{ed}|(textbf}\index{ex=\texttt{ex}|(textbf}\index{vi=\texttt{vi}|(textbf}\index{sed=\texttt{sed}|(textbf}\index{awk=\texttt{awk}|(textbf}\index{grep=\texttt{grep}|(textbf}\index{egrep=\texttt{egrep}|(textbf}
\index{*=\texttt{*}|(textbf}\index{.=\texttt{.}|(textbf}\index{\^=\texttt{\^}|(textbf}\index{\$=\texttt{\$}|(textbf}\index{Backslash|(textbf}\index{[ ]=\texttt{[ ]}|(textbf}\index{\textbackslash( \textbackslash)=\texttt{\textbackslash( \textbackslash)}|(textbf}\index{\textbackslash\{ \textbackslash\}=\texttt{\textbackslash\{ \textbackslash\}}|(textbf}\index{\textbackslash< \textbackslash>=\texttt{\textbackslash< \textbackslash>}|(textbf}\index{+=\texttt{+}|(textbf}\index{?=\texttt{?}|(textbf}\index{|=\texttt{|}|(textbf}\index{( )=\texttt{( )}|(textbf}\index{Regul<EFBFBD>rer Ausdruck|(textbf}
\index{\textbackslash n=\texttt{\textbackslash}\textsl{n}|(textbf}\index{\&=\texttt{\&}|(textbf}\index{\~{}=\texttt{\~{}}|(textbf}\index{\textbackslash u=\texttt{\textbackslash u}|(textbf}\index{\textbackslash U=\texttt{\textbackslash U}|(textbf}\index{\textbackslash l=\texttt{\textbackslash l}|(textbf}\index{\textbackslash L=\texttt{\textbackslash L}|(textbf}\index{\textbackslash E=\texttt{\textbackslash E}|(textbf}\index{\textbackslash e=\texttt{\textbackslash e}|(textbf}
Man unterscheidet in der Shell-Programmierung zwischen den
Meta-Zeichen\index{Meta-Zeichen}, die bei der Bezeichnung von Dateinamen
eingesetzt werden (sogenanntes `Globbing'\index{Globbing}) und den Meta-Zeichen, die in
mehreren Programmen Verwendung finden, um z. B. Suchmuster zu definieren. Diese
Muster werden auch regul<75>re Ausdr<64>cke (regular expression)\index{Regular
Expression|see{Regul<EFBFBD>rer Ausdruck}}\index{Expression|see{Regul<EFBFBD>rer
Ausdruck}}\index{Ausdruck|see{Regul<EFBFBD>rer Ausdruck}} genannt. Sie bieten
wesentlich mehr M<>glichkeiten als die relativ einfachen Wildcards f<>r
Dateinamen.
In der folgenden Tabelle wird gezeigt, in welchen Unix-Tools welche Zeichen zur Verf<72>gung stehen. Eine ausf<73>hrlichere Beschreibung der Eintr<74>ge findet sich auf Seite \pageref{beschreibung_der_muster}. \nopagebreak
\LTXtable{\textwidth}{tab_mustererkennung_muster.tex}
Bei einigen Tools (\texttt{ex}, \texttt{sed} und \texttt{ed}) werden zwei Muster angegeben: Ein Suchmuster (links) und ein Ersatzmuster (rechts). Nur die folgenden Zeichen sind in einem Ersatzmuster g<>ltig:\nopagebreak
\LTXtable{\textwidth}{tab_mustererkennung_ersatzmuster.tex}
\medskip\emph{Sonderzeichen in Suchmustern:}\label{beschreibung_der_muster}\nopagebreak
\LTXtable{\textwidth}{tab_mustererkennung_sonderzeichen.tex}
\medskip\emph{Sonderzeichen in Ersatzmustern:}\nopagebreak
\LTXtable{\textwidth}{tab_mustererkennung_ersatzsonderzeichen.tex}
\medskip\emph{Beispiele:} Muster\nopagebreak
\LTXtable{\textwidth}{tab_beisp_muster.tex}
\medskip\emph{Beispiele:} egrep- oder awk-Muster\nopagebreak
\LTXtable{\textwidth}{tab_beisp_muster_egrep.tex}
\medskip\emph{Beispiele:} ex- oder vi-Muster\nopagebreak
\LTXtable{\textwidth}{tab_beisp_muster_ex.tex}
\medskip\emph{Beispiele:} sed- oder grep-Muster\nopagebreak
\LTXtable{\textwidth}{tab_beisp_muster_sed.tex}
\medskip\emph{Beispiele:} Suchen und Ersetzen mit \texttt{sed} und \texttt{ex}. Im Folgenden werden Leerzeichen durch \Ovalbox{SPACE} und Tabulatoren durch \Ovalbox{TAB} gekennzeichnet. Befehle f<>r ex werden mit einem Doppelpunkt eingeleitet.\nopagebreak
\LTXtable{\textwidth}{tab_beisp_sed-ex.tex}
\index{ed=\texttt{ed}|)}\index{ex=\texttt{ex}|)}\index{vi=\texttt{vi}|)}\index{sed=\texttt{sed}|)}\index{awk=\texttt{awk}|)}\index{grep=\texttt{grep}|)}\index{egrep=\texttt{egrep}|)}
\index{*=\texttt{*}|)}\index{.=\texttt{.}|)}\index{\^=\texttt{\^}|)}\index{\$=\texttt{\$}|)}\index{Backslash|)}\index{[ ]=\texttt{[ ]}|)}\index{\textbackslash( \textbackslash)=\texttt{\textbackslash( \textbackslash)}|)}\index{\textbackslash\{ \textbackslash\}=\texttt{\textbackslash\{ \textbackslash\}}|)}\index{\textbackslash< \textbackslash>=\texttt{\textbackslash< \textbackslash>}|)}\index{+=\texttt{+}|)}\index{?=\texttt{?}|)}\index{|=\texttt{|}|)}\index{( )=\texttt{( )}|)}\index{Regul<EFBFBD>rer Ausdruck|)}
\index{\textbackslash n=\texttt{\textbackslash}\textsl{n}|)}\index{\&=\texttt{\&}|)}\index{\~{}=\texttt{\~{}}|)}\index{\textbackslash u=\texttt{\textbackslash u}|)}\index{\textbackslash U=\texttt{\textbackslash U}|)}\index{\textbackslash l=\texttt{\textbackslash l}|)}\index{\textbackslash L=\texttt{\textbackslash L}|)}\index{\textbackslash E=\texttt{\textbackslash E}|)}\index{\textbackslash e=\texttt{\textbackslash e}|)}
\index{Mustererkennung|)}
\section{Programmablaufkontrolle}
Bei der Shell-Programmierung verf<72>gt man <20>ber <20>hnliche Konstrukte wie bei anderen Programmiersprachen, um den Ablauf des Programms zu steuern. Dazu geh<65>ren Funktionsaufrufe, Schleifen, Fallunterscheidungen und dergleichen.\nopagebreak
\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}).
\index{Kommentar|)}
\subsection{Auswahl der Shell (\texttt{\#!})}\label{auswahl_der_shell}\index{\#!!=\texttt{\#!!}|see{Shell / Auswahl der\ldots}}\index{Shell>Auswahl der\ldots|(textbf}
In der ersten Zeile eines Shell-Skriptes sollte definiert werden, mit welcher Shell das Skript ausgef<65>hrt werden soll. Das System <20>ffnet dann eine Subshell\index{Subshell} und f<>hrt das restliche Skript in dieser aus.
Die Angabe erfolgt <20>ber eine Zeile in der Form \verb\#!/bin/sh\, wobei unter \verb\/bin/sh\ die entsprechende Shell (in diesem Fall die Bourne-Shell) liegt. Dieser Eintrag wirkt nur dann, wenn er in der ersten Zeile des Skripts steht.
\index{Shell>Auswahl der\ldots|)}
\subsection{Null-Befehl (\texttt{:})}\label{null-befehl}\index{Null-Befehl|(textbf}\index{:=\texttt{:}|see{Null-Befehl}}\index{Doppelpunkt|see{Null-Befehl}}
Dieser Befehl tut nichts, au<61>er den Status 0 zur<75>ckzugeben. Er wird benutzt, um Endlosschleifen\index{Endlosschleife} zu schreiben (siehe unter \ref{while}), oder um leere Bl<42>cke in \texttt{if}- oder \texttt{case}-Konstrukten\index{if=\texttt{if}}\index{case=\texttt{case}} m<>glich zu machen.
\medskip\emph{Beispiel:} Pr<50>fen, ob jemand angemeldet ist:\nopagebreak
\LTXtable{\textwidth}{tab_beisp_nullbefehl.tex}
\index{Null-Befehl|)}
\subsection{Source (\texttt{.})}\label{source}\index{source=\texttt{source}|(textbf}\index{.=\texttt{.}|see{source}}
Ein Shell-Skript kann in keiner Weise Einflu<6C> auf die umgebende Shell nehmen. Das hei<65>t, da<64> es beispielsweise nicht m<>glich ist, in einem Skript Variablen zu setzen, die dann in der aufrufenden Shell zur Verf<72>gung stehen. Genauso wenig ist es m<>glich, da<64> ein Skript den Pfad <20>ndert, in dem man sich befindet. Der Grund f<>r dieses Verhalten ist die Systemsicherheit. Man will verhindern, da<64> ein Skript unbemerkt <20>nderungen an der Benutzerumgebung vornimmt.
Wenn es aber doch gew<65>nscht wird, da<64> ein Skript die Umgebung des Benutzers <20>ndern kann, dann mu<6D> es mit dem Source-Kommando aufgerufen werden. Das wird in der Form \verb\source skriptname\ bzw. \verb\. skriptname\ angegeben. Er bewirkt <20>hnliches wie ein \verb\#include\ in der Programmiersprache C.
Die `gesourcte' Datei wird eingelesen und ausgef<65>hrt, als ob ihr Inhalt an der Stelle des Befehls stehen w<>rde. Diese Methode wird zum Beispiel beim Login in den Konfigurationsdateien des Benutzers (z. B. \verb\.profile\, \verb\.bashrc\) oder w<>hrend des Bootvorgangs in den Init-Skripten benutzt, um immer wieder ben<65>tigte Funktionen (Starten eines Dienstes, Statusmeldungen auf dem Bildschirm etc.) in einer zentralen Datei pflegen zu k<>nnen (siehe Beispiel unter~\ref{init-skript}).
\index{source=\texttt{source}|)}
\subsection{Funktionen}\index{Funktion|(textbf}
Es ist in der Shell auch m<>glich, <20>hnlich wie in einer `richtigen' Programmiersprache Funktionen zu deklarieren und zu benutzen. Da die Bourne-Shell (\verb\sh\) nicht <20>ber Aliase\index{Aliase} verf<72>gt, k<>nnen einfache Funktionen als Ersatz dienen.
Der R<>ckgabewert einer Funktion ist gleich dem R<>ckgabewert des letzten in der Funktion aufgerufenen Kommandos.
\medskip\emph{Beispiel:} Die Funktion gibt die Anzahl der Dateien im aktuellen Verzeichnis zur<75>ck. Aufgerufen wird diese Funktion wie ein Befehl, also einfach durch die Eingabe von \verb\count\.\nopagebreak
\LTXtable{\textwidth}{tab_beisp_funktionen.tex}
\index{Funktion|)}
\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.
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}
\medskip\emph{Bedingungen f<>r Zeichenfolgen:}\nopagebreak
\LTXtable{\textwidth}{tab_bedingungen_zeichenfolgen.tex}
\medskip\emph{Ganzzahlvergleiche:}\nopagebreak
\LTXtable{\textwidth}{tab_bedingungen_ganzzahlvergleiche.tex}
\medskip\emph{Kombinierte Formen:}\nopagebreak
\LTXtable{\textwidth}{tab_bedingungen_kombinationen.tex}
\medskip\emph{Beispiele:}\nopagebreak
\LTXtable{\textwidth}{tab_beisp_bedingungen.tex}
\index{test=\texttt{test}|)}
\subsection{if\ldots}\label{if}\index{if=\texttt{if}|(textbf}\index{then=\texttt{then}|see{if}}\index{elif=\texttt{elif}|see{if}}\index{else=\texttt{else}|see{if}}\index{fi=\texttt{fi}|see{if}}
Die \texttt{if}-Anweisung in der Shell-Programmierung macht das gleiche wie in allen anderen Programmiersprachen, sie testet eine Bedingung auf Wahrheit und macht davon den weiteren Ablauf des Programms abh<62>ngig.
Die Syntax der \texttt{if}-Anweisung lautet wie folgt:\nopagebreak
\LTXtable{\textwidth}{tab_if.tex}
Wenn die \textsl{Bedingung1} erf<72>llt ist, werden die \textsl{Befehle1} ausgef<65>hrt; andernfalls, wenn die \textsl{Bedingung2} erf<72>llt ist, werden die \textsl{Befehle2} ausgef<65>hrt. Trifft keine Bedingung zu, sollen die \textsl{Befehle3} ausgef<65>hrt werden.
Bedingungen werden normalerweise mit dem Befehl \texttt{test}\index{test=\texttt{test}} (siehe unter \ref{bedingungen}) formuliert. Es kann aber auch der R<>ckgabewert\footnote{Siehe unter \ref{exitcode}.}\index{R<EFBFBD>ckgabewert} jedes anderen Kommandos ausgewertet werden. F<>r Bedingungen, die auf jeden Fall zutreffen sollen steht der Null-Befehl (\texttt{:}, siehe unter \ref{null-befehl}) zur Verf<72>gung.
\medskip\emph{Beispiele:} Man achte auf die Positionierung der Semikola\footnote{Und man verzeihe mir einen eventuell falschen Plural\ldots :-)}.\nopagebreak
\LTXtable{\textwidth}{tab_beisp_if.tex}
\index{if=\texttt{if}|)}
\subsection{case\ldots}\label{case}\index{case=\texttt{case}|(textbf}\index{esac=\texttt{esac}|see{case}}
\index{;;=\texttt{;;}|see{case}}
Auch die \texttt{case}-Anweisung ist vergleichbar in vielen anderen Sprachen vorhanden. Sie dient, <20>hnlich wie die \texttt{if}-Anweisung zur Fallunterscheidung\index{Fallunterscheidung|see{case}}\index{Fallunterscheidung|see{if}}. Allerdings wird hier nicht nur zwischen zwei F<>llen unterschieden (Entweder / Oder), sondern es sind mehrere F<>lle m<>glich. Man kann die \texttt{case}-Anweisung auch durch eine geschachtelte \texttt{if}-Anweisung v<>llig umgehen, allerdings ist sie ein elegantes Mittel um den Code lesbar zu halten.
Die Syntax der \texttt{case}-Anweisung lautet wie folgt:\nopagebreak
\LTXtable{\textwidth}{tab_case.tex}
Wenn der \textsl{Wert} mit dem \textsl{Muster1} <20>bereinstimmt, wird die entsprechende Befehlsfolge\index{Befehls>-folge} (\textsl{Befehle1}) ausgef<65>hrt, bei <20>bereinstimmung mit \textsl{Muster2} werden die Kommandos der zweiten Befehlsfolge\index{Befehls>-folge} (\textsl{Befehle2}) ausgef<65>hrt, usw. Der letzte Befehl in jeder Gruppe mu<6D> mit \texttt{;;} gekennzeichnet werden. Das bedeutet f<>r die Shell soviel wie `springe zum n<>chsten \texttt{esac}', so da<64> die anderen Bedingungen nicht mehr <20>berpr<70>ft werden.
In den Mustern sind die gleichen Meta-Zeichen\index{Meta-Zeichen} erlaubt wie bei der Auswahl von Dateinamen. Das bedeutet, da<64> man durch ein einfaches \texttt{*}\index{*=\texttt{*}} den Default-Pfad kennzeichnen kann. Dieser wird dann durchlaufen, wenn kein anderes Muster zutrifft. Wenn in einer Zeile mehrere Muster angegeben werden sollen, m<>ssen sie durch ein Pipezeichen (\texttt{|}, logisches ODER) getrennt werden.
\medskip\emph{Beispiele:}\nopagebreak
\LTXtable{\textwidth}{tab_beisp_case.tex}
\index{case=\texttt{case}|)}
\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}).}.
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.
\medskip\emph{Beispiele:}\nopagebreak
\LTXtable{\textwidth}{tab_beisp_for.tex}
\index{for=\texttt{for}|)}
\subsection{while\ldots}\label{while}\index{while=\texttt{while}|(textbf}\index{Schleife>while-=\texttt{while}-|see{while}}\index{Schleife>Fu<46>gesteuerte-|see{while}}\index{Fu<EFBFBD>gesteuerte Schleife|see{while}}
Die \texttt{while}-Schleife ist wieder ein Konstrukt, das einem aus vielen anderen Sprachen bekannt ist: die Kopfgesteuerte Schleife.
Die Syntax der \texttt{while}-Schleife lautet wie folgt:\nopagebreak
\LTXtable{\textwidth}{tab_while.tex}
Die \textsl{Befehle} werden so lange ausgef<65>hrt, wie die \textsl{Bedingung} erf<72>llt ist. Dabei wird die \textsl{Bedingung} vor der Ausf<73>hrung der \textsl{Befehle} <20>berpr<70>ft. 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<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{Beispiel:}\nopagebreak
\LTXtable{\textwidth}{tab_beisp_while.tex}
Eine Standard-Anwendung der \texttt{while}-Schleife ist der Ersatz f<>r die
Z<EFBFBD>hlschleife\index{Z<EFBFBD>hlschleife}\index{Schleife>Z<>hl-=Z<EFBFBD>hl-|see{Z<EFBFBD>hlschleife}}.
In anderen Sprachen kann man mit der
\texttt{for}-Schleife\index{for=\texttt{for}} eine
Laufvariable\index{Laufvariable} <20>ber einen bestimmten Wertebereich iterieren
lassen (\texttt{for i = 1 to 100...next}). Da das mit der \texttt{for}-Schleife
der Shell nicht geht\footnote{Auf einigen Systemen steht f<>r diesen Zweck auch
das Kommando \texttt{seq}\index{seq=\texttt{seq}} zur Verf<72>gung.},
ersetzt man die Funktion durch geschickte Anwendung der
\texttt{while}-Schleife:\nopagebreak
\LTXtable{\textwidth}{tab_beisp_while_for.tex}
\index{while=\texttt{while}|)}
\subsection{until\ldots}\label{until}\index{until=\texttt{until}|(textbf}\index{Schleife>until-=\texttt{until}-|see{until}}\index{Schleife>Kopfgesteuerte-|see{until}}\index{Kopfgesteuerte Schleife|see{until}}
Die \texttt{until}-Schleife ist das Gegenst<73>ck zur \texttt{while}-Schleife: die ebenfalls aus vielen anderen Sprachen bekannte Fu<46>gesteuerte Schleife.
Die Syntax der \texttt{until}-Schleife lautet wie folgt:\nopagebreak
\LTXtable{\textwidth}{tab_until.tex}
Die \textsl{Befehle} werden ausgef<65>hrt, bis die \textsl{Bedingung} erf<72>llt ist. Dabei wird die \textsl{Bedingung} nach der Ausf<73>hrung der \textsl{Befehle} <20>berpr<70>ft. 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<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{Beispiel:} Hier wird die Bedingung nicht per \texttt{test} sondern mit dem R<>ckgabewert\index{R<EFBFBD>ckgabewert} des Programms \texttt{grep}\index{grep=\texttt{grep}} formuliert.\nopagebreak
\LTXtable{\textwidth}{tab_beisp_until.tex}
\index{until=\texttt{until}|)}
\subsection{continue}\label{continue}\index{continue=\texttt{continue}|(textbf}
Die Syntax der \texttt{continue}-Anweisung lautet wie folgt:\nopagebreak
\LTXtable{\textwidth}{tab_continue.tex}
Man benutzt \texttt{continue} um die restlichen Befehle in einer Schleife zu <20>berspringen und mit dem n<>chsten Schleifendurchlauf anzufangen. Wenn der Parameter \textsl{n} angegeben wird, werden \textsl{n} Schleifenebenen <20>bersprungen.
\index{continue=\texttt{continue}|)}
\subsection{break}\label{break}\index{break=\texttt{break}|(textbf}
Die Syntax der \texttt{break}-Anweisung lautet wie folgt:\nopagebreak
\LTXtable{\textwidth}{tab_break.tex}
Mit \texttt{break} kann man die innerste Ebene (bzw. \textsl{n} Schleifenebenen) verlassen ohne den Rest der Schleife auszuf<75>hren.
\index{break=\texttt{break}|)}
\subsection{exit}\label{exit}\index{exit=\texttt{exit}|(textbf}
Die Syntax der \texttt{exit}-Anweisung lautet wie folgt:\nopagebreak
\LTXtable{\textwidth}{tab_exit.tex}
Die \texttt{exit}-Anweisung wird benutzt, um ein Skript zu beenden. Wenn der Parameter \textsl{n} angegeben wird, wird er von dem Skript als Exit-Code zur<75>ckgegeben.
\index{exit=\texttt{exit}|)}
\section{Befehlsformen}\label{befehlsformen}\index{Befehls>-formen|(textbf}
\index{\&=\texttt{\&}|(textbf}\index{;=\texttt{;}|(textbf}\index{( )=\texttt{( )}|(textbf}\index{\{ \}=\texttt{\{ \}}|(textbf}\index{Pipe|(textbf}\index{Backticks|(textbf}\index{\&\&=\texttt{\&\&}|(textbf}\index{!|!|=\texttt{!|!|}|(textbf}\index{Befehls>-substitution|(textbf}\index{Befehls>-folge|(textbf}\index{Befehls>-block|(textbf}
\index{!|=\texttt{!|}|see{Pipe}}\index{Substitution|see{Befehls-Subst.}}
Es gibt eine Reihe verschiedener M<>glichkeiten, Kommandos auszuf<75>hren:\nopagebreak
\LTXtable{\textwidth}{tab_befehlsformen.tex}
\medskip\emph{Beispiele:}\nopagebreak
\LTXtable{\textwidth}{tab_beisp_befehlsformen.tex}
\index{\&=\texttt{\&}|)}\index{;=\texttt{;}|)}\index{( )=\texttt{( )}|)}\index{\{ \}=\texttt{\{ \}}|)}\index{Pipe|)}\index{Backticks|)}\index{\&\&=\texttt{\&\&}|)}\index{!|!|=\texttt{!|!|}|)}\index{Befehls>-substitution|)}\index{Befehls>-folge|)}\index{Befehls>-block|)}
\index{Befehls>-formen|)}
\section{Datenstr<EFBFBD>me}\label{datenstrom}\index{Datenstr<EFBFBD>me|(textbf}
\index{<=\texttt{<}|(textbf}\index{<<=\texttt{<<}|(textbf}\index{!>\&=\texttt{!>\&}|(textbf}\index{!>\&-=\texttt{!>\&-}|(textbf}\index{<\&=\texttt{<\&}|(textbf}\index{<\&-=\texttt{<\&-}|(textbf}\index{!>=\texttt{!>}|(textbf}\index{!>!>=\texttt{!>!>}|(textbf}\index{Pipe|(textbf}\index{Dateideskriptor|(textbf}\index{Standard-Eingabe|(textbf}\index{Standard-Ausgabe|(textbf}\index{Standard-Fehlerausgabe|(textbf}\index{Here-Dokument|(textbf}
\index{Deskriptor|see{Dateideskriptor}}\index{Ausgabe|see{Standard-Ausgabe}}\index{Fehlerausgabe|see{Standard-Fehlerausgabe}}\index{Fehlermeldungen|see{Standard-Fehlerausgabe}}\index{stdin|see{Standard-Eingabe}}\index{stdout|see{Standard-Ausgabe}}\index{stderr|see{Standard-Fehlerausgabe}}
Eines der markantesten Konzepte, das in Shell-Skripten benutzt wird, ist das der Datenstr<74>me. Die meisten der vielen Unix-Tools bieten die M<>glichkeit, Eingaben aus der sogenannten Standard-Eingabe entgegenzunehmen und Ausgaben dementsprechend auf der Standard-Ausgabe zu machen. Es gibt noch einen dritten Kanal f<>r Fehlermeldungen, so da<64> man eine einfache M<>glichkeit hat, fehlerhafte Programmdurchl<68>ufe zu behandeln indem man die Fehlermeldungen von den restlichen Ausgaben trennt.
Es folgt eine Aufstellung der drei Standardkan<61>le:\nopagebreak
\LTXtable{\textwidth}{tab_datenstroeme_kanaele.tex}
Die standardm<64><6D>ige Eingabequelle oder das Ausgabeziel k<>nnen wie folgt ge<67>ndert werden:
\emph{Einfache Umlenkung:}\nopagebreak\index{Umlenkung}
\LTXtable{\textwidth}{tab_datenstroeme_einfach.tex}
Die Technik eines Here-Dokuments ist sicherlich auf den ersten Blick etwas
verwirrend. Man benutzt Here-Dokumente zum Beispiel in einer Situation, in der
ein fest vorgegebener Text ben<65>tigt wird. Man stelle sich ein Skript vor, das
jeden Tag eine Mail mit festem Inhalt und variablem Anhang verschickt.
Oder eine eingebaute Hilfe-Funktion, die bei falschen Parametern einen
Hilfetext ausgibt.
Nat<EFBFBD>rlich k<>nnte man zu diesem Zweck eine eigene Datei einrichten, aber das ist
eigentlich nicht notwendig. Man handelt sich nur <20>rger ein, wenn man das Skript
auf einen anderen Rechner portiert und die Datei vergi<67>t. Abgesehen davon - wo
legt man eine solche Datei sinnvoll ab?
Um diesem <20>rger zu entgehen, sollte man in einer solchen Situation ein
Here-Dokument benutzen.
\emph{Umlenkung mit Hilfe von Dateideskriptoren:}\nopagebreak
\LTXtable{\textwidth}{tab_datenstroeme_deskriptoren.tex}
\emph{Mehrfach-Umlenkung:}\index{Umlenkung}\index{Mehrfach-Umlenkung}\nopagebreak
\LTXtable{\textwidth}{tab_datenstroeme_mehrfach.tex}
Zwischen den Dateideskriptoren und einem Umlenkungssymbol darf kein Leerzeichen sein; in anderen F<>llen sind Leerzeichen erlaubt.
\medskip\emph{Beispiele:}\nopagebreak
\LTXtable{\textwidth}{tab_beisp_datenstroeme.tex}
\medskip\emph{Beispiel eines Here-Dokuments:}\nopagebreak
\LTXtable{\textwidth}{tab_beisp_datenstroeme_here-dokument.tex}
Gerade der Mechanismus mit dem Piping sollte nicht untersch<63>tzt werden. Er dient nicht nur dazu, relativ kleine Texte zwischen Tools hin- und herzureichen. An dem folgenden Beispiel soll die M<>chtigkeit dieses kleinen Zeichens gezeigt werden:\nopagebreak
Es ist mit den passenden Tools unter Unix m<>glich, eine ganze Audio-CD mit zwei Befehlen an der Kommandozeile zu duplizieren. Das erste Kommando veranla<6C>t, da<64> die TOC (Table Of Contents) der CD in die Datei cd.toc geschrieben wird. Das dauert nur wenige Sekunden. Die Pipe steckt im zweiten Befehl. Hier wird der eigentliche Inhalt der CD mit dem Tool `cdparanoia' ausgelesen. Da kein Dateiname angegeben wird, schreibt cdparanoia die Daten auf seine Standard-Ausgabe. Diese wird von dem Brennprogramm `cdrdao' <20>bernommen und in Verbindung mit der TOC `on the fly' auf die CD geschrieben.\label{cdrdao}\nopagebreak
\LTXtable{\textwidth}{tab_beisp_datenstroeme_cdparanoia.tex}
\index{<=\texttt{<}|)}\index{!>\&=\texttt{!>\&}|)}\index{!>\&-=\texttt{!>\&-}|)}\index{<\&=\texttt{<\&}|)}\index{<\&-=\texttt{<\&-}|)}\index{!>=\texttt{!>}|)}\index{!>!>=\texttt{!>!>}|)}\index{Pipe|)}\index{Dateideskriptor|)}\index{Standard-Eingabe|)}\index{Standard-Ausgabe|)}\index{Standard-Fehlerausgabe|)}
\index{Datenstr<EFBFBD>me|)}

34
wo_sind_unterschiede_zu_dos_batchdateien.tex Normal file
View File

@ -0,0 +1,34 @@
\chapter{Wo sind Unterschiede zu DOS-Batchdateien?}\index{DOS|(textbf}\index{Batchdateien|(textbf}
Unter DOS werden Batchdateien oft dazu benutzt, lange Kommandos abzuk<75>rzen um
die Tipparbeit zu vermindern, oder um sich das Merken von vielen Parametern zu
ersparen. Diese Aufgabe <20>berl<72><6C>t man unter Unix am besten den
Shell-Aliasen\index{Aliase} oder Shell-Funktionen.\bigskip
Shell-Skripte k<>nnen viel mehr als Batchdateien.\bigskip
Wie der Name schon sagt, sind Batchdateien im Wesentlichen nur ein `Stapel' von
Anweisungen, die nacheinander ausgef<65>hrt werden. Es stehen zwar auch einige
einfache Mechanismen zur Verzweigung zu Verf<72>gung, aber das entspricht bei
weitem nicht den M<>glichkeiten, die man an der Shell hat.
Interaktive Batchdateien sind unter DOS nicht m<>glich, in der Shell steht dazu
das \texttt{read}-Kommando zur Verf<72>gung. Ein Mechanismus wie die
Befehls-Substitution\footnote{Verarbeitung der Ausgabe von Kommandos mittels
Backticks (siehe unter Befehlsformen - \ref{befehlsformen})} fehlt v<>llig.
Ein weiteres interessantes Merkmal ist die Behandlung von Pipes. Es ist unter
DOS zwar m<>glich, zwei Kommandos durch eine Pipe zu verbinden. Aber da es unter
DOS keine M<>glichkeit gibt, zwei Kommandos parallel laufen zu lassen, wird das
erste Kommando vollst<73>ndig ausgef<65>hrt, seine Ausgabe in eine tempor<6F>re Datei
geschrieben und danach als Eingabe f<>r das zweite Kommando benutzt. Da<44> so ein
Verhalten unter Umst<73>nden schnell zu einer vollen Festplatte f<>hren kann, sieht
man bei dem Beispiel, in dem eine CD kopiert werden soll (Kapitel \ref{cdrdao},
Seite \pageref{cdrdao}).
Shell-Skripte kann man dagegen eher mit einer `richtigen' Programmiersprache
vergleichen. Es stehen alle Konstrukte zur Verf<72>gung, die eine
Programmiersprache auszeichnen (Funktionen, Schleifen, Fallunterscheidungen,
Variablen, etc).
\index{DOS|)}\index{Batchdateien|)}

18
wofuer_shell_programmierung.tex Normal file
View File

@ -0,0 +1,18 @@
\chapter{Wof<EFBFBD>r Shell-Programmierung?}
Shell-Skripte werden im Wesentlichen aus zwei Gr<47>nden geschrieben: Erstens,
weil man so st<73>ndig wiederkehrende Kommandos zusammenfassen kann, die man dann
mit einem einfachen Aufruf starten kann, und zweitens, weil man so einfache
Programme schreiben kann, die relativ intelligent Aufgaben erledigen k<>nnen.
Der erste Aspekt ist wichtig, wenn man beispielsweise regelm<6C><6D>ig auftretende
Aufgaben erledigen m<>chte, wie z. B. das Backup von Log-Dateien. In dem Fall
schreibt man sich ein Skript, das die Dateien archiviert, und sorgt daf<61>r, da<64>
dieses Skript in regelm<6C><6D>igen Abst<73>nden aufgerufen wird (per
Cron-Job\index{Cron-Job}).
Der zweite Fall tritt ein, wenn man eine mehr oder weniger komplexe Abfolge von
Befehlen ausf<73>hren m<>chte, die voneinander abh<62>ngen. Ein Skript das zum
Beispiel eine Audio-CD kopieren soll, sollte das Brennprogramm nur dann
aufrufen, wenn der Einlesevorgang erfolgreich abgeschlossen wurde.