WE CERTIFIED WEB ADMINISTRATOR I. Grundlagen der. Shellskript-Programmierung ... Offizielles Curriculum des Europäischen Webmasterverbandes

WE CERTIFIED WEB ADMINISTRATOR I Grundlagen der Shellskript-Programmierung............................................................. Offizielles Curriculum des Europäischen Webmasterverbandes

WE CERTIFIED WEB ADMINISTRATOR I Grundlagen der Shellskript-Programmierung............................................................. Art.-Nr. 011188861 Versionsnr. 3.0.1 vom 05.07.2012 Autor: Dorian Karnbaum, Marc Remolt webmasters akademie Nürnberg GmbH, Nürnberg, Germany Das vorliegende Schulungsskript ist urheberrechtlich geschützt. Alle Rechte vorbehalten. Die Verwendung der Texte und Abbildungen, auch auszugsweise, ist ohne schriftliche Genehmigung der webmasters akademie Nürnberg GmbH urheberrechtswidrig und daher strafbar. Dies gilt insbesondere für die Vervielfältigung, Übersetzung oder Verwendung in elektronischen Systemen sowie für die Verwendung in Schulungsveranstaltungen. Die Informationen in diesem Schulungsskript wurden mit größter Sorgfalt erarbeitet. Trotzdem können Fehler nicht vollständig ausgeschlossen werden. Autoren und Herausgeber übernehmen keine juristische Verantwortung oder irgendeine Haftung für eventuell verbliebene fehlerhafte Angaben und deren Folgen.

Inhaltsverzeichnis 1 Allgemeine Einführung.................................................... 9 1.1 Allgemeine Vorbereitungen zum Lernheft....................................... 9 1.1.1 Voraussetzungen............................................................... 9 1.1.2 Einrichten der Arbeitsumgebung................................................ 9 1.1.3 Umgang mit diesem Lernheft.................................................. 10 1.1.4 Aufgaben zur Selbstkontrolle................................................... 11 2 Grundlagen.............................................................. 12 2.1 Wiederholung................................................................. 12 2.1.1 Umleitungen.................................................................. 12 2.1.2 Pipes.......................................................................... 12 2.1.3 Kommandoverknüpfungen.................................................... 13 2.1.4 Kommandosubstitution........................................................ 13 2.2 Aufbau eines Shellskriptes..................................................... 14 2.2.1 Shellskripte als Folge von Shellkommandos..................................... 14 2.2.2 Der Shebang................................................................... 15 2.2.3 Kommentare.................................................................. 15 2.3 Ausführen eines Shellskriptes.................................................. 15 2.3.1 Skript als Parameter der Shell ausführen........................................ 15 2.3.2 Skript direkt ausführen......................................................... 15 2.4 Zusammenfassung............................................................. 16 3 Variablen und Zuweisungen.............................................. 17 3.1 Variablenzugriff................................................................ 17 3.2 Methoden der Zuweisung...................................................... 17 3.2.1 Einfache Zuweisung........................................................... 17 3.2.2 Ausgabe eines Kommandos zuweisen.......................................... 17 3.3 Ausgeben von Variablen....................................................... 18 3.3.1 echo........................................................................... 18 3.3.2 Bedeutung der Anführungszeichen bei echo................................... 18 3.3.3 Abgrenzung des Variablennamens............................................. 20 3.4 Besondere Zuweisungen....................................................... 20 3.4.1 Stringverkettung.............................................................. 20 3.4.2 Löschen von Variablen......................................................... 21 3.4.3 Zuweisung mit Standardwert.................................................. 21 3.5 Umgebungsvariablen.......................................................... 22 3.5.1 Konzept....................................................................... 22 3.5.2 $PWD......................................................................... 22 3.5.3 $SHELL........................................................................ 22 3.5.4 $LOGNAME.................................................................... 22 3.5.5 $PATH......................................................................... 22 3.5.6 $LANG......................................................................... 22 3.5.7 $PS1........................................................................... 23 3.5.8 $RANDOM..................................................................... 23 3.6 Zusammenfassung............................................................. 24 4 Formatierte Ausgabe..................................................... 25 4.1 Erweitertes echo............................................................... 25 4.1.1 Zeilenumbruch unterdrücken.................................................. 25 4.1.2 Erweiterte Formatierungen..................................................... 26

