Normalerweise, wenn Leute von einer "Shell-Skriptsprache" sprechen, denken sie an bash, ksh, sh oder andere ähnliche Linux/Unix-Skriptsprachen. Eine Skriptsprache ist eine weitere Möglichkeit, mit dem Computer zu kommunizieren. Mit einer grafischen Fensteroberfläche (ob Windows oder Linux, spielt keine Rolle) kann der Benutzer die Maus bewegen und auf verschiedene Objekte klicken, wie Schaltflächen, Listen, Kontrollkästchen usw. Aber diese Methode ist sehr unbequem, jedes Mal, wenn der Benutzer möchte, dass der Computer/Server dieselbe Aufgabe ausführt (zum Beispiel Fotos im Stapel konvertieren oder neue Filme, MP3s usw. herunterladen). Um all diese Dinge einfach und automatisiert zu machen, können wir Shell-Skripte verwenden.
Einige Programmiersprachen, wie Pascal, FoxPro, C, Java usw., müssen vor der Ausführung kompiliert werden. Sie benötigen einen geeigneten Compiler, damit unser Code eine bestimmte Aufgabe erfüllen kann.
Andere Programmiersprachen, wie PHP, JavaScript, Visual Basic usw., benötigen keinen Compiler; stattdessen benötigen sie einen Interpreter, und wir können Programme ausführen, ohne den Code zu kompilieren.
Shell-Skripte sind ebenfalls wie Interpreter, aber sie werden normalerweise verwendet, um externe kompilierte Programme aufzurufen. Dann erfassen sie die Ausgabeergebnisse, Exit-Codes und behandeln sie je nach Situation.
Eine der beliebtesten Shell-Skriptsprachen in der Linux-Welt ist bash. Und ich denke (das ist meine eigene Meinung), der Grund ist, dass die bash-Shell Benutzern standardmäßig ermöglicht, bequem durch die Befehlsgeschichte (zuvor ausgeführte Befehle) zu navigieren. Im Gegensatz dazu erfordert ksh einige Anpassungen an .profile oder das Erinnern an einige "magische" Tastenkombinationen, um den Verlauf zu überprüfen und Befehle zu korrigieren.
In Ordnung, ich denke, diese Einführung reicht aus. Welche Umgebung am besten zu Ihnen passt, überlasse ich Ihnen zu entscheiden. Von nun an werde ich nur über bash und seine Skripte sprechen. In den folgenden Beispielen verwende ich CentOS 6.6 und bash-4.1.2. Bitte stellen Sie sicher, dass Sie dieselbe Version oder eine höhere haben.
Shell-Skript-Streams
Die Shell-Skriptsprache ist wie ein Gespräch mit mehreren Leuten. Sie müssen sich einfach alle Befehle als Menschen vorstellen, die Ihnen helfen können, Dinge zu erledigen, solange Sie sie auf die richtige Weise fragen. Zum Beispiel möchten Sie ein Dokument schreiben. Zuerst brauchen Sie Papier. Dann müssen Sie jemandem den Inhalt sagen, damit er ihn für Sie schreiben kann. Schließlich möchten Sie ihn irgendwo speichern. Oder sagen wir, Sie möchten ein Haus bauen, also müssen Sie die richtigen Leute anheuern, um das Grundstück zu räumen. Nachdem sie sagen "die Arbeit ist erledigt," können andere Ingenieure Ihnen helfen, die Wände zu bauen. Wenn diese Ingenieure Ihnen schließlich ebenfalls sagen "die Arbeit ist erledigt," können Sie die Maler rufen, um das Haus zu dekorieren. Was passiert, wenn Sie die Maler bitten, vor dem Bau der Wände zu dekorieren? Ich denke, sie werden anfangen, sich zu beschweren. Fast alle diese menschenähnlichen Befehle werden sprechen. Wenn sie die Arbeit ohne Probleme erledigen, melden sie "Standardausgabe." Wenn sie nicht tun können, was Sie von ihnen verlangt haben – melden sie "Standardfehler." Letztendlich hören also alle Befehle über "Standardeingabe" auf Sie.
Schnelles Beispiel – wenn Sie ein Linux-Terminal öffnen und etwas Text eingeben – sprechen Sie über "Standardeingabe" mit bash. Fragen wir also die bash-Shellwho am i (Wer bin ich?)dann.
root@localhost ~]# who am i <--- 你通过标准输入对 bash shell 说 root pts/0 2015-04-22 20:17 (192.168.1.123) <--- bash shell通过标准输出回答你
Fragen wir bash nun etwas, das sie nicht versteht:
[root@localhost ~]# blablabla <--- 哈，你又在和标准输入说话了 -bash: blablabla: command not found <--- bash通过标准错误在发牢骚了
Das erste Wort vor dem ':' ist normalerweise der Befehl, der sich bei Ihnen beschwert. Tatsächlich hat jeder dieser Streams seine eigene Indexnummer (Hinweis des LCTT-Übersetzers: Dateihandle-Nummer):
- Standardeingabe (stdin） – 0
- Standardausgabe (stdout） – 1
- Standardfehler (stderr） – 2
Wenn Sie wirklich wissen möchten, was die Ausgabe eines Befehls gesagt hat, müssen Sie diese Rede in eine Datei umleiten (mit dem Größer-als-Zeichen ">" und dem Stream-Index nach dem Befehl):
[root@localhost ~]# blablabla 1> output.txt -bash: blablabla: command not found
In diesem Beispiel versuchen wir, Stream 1 (stdout) in eine Datei namens output.txt umzuleiten. Sehen wir uns an, was mit dem Inhalt der Datei gemacht wurde; das können Sie mit dem Befehl cat tun:
[root@localhost ~]# cat output.txt [root@localhost ~]#
Sie scheint leer zu sein. Nun, jetzt leiten wir Stream 2 (stderr）：
[root@localhost ~]# blablabla 2> error.txt [root@localhost ~]#
Nun, wir sehen, dass die Beschwerden verschwunden sind. Prüfen wir diese Datei:
[root@localhost ~]# cat error.txt -bash: blablabla: command not found [root@localhost ~]#
Tatsächlich! Wir sehen, dass alle Beschwerden in der Datei errors.txt aufgezeichnet wurden.
Manchmal erzeugt ein Befehl sowohlstdoutals auchstderr. Um sie in verschiedene Dateien umzuleiten, können wir die folgende Anweisung verwenden:
command 1>out.txt 2>err.txt
Um die Anweisung etwas zu verkürzen, können wir "1" weglassen, denn standardmäßig wirdstdoutumgeleitet:
command >out.txt 2>err.txt
Nun, versuchen wir etwas "Schlimmes". Verwenden wir den Befehl rm, um file1 und folder1 zu löschen:
[root@localhost ~]# rm -vf folder1 file1 > out.txt 2>err.txt
Jetzt lass uns die folgenden Ausgabedateien überprüfen:
[root@localhost ~]# cat out.txt removed `file1' [root@localhost ~]# cat err.txt rm: cannot remove `folder1': Is a directory [root@localhost ~]#
Wie wir sehen können, wurden die verschiedenen Streams in verschiedene Dateien getrennt. Manchmal ist das nicht sehr praktisch, weil wir sehen möchten, was vor oder nach einer bestimmten Operation zusammenhängend passiert ist, wenn ein Fehler auftritt. Um dies zu erreichen, können wir beide Streams in dieselbe Datei umleiten:
command >>out_err.txt 2>>out_err.txt
Hinweis: Bitte beachten Sie, dass ich ">>" anstelle von ">" verwendet habe. Damit können wir an die Datei anhängen, anstatt sie zu überschreiben.
Wir können auch einen Stream in einen anderen umleiten:
command >out_err.txt 2>&1
Lass es mich erklären. Die Standardausgabe aller Befehle wird in out_err.txt umgeleitet, die Fehlerausgabe wird auf Stream 1 umgeleitet (wie oben erklärt), und dieser Stream wird in dieselbe Datei umgeleitet. Betrachten wir dieses Beispiel:
[root@localhost ~]# rm -fv folder2 file2 >out_err.txt 2>&1 [root@localhost ~]# cat out_err.txt rm: cannot remove `folder2': Is a directory removed `file2' [root@localhost ~]#
Wenn wir die kombinierte Ausgabe betrachten, können wir sie so beschreiben: Zuerst,rmversucht der Befehl, folder2 zu löschen, aber er wird nicht erfolgreich sein, weil Linux die-rOption benötigt, um demrmBefehl zu erlauben, den Ordner zu löschen, während die zweite Datei file2 gelöscht wird. Durch Angabe derrm-Befehl und demAngeben des-v(verbose)-Schlüssels lassen wir den rm-Befehl jede gelöschte Datei oder jeden gelöschten Ordner melden.
This is almost everything you need to know about redirection. I say almost, because there is one more important redirection tool, which is called a "pipe." By using the | (pipe) symbol, we usually redirect thestdout-Stream um.
Zum Beispiel haben wir eine Textdatei wie diese:
[root@localhost ~]# cat text_file.txt This line does not contain H e l l o word This lilne contains Hello This also containd Hello This one no due to HELLO all capital Hello bash world!
And we need to find the lines containing "Hello". Linux has agrep-Befehl, der diese Aufgabe erledigen kann:
[root@localhost ~]# grep Hello text_file.txt This lilne contains Hello This also containd Hello Hello bash world! [root@localhost ~]#
Wenn wir eine Datei haben und darin suchen möchten, funktioniert das gut. Aber was, wenn wir etwas in der Ausgabe eines anderen Befehls finden müssen? Ja, natürlich können wir die Ausgabe in eine Datei umleiten und dann in der Datei suchen:
[root@localhost ~]# fdisk -l>fdisk.out [root@localhost ~]# grep "Disk /dev" fdisk.out Disk /dev/sda: 8589 MB, 8589934592 bytes Disk /dev/mapper/VolGroup-lv_root: 7205 MB, 7205814272 bytes Disk /dev/mapper/VolGroup-lv_swap: 855 MB, 855638016 bytes [root@localhost ~]#
Was, wenn Sie vorhaben, etwas mit grep zu suchen, das in doppelten Anführungszeichen steht und Leerzeichen enthält!
Hinweis: Der Befehl fdisk zeigt Informationen über Laufwerke auf Linux-Betriebssystemen an.
As we can see, this method is very inconvenient, because we soon mess up the temporary file space. To accomplish this task, we can use pipes. They allow us to redirect one command'sstdouteines Befehls an denstdin-Stream eines anderen Befehls umzuleiten:
[root@localhost ~]# fdisk -l | grep "Disk /dev" Disk /dev/sda: 8589 MB, 8589934592 bytes Disk /dev/mapper/VolGroup-lv_root: 7205 MB, 7205814272 bytes Disk /dev/mapper/VolGroup-lv_swap: 855 MB, 855638016 bytes [root@localhost ~]#
As you can see, we get the same result without needing any temporary files. We redirect thefdisk stdoutangrep stdin um。
Note: Die Pipe-Umleitung erfolgt immer von links nach rechts.
Es gibt noch ein paar andere Umleitungsarten, aber darauf gehen wir später ein.
Benutzerdefinierte Informationen in der Shell anzeigen
Wie wir wissen, erfolgt die Kommunikation mit der Shell und innerhalb der Shell normalerweise in dialogischer Form. Also lassen Sie uns einige echte Skripte erstellen, die auch mit uns sprechen. Dies bringt Ihnen ein paar einfache Befehle bei und vermittelt Ihnen ein besseres Verständnis des Konzepts von Skripten.
Angenommen, wir sind der Manager des Service Desks eines Unternehmens und möchten ein Shell-Skript erstellen, um Anrufinformationen zu erfassen: Telefonnummer, Benutzername und eine kurze Beschreibung des Problems. Wir planen, diese Informationen in einer einfachen Textdatei, data.txt, für spätere Statistiken zu speichern. Das Skript selbst arbeitet dialogorientiert, was den Arbeitsalltag der Service-Desk-Mitarbeiter etwas erleichtert. Also müssen wir zuerst Eingabeaufforderungen anzeigen. Zum Anzeigen von Informationen können wir die Befehle echo und printf verwenden. Beide werden zum Anzeigen von Informationen verwendet, aber printf ist leistungsfähiger, weil wir damit die Ausgabe schön formatieren können; wir können sie rechtsbündig, linksbündig ausrichten oder Platz für Informationen reservieren. Beginnen wir mit einem einfachen Beispiel. Um eine Datei zu erstellen, verwenden Sie Ihren üblichen Texteditor (kate, nano, vi, ...), erstellen Sie eine Datei namens note.sh und schreiben Sie diese Befehle hinein:
echo "Phone number ?"
Wie führt man ein Skript aus?
Nach dem Speichern der Datei können wir sie mit dem Befehl bash ausführen und unsere Datei als Argument übergeben:
[root@localhost ~]# bash note.sh Phone number ?
Eigentlich ist das Ausführen des Skripts auf diese Weise ziemlich unpraktisch. Wenn wir denbash-Befehl nicht als Präfix verwenden, wäre es bequemer, es auszuführen. Um das Skript ausführbar zu machen, können wir denchmod-Befehl verwenden:
[root@localhost ~]# ls -la note.sh -rw-r--r--. 1 root root 22 Apr 23 20:52 note.sh [root@localhost ~]# chmod +x note.sh [root@localhost ~]# ls -la note.sh -rwxr-xr-x. 1 root root 22 Apr 23 20:52 note.sh [root@localhost ~]#
Hinweis: Der Befehl ls zeigt die Dateien im aktuellen Ordner an. Durch Hinzufügen der Option -la werden mehr Dateiinformationen angezeigt.
Wie wir sehen können, hat das Skript, bevor derchmod-Befehl ausgeführt wird, nur Lese- (r) und Schreibberechtigungen (w). Nach dem Ausführen vonchmod +xerhält es die Ausführungsberechtigung (x). (Auf weitere Details zu Berechtigungen werde ich im nächsten Artikel eingehen.) Jetzt führen wir es einfach so aus:
[root@localhost ~]# ./note.sh Phone number ?
Vor dem Skriptnamen habe ich die Kombination ./ hinzugefügt. . (Punkt) bedeutet in der Unix-Welt den aktuellen Ort (aktuellen Ordner), und / (Schrägstrich) ist der Ordner-Trenner. (In Windows-Systemen verwenden wir Backslash \, um dieselbe Funktion anzuzeigen.) Diese ganze Kombination bedeutet also: "Führe das Skript note.sh aus dem aktuellen Ordner aus". Ich denke, es wäre klarer, wenn ich dieses Skript mit dem vollständigen Pfad ausführen würde:
[root@localhost ~]# /root/note.sh Phone number ? [root@localhost ~]#
Es funktioniert auch.
Wenn alle Linux-Benutzer dieselbe Standard-Shell hätten, wäre alles in Ordnung. Wenn wir das Skript einfach ausführen, wird die Standard-Benutzer-Shell verwendet, um den Skriptinhalt zu parsen und die Befehle auszuführen. Verschiedene Shells haben leichte Unterschiede in Syntax, internen Befehlen und so weiter. Um also sicherzustellen, dass unser Skriptbashverwendet, sollten wir#!/bin/bashzur ersten Zeile der Datei hinzufügen. Auf diese Weise ruft die Standard-Benutzer-Shell/bin/bashauf, und erst dann werden die Befehle im Skript ausgeführt:
[root@localhost ~]# cat note.sh #!/bin/bash echo "Phone number ?"
Erst jetzt sind wir 100% sicher,bashdass es verwendet wird, um den Inhalt unseres Skripts zu parsen. Fahren wir fort.
Eingabe lesen
Nachdem die Nachricht angezeigt wurde, wartet das Skript auf die Antwort des Benutzers. Es gibt einenreadBefehl, der verwendet wird, um die Antwort des Benutzers zu empfangen:
#!/bin/bash echo "Phone number ?" read phone
Nach der Ausführung wartet das Skript auf Benutzereingaben, bis der Benutzer [ENTER] drückt, um die Eingabe zu beenden:
[root@localhost ~]# ./note.sh Phone number ? 12345 <--- 这儿是我输入的内容 [root@localhost ~]#
Alles, was Sie eingeben, wird in der Variablephonegespeichert; um den Wert der Variable anzuzeigen, können wir auch denechoBefehl verwenden:
[root@localhost ~]# cat note.sh #!/bin/bash echo "Phone number ?" read phone echo "You have entered $phone as a phone number" [root@localhost ~]# ./note.sh Phone number ? 123456 You have entered 123456 as a phone number [root@localhost ~]#
InbashIn der Shell verwenden wir im Allgemeinen das$(Dollar)-Zeichen, um anzuzeigen, dass dies eine Variable ist, außer beim Einlesen in eine Variable und in einigen anderen seltenen Fällen, in denen wir dieses $ nicht verwenden (wird später erklärt).
In Ordnung, jetzt sind wir bereit, die restlichen Fragen hinzuzufügen:
#!/bin/bash echo "Phone number?" read phone echo "Name?" read name echo "Issue?" read issue [root@localhost ~]# ./note.sh Phone number? 123 Name? Jim Issue? script is not working. [root@localhost ~]#
Stream-Umleitung verwenden
Perfekt! Es bleibt nur noch, alles in die Datei data.txt umzuleiten. Als Feldtrennzeichen verwenden wir das Symbol / (Schrägstrich).
Hinweis: Du kannst ein beliebiges Trennzeichen wählen, das du für am besten hältst, aber stelle sicher, dass der Dateiinhalt diese Symbole nicht enthält, sonst verursacht es zusätzliche Felder in den Textzeilen.
Vergiss nicht, ">>" statt ">" zu verwenden, weil wir die Ausgabe an das Ende der Datei anhängen wollen!
[root@localhost ~]# tail -2 note.sh read issue echo "$phone/$name/$issue">>data.txt [root@localhost ~]# ./note.sh Phone number? 987 Name? Jimmy Issue? Keybord issue. [root@localhost ~]# cat data.txt 987/Jimmy/Keybord issue. [root@localhost ~]#
Hinweis ： tail-Befehl zeigt die letztennZeilen an.
Fertig. Lass es uns erneut ausführen, um es zu sehen:
[root@localhost ~]# ./note.sh Phone number? 556 Name? Janine Issue? Mouse was broken. [root@localhost ~]# cat data.txt 987/Jimmy/Keybord issue. 556/Janine/Mouse was broken. [root@localhost ~]#
Unsere Datei wächst. Fügen wir am Anfang jeder Zeile ein Datum hinzu. Das wird nützlich sein, wenn wir später mit diesen Statistiken herumspielen. Um das zu erreichen, können wir den Befehl date verwenden und ein bestimmtes Format angeben, weil mir das Standardformat nicht gefällt:
[root@localhost ~]# date Thu Apr 23 21:33:14 EEST 2015 <---- date命令的默认输出 [root@localhost ~]# date "+%Y.%m.%d %H:%M:%S" 2015.04.23 21:33:18 <---- 格式化后的输出
Es gibt mehrere Möglichkeiten, die Ausgabe eines Befehls in eine Variable einzulesen; in diesem einfachen Fall verwenden wir ` (Backtick, kein einfaches Anführungszeichen, auf derselben Taste wie die Tilde ~):
[root@localhost ~]# cat note.sh #!/bin/bash now=`date "+%Y.%m.%d %H:%M:%S"` echo "Phone number?" read phone echo "Name?" read name echo "Issue?" read issue echo "$now/$phone/$name/$issue">>data.txt [root@localhost ~]# ./note.sh Phone number? 123 Name? Jim Issue? Script hanging. [root@localhost ~]# cat data.txt 2015.04.23 21:38:56/123/Jim/Script hanging. [root@localhost ~]#
Hmm... unser Skript sieht etwas hässlich aus. Verschönern wir es. Wenn du manuell denread-Befehl lesen möchtest, wirst du feststellen, dass der read-Befehl auch einige Informationen anzeigen kann. Um das zu erreichen, sollten wir die Option -p plus die Nachricht verwenden:
[root@localhost ~]# cat note.sh #!/bin/bash now=`date "+%Y.%m.%d %H:%M:%S"` read -p "Phone number: " phone read -p "Name: " name read -p "Issue: " issue echo "$now/$phone/$name/$issue">>data.txt
Du kannst direkt viele interessante Informationen über verschiedene Befehle von der Konsole aus finden, tippe einfach:man read, man echo, man date, man ……
Einverstanden? Es sieht viel komfortabler aus!
[root@localhost ~]# ./note.sh Phone number: 321 Name: Susane Issue: Mouse was stolen [root@localhost ~]# cat data.txt 2015.04.23 21:38:56/123/Jim/Script hanging. 2015.04.23 21:43:50/321/Susane/Mouse was stolen [root@localhost ~]#
Der Cursor steht nach der Nachricht (nicht in einer neuen Zeile), was interessant ist. (Anmerkung des LCTT-Übersetzers: Wenn du den Befehl echo zur Ausgabe verwendest, kannst du die Option -n verwenden, um einen Zeilenumbruch zu vermeiden.)
Schleifen
Es ist Zeit, unser Skript zu verbessern. Wenn der Benutzer den ganzen Tag Telefonanrufe beantwortet, wäre es dann nicht lästig, es jedes Mal ausführen zu müssen? Lass uns diese Aktivitäten in einer Endlosschleife ausführen:
[root@localhost ~]# cat note.sh
#!/bin/bash
while true
do
read -p "Phone number: " phone
now=`date "+%Y.%m.%d %H:%M:%S"`
read -p "Name: " name
read -p "Issue: " issue
echo "$now/$phone/$name/$issue">>data.txt
done
Ich habe dieread phoneundnow=datePositionen der Zeilen vertauscht. Das liegt daran, dass ich die Zeit nach der Eingabe der Telefonnummer erhalten möchte. Wenn ich sie in die erste Zeile der Schleife setzen würde, dann würde die Variable now nach einer Schleife die Zeit unmittelbar nach dem Speichern der Daten in die Datei erhalten. Und das ist nicht gut, weil der nächste Anruf 20 Minuten später oder sogar noch später kommen könnte.
[root@localhost ~]# ./note.sh Phone number: 123 Name: Jim Issue: Script still not works. Phone number: 777 Name: Daniel Issue: I broke my monitor Phone number: ^C [root@localhost ~]# cat data.txt 2015.04.23 21:38:56/123/Jim/Script hanging. 2015.04.23 21:43:50/321/Susane/Mouse was stolen 2015.04.23 21:47:55/123/Jim/Script still not works. 2015.04.23 21:48:16/777/Daniel/I broke my monitor [root@localhost ~]#
Hinweis: Um die Endlosschleife zu verlassen, können Sie [Strg]+[C] drücken. Die Shell zeigt ^ an, um die Strg-Taste darzustellen.。
Verwendung der Pipe-Umleitung
Fügen wir unserem "Frankenstein" weitere Funktionen hinzu. Ich möchte, dass das Skript nach jedem Anruf einige Statistiken anzeigt. Zum Beispiel möchte ich sehen, wie oft jede Nummer mich angerufen hat. Dafür sollten wir die Datei data.txt mit cat ausgeben:
[root@localhost ~]# cat data.txt 2015.04.23 21:38:56/123/Jim/Script hanging. 2015.04.23 21:43:50/321/Susane/Mouse was stolen 2015.04.23 21:47:55/123/Jim/Script still not works. 2015.04.23 21:48:16/777/Daniel/I broke my monitor 2015.04.23 22:02:14/123/Jimmy/New script also not working!!! [root@localhost ~]#
Jetzt können wir die gesamte Ausgabe an den Befehlcutumleiten, wobeicutjede Zeile in Stücke zerlegt (wir verwenden das Trennzeichen "/") und dann das zweite Feld ausgibt:
[root@localhost ~]# cat data.txt | cut -d"/" -f2 123 321 123 777 123 [root@localhost ~]#
Jetzt können wir diese Ausgabe an einen anderen Befehlsort umleiten：
[root@localhost ~]# cat data.txt | cut -d"/" -f2|sort 123 123 123 321 777 [root@localhost ~]#
Dann bleiben nur eindeutige Zeilen übrig. Um eindeutige Einträge zu zählen, fügen Sie einfach die-cOption zumuniq-Befehl hinzu:
[root@localhost ~]# cat data.txt | cut -d"/" -f2 | sort | uniq -c
3 123
1 321
1 777
[root@localhost ~]#
Fügen Sie dies einfach am Ende unserer Schleife hinzu:
#!/bin/bash
while true
do
read -p "Phone number: " phone
now=`date "+%Y.%m.%d %H:%M:%S"`
read -p "Name: " name
read -p "Issue: " issue
echo "$now/$phone/$name/$issue">>data.txt
echo "===== We got calls from ====="
cat data.txt | cut -d"/" -f2 | sort | uniq -c
echo "--------------------------------"
done
Ausführen:
[root@localhost ~]# ./note.sh
Phone number: 454
Name: Malini
Issue: Windows license expired.
===== We got calls from =====
3 123
1 321
1 454
1 777
--------------------------------
Phone number: ^C
Das aktuelle Szenario durchläuft mehrere bekannte Schritte:
- Nachricht anzeigen
- Benutzereingabe abrufen
- Wert in Datei speichern
- Gespeicherte Daten verarbeiten
Wenn der Benutzer jedoch einigermaßen verantwortungsbewusst ist, muss er manchmal Daten eingeben, manchmal Statistiken erstellen oder möchte vielleicht etwas in den gespeicherten Daten nachschlagen? Für diese Dinge müssen wir Switch/Case-Anweisungen verwenden und wissen, wie man die Ausgabe schön formatiert. Das ist nützlich, wenn man Tabellen in der Shell "zeichnet".
Quelle: http://linux.cn/article-5591-1.html