4.2 printf......................................................................... 26 4.3 Zusammenfassung............................................................ 27 5 Shell-Expansion und Strings.............................................. 28 5.1 Dateinamensexpansion........................................................ 28 5.1.1 *.............................................................................. 28 5.1.2?.............................................................................. 29 5.1.3 [].............................................................................. 29 5.1.4 @()............................................................................ 29 5.2 Musterexpansion.............................................................. 30 5.2.1 {a,b,c,d}....................................................................... 30 5.2.2 {a..z}.......................................................................... 31 5.3 Stringbehandlung............................................................. 31 5.3.1 Länge eines Strings ausgeben................................................. 31 5.3.2 Teilstrings nach Position ausschneiden......................................... 31 5.3.3 Teilstrings nach Muster entfernen.............................................. 32 5.3.4 Suchen und ersetzen.......................................................... 33 5.4 Zusammenfassung............................................................ 34 6 Weitere Shellfunktionen.................................................. 35 6.1 Blöcke........................................................................ 35 6.2 set............................................................................ 36 6.2.1 Anzeige aller Variablen und Funktionen........................................ 36 6.2.2 Verhalten der Shell einstellen.................................................. 36 6.2.3 Parametervariablen setzen.................................................... 37 6.3 Berechnungen................................................................ 37 6.3.1 Ohne Rückgabe............................................................... 37 6.3.2 Mit Rückgabe................................................................. 38 6.4 source........................................................................ 38 6.5 Zusammenfassung............................................................ 39 7 Eingabe und Parameter.................................................. 40 7.1 Parameter an ein Shellskript übergeben........................................ 40 7.1.1 Regeln bei der Übergabe...................................................... 40 7.1.2 Die Parametervariablen........................................................ 40 7.1.3 Weitere Spezialvariablen....................................................... 41 7.1.4 Mehr als neun Parameter verarbeiten.......................................... 41 7.1.5 Mit set Parametervariablen setzen............................................. 42 7.2 Einlesen von Benutzereingaben mit read....................................... 43 7.3 Zusammenfassung............................................................ 44 8 Tests und Bedingungen.................................................. 45 8.1 Tests.......................................................................... 45 8.2 Die Spezialvariable $?.......................................................... 45 8.3 Dateitests..................................................................... 45 8.4 Zahlentests................................................................... 46 8.5 Stringtests und Stringvergleiche............................................... 46 8.6 Schreibweise der Bourne-Shell................................................. 48 8.7 Kommandotests............................................................... 48 8.8 Zusammenfassung............................................................ 48 9 Verzweigungen.......................................................... 50 9.1 Entscheidungen treffen........................................................ 50 9.2 if.............................................................................. 50

9.2.1 Syntax......................................................................... 50 9.2.2 if-else.......................................................................... 51 9.2.3 if-elif-else...................................................................... 52 9.3 case........................................................................... 54 9.4 Zusammenfassung............................................................. 56 10 Schleifen................................................................ 57 10.1 Wiederholtes Ausführen von Codeblöcken..................................... 57 10.2 Die while-schleife.............................................................. 57 10.2.1 Syntax......................................................................... 57 10.2.2 Eine while-schleife ohne Abbruch-Modifikator.................................. 58 10.2.3 While zum zeilenweisen Einlesen einer Textdatei............................... 58 10.3 Die for-schleife................................................................ 59 10.3.1 Syntax......................................................................... 60 10.3.2 Dynamisch erzeugte Listen..................................................... 60 10.4 Zusammenfassung............................................................. 61 11 Ergänzende Linux-Kommandos........................................... 63 11.1 Kommandos als Helfer......................................................... 63 11.2 head und tail.................................................................. 63 11.2.1 head.......................................................................... 63 11.2.2 tail............................................................................ 64 11.2.3 Zeilen in der Mitte einer Datei auslesen......................................... 64 11.3 basename und dirname........................................................ 65 11.3.1 basename..................................................................... 65 11.3.2 dirname....................................................................... 65 11.4 cut............................................................................ 65 11.4.1 Ausschneiden nach Zeichen.................................................... 65 11.4.2 Ausschneiden nach Feldern.................................................... 67 11.5 tr.............................................................................. 68 11.6 Zusammenfassung............................................................. 68 12 Signalverarbeitung...................................................... 70 12.1 Prozesse und Signale.......................................................... 70 12.1.1 Signale senden mit kill......................................................... 70 12.1.2 Wichtige Signale............................................................... 70 12.1.3 Die Spezialvariable $$.......................................................... 71 12.2 Signale einfangen mit trap..................................................... 72 12.2.1 trap........................................................................... 72 12.2.2 Aufräumen bei Skriptende..................................................... 72 12.3 Zusammenfassung............................................................. 72 13 Fortgeschrittene Parameterauswertung................................... 74 13.1 Einschränkungen der Parametervariablen...................................... 74 13.2 Verarbeiten von Parametern mit getopts....................................... 75 13.3 Zusammenfassung............................................................. 76 14 Reguläre Ausdrücke...................................................... 78 14.1 Konzept....................................................................... 78 14.2 Metazeichen................................................................... 78 14.2.1 Zeilenanfang und Zeilenende.................................................. 79 14.2.2 Zeichenklassen................................................................ 79 14.2.3 Posix Zeichenklassen........................................................... 80 14.2.4 Negation von Zeichenklassen.................................................. 80

14.2.5 Ein beliebiges Zeichen......................................................... 81 14.2.6 Auskommentieren von Sonderzeichen......................................... 81 14.3 Quantoren.................................................................... 81 14.3.1 Allgemeine Quantoren........................................................ 81 14.3.2 Spezielle Quantoren........................................................... 82 14.4 Klammern..................................................................... 82 14.4.1 Quantifizierung ganzer Ausdrücke............................................. 82 14.4.2 Alternationen................................................................. 83 14.4.3 Zwischenspeichern von Treffern............................................... 83 14.5 Rückwärtsreferenzen.......................................................... 83 14.6 egrep......................................................................... 84 14.6.1 Syntax........................................................................ 84 14.6.2 Optionen..................................................................... 85 14.7 Zusammenfassung............................................................ 86 15 Einführung in Sed und Awk............................................... 88 15.1 Sed........................................................................... 88 15.1.1 Zeilen löschen................................................................. 88 15.1.2 Nur bestimmte Zeilen ausgeben............................................... 89 15.1.3 Suchen und ersetzen.......................................................... 89 15.1.4 Löschen....................................................................... 90 15.2 Awk........................................................................... 91 15.2.1 Syntax........................................................................ 91 15.2.2 Feldtrenner ändern............................................................ 91 15.2.3 awk und reguläre Ausdrücke................................................... 92 15.3 Zusammenfassung............................................................ 94 Lösungen........................................................................ 97 Index............................................................................ 105

3.1 VARIABLENZUGRIFF 17 3 Variablen und Zuweisungen In dieser Lektion lernen Sie: wie die Shell mit Variablen arbeitet. welche Bedeutung die Anführungszeichen haben. was echo tut. was Umgebungsvariablen sind. 3.1 Variablenzugriff Wenn Sie schon mit anderen Programmiersprachen gearbeitet haben, kennen Sie eventuell schon verschiedene Namensgebungen für Variablen. In Javascript zum werden Variablen mit var name initialisiert, in PHP können Sie jede Variable einfach verwenden. Dafür müssen Sie vor dem Namen ein Dollarzeichen schreiben, also zum $name. Auf der Shell wird unterschieden, ob Sie auf die Variable lesend zugreifen, also den Wert auslesen, oder schreibend, also etwas in die Variable hineinschreiben. Bei lesendem Zugriff müssen Sie vor dem Variablennamen ein Dollarzeichen schreiben, bei schreibendem Zugriff müssen Sie es weglassen. 3.2 Methoden der Zuweisung 3.2.1 Einfache Zuweisung Eine einfache Zuweisung wird mit dem Gleichheitszeichen (=) durchgeführt. Im Gegensatz zu vielen anderen Programmiersprachen dürfen Sie um das = keine Leerzeichen setzen. root@gollum ~ # erfolg="so ist es richtig" root@gollum ~ # erfolg = "Das wird so nicht funktionieren" bash: erfolg: command not found Beachten Sie, dass Sie bei der Zuweisung, wie gerade erwähnt, kein Dollarzeichen vor dem Namen schreiben dürfen. 3.2.2 Ausgabe eines Kommandos zuweisen Wenn Sie die Ausgabe eines Kommandos einer Variablen zuweisen möchen, verwenden Sie die Kommandosubstitution. root@gollum ~ # inhalt=$(cat /etc/passwd) Hier wird der Inhalt von /etc/passwd der Variablen $inhalt zugewiesen.

18 3 VARIABLEN UND ZUWEISUNGEN 3.3 Ausgeben von Variablen 3.3.1 echo Um den Inhalt einer Variablen auf dem Bildschirm auszugeben, verwenden Sie das Kommando echo. root@gollum ~ # inhalt="hallo Welt" root@gollum ~ # echo $inhalt Hallo Welt Sie können an dem sehr schön sehen, wann Sie das Dollarzeichen verwenden müssen und wann nicht. 3.3.2 Bedeutung der Anführungszeichen bei echo Keine Anführungszeichen Wenn Sie Text oder Variableninhalte mit echo ausgeben und keine Anführungszeichen setzen, werden sämtliche Formatierungen durch ein einzelnes Leerzeichen ersetzt. root@gollum ~ # inhalt="das ist ein Test" root@gollum ~ # echo $inhalt Das ist ein Test Die vielen zusätzlichen Leerzeichen sind verschwunden, aber auch Tabulatoren oder Zeilenumbrüche wurden entfernt. Einfache Anführungszeichen In einfachen Anführungszeichen bleiben alle Formatierungen erhalten. root@gollum ~ # echo 'Das ist ein Test' Das ist ein Test Allerdings werden fast alle Sonderzeichen nicht ausgewertet, sondern ebenfalls wörtlich ausgegeben, zum auch Variableninhalte. root@gollum ~ # inhalt="das ist ein Test" root@gollum ~ # echo $inhalt $inhalt Nicht der Variableninhalt, sondern nur der Name wird ausgegeben. Doppelte Anführungszeichen In doppelten Anführungszeichen schließlich werden sowohl Variablen ausgewertet, als auch Formatierungen erhalten. root@gollum ~ # inhalt="das ist ein Test" root@gollum ~ # echo "$inhalt" Das ist ein Test

3.3 AUSGEBEN VON VARIABLEN 19 Diese Unterschiede sind besonders wichtig, wenn es darum geht, die Ausgabe von Programmen erst in einer Variablen zwischenzuspeichern und dann später auszugeben. Vergleichen Sie folgende zwei e: root@gollum ~ # root_dir=$(ls -l /) root@gollum ~ # echo $root_dir insgesamt 73 drwxr-xr-x 2 mremolt root 4096 2008-11-28 16:50 backups drwxrxr-x 2 root root 4096 2008-12-18 10:07 bin drwxr-xr-x 4 root root 1024 2008-12-16 11:30 boot lrwxrwxrwx 1 root root 11 2008-08-22 18:30 cdrom -> media/cdrom drwxr-xr-x 14 root root 14460 2009-01-11 09:54 dev drwxr-xr-x 160 root root 12288 2009-01-11 11:36 etc drwxr-xr-x 5 root root 61 2008-09- 26 12:13 home drwxr-xr-x 2 root root 6 2008-07-02 11:47 initrd lrwxrwxrwx 1 root root 32 2008-12-01 08:53 initrd.img -> boot/initrd.img-2.6.27-9- generic lrwxrwxrwx 1 root root 32 2008-10-30 15:22 initrd.img.old -> boot/initrd.img-2.6.27-7-generic drwxr-xr-x 15 root root 8192 2009-01-08 10:19 lib drwxr-xr-x 4 root root 4096 2008-10-30 14:44 lib32 lrwxrwxrwx 1 root root 4 2008-08-22 18:30 lib64 -> /lib drwxr-xr-x 4 root root 110 2009-01-11 09:54 media drwxr-xr-x 2 root root 6 2008-04-15 07:53 mnt drwxr-xr-x 13 mremolt root 4096 2008-11-24 17:40 opt dr-xr-xr-x 171 root root 0 2009-01-11 09:53 proc drwxr-xr-x 19 root root 4096 2008-12-18 10:31 root drwxrxr-x 2 root root 8192 2008-12-18 10:07 sbin drwxr-xr-x 2 root root 6 2008-07-02 11:47 srv drwxr-xr-x 12 root root 0 2009-01-11 09:53 sys drwxrwxrwt 14 root root 4096 2009-01-11 13:50 tmp drwxr-xr-x 13 root root 151 2008-08- 24 19:07 usr drwxr-xr-x 16 root root 4096 2008-09-10 14:01 var lrwxrwxrwx 1 root root 29 2008-12-01 08:53 vmlinuz -> boot/vmlinuz-2.6.27-9-generic lrwxrwxrwx 1 root root 29 2008-10-30 15:22 vmlinuz.old -> boot/vmlinuz- 2.6.27-7-generic root@gollum ~ # echo "$root_dir" insgesamt 73 drwxr-xr-x 2 mremolt root 4096 2008-11-28 16:50 backups drwxr-xr-x 2 root root 4096 2008-12-18 10:07 bin drwxr-xr-x 4 root root 1024 2008-12-16 11:30 boot lrwxrwxrwx 1 root root 11 2008-08-22 18:30 cdrom -> media/cdrom drwxr-xr-x 14 root root 14460 2009-01-11 09:54 dev drwxr-xr-x 160 root root 12288 2009-01-11 11:36 etc drwxr-xr-x 5 root root 61 2008-09-26 12:13 home drwxr-xr-x 2 root root 6 2008-07-02 11:47 initrd lrwxrwxrwx 1 root root 32 2008-12-01 08:53 initrd.img -> boot/initrd.img-2.6.27-9-generic lrwxrwxrwx 1 root root 32 2008-10-30 15:22 initrd.img.old -> boot/initrd.img-2.6.27-7-generic drwxr-xr-x 15 root root 8192 2009-01-08 10:19 lib drwxr-xr-x 4 root root 4096 2008-10-30 14:44 lib32 lrwxrwxrwx 1 root root 4 2008-08-22 18:30 lib64 -> /lib drwxr-xr-x 4 root root 110 2009-01-11 09:54 media drwxr-xr-x 2 root root 6 2008-04-15 07:53 mnt drwxr-xr-x 13 mremolt root 4096 2008-11-24 17:40 opt dr-xr-xr-x 171 root root 0 2009-01-11 09:53 proc drwxr-xr-x 19 root root 4096 2008-12-18 10:31 root drwxr-xr-x 2 root root 8192 2008-12-18 10:07 sbin drwxr-xr-x 2 root root 6 2008-07-02 11:47 srv drwxr-xr-x 12 root root 0 2009-01-11 09:53 sys drwxrwxrwt 14 root root 4096 2009-01-11 13:50 tmp drwxr-xr-x 13 root root 151 2008-08-24 19:07 usr drwxr-xr-x 16 root root 4096 2008-09-10 14:01 var

20 3 VARIABLEN UND ZUWEISUNGEN lrwxrwxrwx 1 root root 29 2008-12-01 08:53 vmlinuz -> boot/vmlinuz- 2.6.27-9-generic lrwxrwxrwx 1 root root 29 2008-10-30 15:22 vmlinuz.old -> boot/vmlinuz-2.6.27-7-generic Sie sehen, ohne die doppelten Anführungszeichen werden alle Formatierungen, die die Ausgabe von ls erst lesbar machen, vernichtet. 3.3.3 Abgrenzung des Variablennamens In vielen Fällen weiß die Shell von selbst, wo ein Variablenname endet. root@gollum ~ # name="marc" root@gollum ~ # echo "Mein Name ist $name und ich schreibe das hier." Mein Name ist Marc und ich schreibe das hier. In anderen Fällen ist aber nicht klar, wo der Variablenname endet. root@gollum ~ # farbe="gelb" root@gollum ~ # echo "Das ist ein $farbees Postauto." Das ist ein Postauto. Die Shell kann nicht wissen, dass die Variable $farbe heißt und der string es einfach angehängt wurde. Also sucht sie nach einer Variablen $farbees, die es nicht gibt. Das Problem lösen Sie, indem Sie den Varaiblennamen mit geschweiften Klammern abgrenzen. root@gollum ~ # echo "Das ist ein ${farbe}es Postauto." Das ist ein gelbes Postauto. Nun ist der Shell klar, was Sie meinen. Viele Shellprogrammierer verwenden die geschweiften Klammern sogar um jede Variable, nur um sicher zu gehen. Ich überlasse es Ihnen, ob Sie nur bei Bedarf, oder immer die Klammern setzen. 3.4 Besondere Zuweisungen 3.4.1 Stringverkettung Wenn Sie die Stringinhalte mehrerer Variablen einer neuen zuweisen wollen, geht das ziemlich einfach. root@gollum ~ # text1="hallo" root@gollum ~ # text2="welt" root@gollum ~ # text3="$text1 $text2" root@gollum ~ # echo $text3 Hallo Welt Wenn zwischen den Variablen kein Leerraum sein darf, können Sie die Variablennamen, wie gerade gelernt, abgrenzen. root@gollum ~ # farbe="gelb"

3.4 BESONDERE ZUWEISUNGEN 21 root@gollum ~ # name="marc" root@gollum ~ # text="das ist ein ${farbe}es Postauto und es gehört ${name}." root@gollum ~ # echo $text Das ist ein gelbes Postauto und es gehört Marc. 3.4.2 Löschen von Variablen Wenn Sie eine gesetzte Variable wieder löschen wollen, verwenden Sie das Kommando unset. root@gollum ~ # text="hallo Welt" root@gollum ~ # echo $text Hallo Welt root@gollum ~ # unset text root@gollum ~ # echo $text 3.4.3 Zuweisung mit Standardwert Manchmal wollen Sie den Inhalt einer Variablen einer anderen zuweisen, Sie wissen aber noch nicht sicher, ob diese Variable schon einen Wert hat. Das ist besonders häufig bei Benutzereingaben der Fall. Da der Benutzer auch entscheiden kann, gar nichts einzugeben, können Sie nicht sicher davon ausgehen, dass in einer Variablen ein Wert liegt. Deshalb bietet die Shell die Möglichkeit, eine Variable mit einem Standardwert zu initialisieren, wenn noch kein Wert zugewiesen wurde. root@gollum ~ # echo $test root@gollum ~ # test=${test:-nix drin} root@gollum ~ # echo $test nix drin root@gollum ~ # test="was drin" root@gollum ~ # test=${test:-nix drin} root@gollum ~ # echo $test was drin Die Variable $test ist nicht belegt. Dann wird ihr mit einer speziellen Zuweisung der Inhalt von $test zugewiesen, also im Prinzip von sich selbst. Normalerweise würde das so aussehen: root@gollum ~ # test=${test} Durch das :- wird der Variablen jedoch der nachfolgende Text zugewiesen, wenn in $text noch kein Inhalt ist. Beim zweiten Versuch ist die Variable schon belegt, also wird der Alternativtext nicht verwendet.

22 3 VARIABLEN UND ZUWEISUNGEN 3.5 Umgebungsvariablen 3.5.1 Konzept Die Shell selbst arbeitet sehr viel mit Variablen, um Einstellungen vorzunehmen oder Informationen auszugeben. Sie werden im Laufe des Skriptes noch mehrere dieser Variablen kennenlernen. Allen gemein ist, dass sie komplett in Großbuchstaben geschrieben sind. 3.5.2 $PWD In $PWD legt die Shell das aktuelle Arbeitsverzeichnis ab, also die Ausgabe, die Sie beim Aufruf des Kommandos pwd erhalten. Genaugenommen macht dieser Befehl auch nichts anderes, als den Inhalt von $PWD auszugeben. root@gollum ~ # pwd /var/log root@gollum ~ # echo $PWD /var/log 3.5.3 $SHELL In $SHELL ist der Name der aktuell laufenden Shell abgelegt. Wenn Sie in einem Shellskript prüfen müssen, welche Shell dieses Skript gerade ausführt, verwenden Sie diese Variable. root@gollum ~ # echo $SHELL /bin/bash 3.5.4 $LOGNAME In $LOGNAME ist der Benutzername abgelegt, mit dem Sie aktuell eingeloggt sind. Wenn Sie also zum in einem Shellskript prüfen müssen, ob dieses als root ausgeführt wird, verwenden Sie $LOGNAME. 3.5.5 $PATH Diese Variable sollten Sie bereits kennen. In $PATH steht, in welchen Verzeichnissen die Shell nach ausführbaren Dateien sucht. 3.5.6 $LANG In $LANG steht, welche Sprache Ihre Shell gerade verwendet. Viele Befehle ziehen aus dieser Variablen die Information, in welcher Sprache sie ihre Ausgabe formatieren sollen. root@gollum ~ # echo $LANG de_de.utf-8 root@gollum ~ # ls --help Aufruf: ls [OPTION]... [DATEI]... Auflistung von Informationen der DATEIen (Standardvorgabe ist das momentane Verzeichnis). Alphabetisches Sortieren der Einträge, falls weder -cftuvsux noch --sort angegeben. Erforderliche Argumente für lange Optionen sind auch für kurze erforderlich.

3.5 UMGEBUNGSVARIABLEN 23... root@gollum ~ # LANG="en_US" root@gollum ~ # ls --help Usage: ls [OPTION]... [FILE]... List information about the FILEs (the current directory by default). Sort entries alphabetically if none of -cftuvsux nor --sort. Mandatory arguments to long options are mandatory for short options too.... Sie sehen, ls und auch viele andere Programme reagieren sofort, wenn Sie die Sprache der Shell ändern. 3.5.7 $PS1 In $PS1 ist der Prompt abgelegt. root@gollum ~ # echo $PS1 ${debian_chroot:+($debian_chroot)}\u@\h:\w\$ Wenn Sie $PS1 verändern, verändern Sie auch den Prompt. root@gollum ~ # PS1="# " # Der Prompt besteht nun nur noch aus der Raute und einem Leerzeichen. 3.5.8 $RANDOM Mit $RANDOM ist ein Zufallszahlengenerator verknüpft. Jedes Mal, wenn Sie $RANDOM ausgeben, erhalten Sie eine zufällige Zahl. Daher werden die folgenden e bei Ihnen auch ein wenig anders aussehen. root@gollum ~ # echo $RANDOM 7320 root@gollum ~ # echo $RANDOM 8338 root@gollum ~ # echo $RANDOM 19370 root@gollum ~ # echo $RANDOM 13033 root@gollum ~ # echo $RANDOM 31364 root@gollum ~ # echo $RANDOM 14454

24 3 VARIABLEN UND ZUWEISUNGEN 3.6 Zusammenfassung Variablen bilden das Rückgrat jeder Programmiersprache. Die Shell macht da keine Ausnahme. In dieser Lektion haben Sie gelernt, wie Sie mit Variablen arbeiten, also ihnen Werte zuweisen, diese wieder auslesen oder auch Standardwerte zuweisen. Sie haben gelernt, mit echo Inhalte auszugeben und welche Bedeutung die verschiedenen Anführungszeichen haben. Schließlich kennen Sie nun einige nützliche Variablen, die von der Shell zur Verfügung gestellt werden. Aufgaben zur Selbstkontrolle Fragen 1. Welche der folgenden Variablenzuweisungen sind korrekt? Was genau sind die Fehler in den ungültigen Zuweisungen? name = Wert name=wert name="wert" name=ein Wert name="ein Wert" name= Ein Wert $name="ein Wert" 2. Was ist die Ausgabe der folgenden Kommandos? Die Variable name enthält den Wert "Welt". echo "Hallo Welt" echo "Hallo $name" echo Hallo $name echo Hallo $name echo Hallo name 3. Wie können Sie einen Variablennamen vom umgebenden Text abgrenzen, wenn die Shell es nicht automatisch schafft? : echo "Ein $platzter Platz ist nicht schlecht." Die Variable platz enthält den String "zwei" und soll mit dem echo ausgegeben werden. 4. Wie können Sie einer Variablen name den Standardwert "Unbekannt" zuweisen, wenn sie noch keinen Inhalt hat? Wenn die Variable bereits gefüllt ist, soll der Inhalt nicht verändert werden. 5. Wie können Sie erreichen, dass Ihr Shellprompt "Guten Morgen# " anzeigt? 6. Was ist die Ausgabe des Kommandos echo $RANDOM?

INDEX 105 Index # $# 41 $$ 71 $(( Rechenoperation )) 38 $? 45 $@ 41 ${#var} 31 ${10} 42 ${var x y}31 ${var#muster} 32 ${var%muster} 33 ${var/muster/ersatz} 33 $0 41 $1 40 $LANG 22 $LOGNAME 22 $PATH 22 $PS1 23 $PWD 22 $RANDOM 23 $SHELL 22 (( Rechenoperation )) 37 * 28? 29 @() 29 {a,b,c,d} 30 {a..z} 31 A Alternationen 83 Ascii-Tabelle 47 Awk 91 awk 91 B basename 65 Benutzereingaben 43 Berechnungen 37 Blöcke 35 Bourne-Shell 48 C case 54 cut 65 D Dateitests 45 dirname 65 Doppelte Anführungszeichen 18 E echo 18 egrep 84 Einfache Anführungszeichen 18 elif 52 else 51 Exit-Status 48 F Formatierungen 26 for-schleife 59 60 G getopts 75 globbing 28 H head 63 I if 50 51 if-elif-else 52 if-else 51 IFS 42 K kill 70 Kommandosubstitution 13 Kommandotest 48 Kommandoverknüpfungen 13 Kommentare 15 M Metazeichen 78 N Negation 80 P Parametervariablen 40, 74 Pipes 12 Posix 80 printf 26 Prozesse 70 Q Quantifizierung 82 Quantoren 81 R read 43 regex 78 Reguläre Ausdrücke 78

106 INDEX S sed 88 set 36 Shebang 15 shopt 30 Signale 70 Sonderzeichen 81 source 38 Spezialvariable 71 Spezialvariablen 41 Stringbehandlung 31 Stringtest 46 Stringvergleich 46 Stringverkettung 20 T tail 64 tr 68 trap 72 U Umleitungen 12 unset 21 W while-schleife 57 Z Zahlentests 46 Zeichenklassen 79 Zeilenanfang 79 Zeilenende 79 Zuweisung 17 Zwischenspeichern 83