Linux Bibel online

Creative Commons Lizenzvertrag
Dieses Werk ist lizenziert unter einer Creative Commons Namensnennung - Nicht-kommerziell - Weitergabe unter gleichen Bedingungen 3.0 Österreich Lizenz.

Change language by Google translator: ...

Was sind Scripte eigentlich? Scripte sind eigentlich nichts anderes als ganz einfache Textdateien die man wie ein Programm ausführen kann. Man kann sich dies vorstellen wie wenn man am Terminal eine ganze Reihe an Befehlen startet die eine Aufgabe erfüllen sollen - man schreibt sich ein Script mit den nötigen Befehlen, führt das Script aus und dieses erledigt die ganze Geschichte.

Was kann man mit Scripts anstellen? Eigentlich gesagt - fast alles - man kann damit System-Daten abfragen, man kann damit Dinge in einem Schlag ausführen für die viel Zeit nötig wäre, man kann damit viele Dinge unter Linux automatisieren, je mehr Ideen man hat desto mehr kann man mit Scripts anstellen.

In diesem Beitrag wird es um so genannte Shell-Scripte gehen, manche nennen diese auch Terminal-Scripte oder Bash-Scripte - einfach weil sie vom Standard-Interpreter des Terminals - der Bash ausgeführt werden. Shell-Scripte sind die einfachste Variante von Scripts und somit die einfachste Art Aufgaben schnell zu lösen, vor allem eben Dinge zu erledigen die immer wieder kehren.

Was benötigt man?

Nichts anderes als jeden normalen ganz einfachen Texteditor und eben ein wenig Wissen wie das Terminal funktioniert. Bekannte Texteditoren unter Linux wären etwa Kate - der Editor von KDE, Gedit - der Editor von GNOME und Unity (Ubuntu), Emacs, Vi(m), Nano und so weiter und so fort.

Wie beginnt man?

Man öffnet seinen Texteditor - ich denke darauf hätte ich verzichten können - und startet mit dem so genannten Shebang - dies ist die erste Zeile in einem jeden Shell-Script überhaupt. Diese Zeile zeigt dem Terminal-Interpreter - also der Bash welche Script-Sprache man eigentlich benutzen will (neben der Bash gibt es beispielsweise noch Python, Perl, Ruby und viele weitere). Da wir reine Shell-Scripte schreiben wollen beginnen wir mit dem Shebang der Bash:

#!/bin/bash

Durch diese Zeile versteht das Terminal nun das jeder Befehl darin mit der Bash zu tun hat - also grob gesagt ganz einfach mit dem Standard des Terminals. Was nun natürlich noch fehlt wäre der Bash nun zu zeigen was sie tun soll, als kleines Beispiel wollen wir einen ganz einfachen Befehl nutzen:

ls -a

Der Befehl zeigt uns den Inhalt des aktuellen Verzeichnisses an inklusive versteckter Dateien. Dazu fügen wir den Befehl ganz einfach in die nächste Zeile ein:

#!/bin/bash ls -a

Abgeschlossen wird ein Script unter normalen Umständen mit dem Befehl:

done

Dieser zeigt der Bash das die Arbeit erledigt wurde - also:

#!/bin/bash ls -a done

Womit wir unser erstes Script erstellt hätten, wir speichern die Datei unter einem beliebigen Namen - in meinem Beispiel nenne ich das Script "shellscript", es ist eigentlich nicht nötig der Datei eine Datei-Endung zu geben - üblicherweise nutzt man jedoch die Endung ".sh" - also "shellscript.sh".

Shellscripte unter Linux erstellen

Shellscripte unter Linux erstellen

Nun haben wir eine Textdatei namens "shellscript.sh", mit dieser können wir jedoch nichts anderes anfangen als diese in einem Texteditor öffnen und lesen oder bearbeiten - wir jedoch wollen das dieses Script unseren Befehl ausführt. Dazu müssen wir unser Script ausführbar machen, dies funktioniert auf zwei Wege. Die erste wäre es die Datei auf dem Terminal ausführbar zu machen, der nötige Befehl würde lauten:

chmod +x shellscript.sh

Damit wäre die Geschichte erledigt. Die zweite Variante läuft über die grafische Oberfläche, man klickt die Datei rechts an und wählt "Eigenschaften / Berechtigungen":

Shellscripte unter Linux erstellen - als ausführbar markieren

Shellscripte unter Linux erstellen - als ausführbar markieren

Nun ist unser Script in beiden Fällen einsatzbereit. Um ein Shellscript zu starten gibt es auf dem Terminal zwei Varianten, die erste wäre:

sh shellscript.sh

Die zweite:

./shellscript.sh

Beide führen zum selben Ziel. Auf der grafischen Oberfläche würde man das Script ganz einfach anklicken und "Ausführen" wählen:

Shellscripte unter Linux erstellen - Script starten

Shellscripte unter Linux erstellen - Script starten

In diesem Fall würden wir unser Ziel natürlich nur am Terminal erreichen da der Befehl nur auf dem Terminal wirkt - also unsere Dateien anzeigt:

Shellscripte unter Linux erstellen

Shellscripte unter Linux erstellen

Meist nutzt man Scripte natürlich zur Automatisierung, also das Script wird automatisch vom System ausgeführt und erledigt so seine Arbeit ohne das der Nutzer etwas damit zu tun hat - möchte dieser dann aber doch etwas davon wissen sollte das Script etwa am besten ein Protokoll schreiben - etwa in eine einfache Datei, existiert diese Datei nicht wird diese automatisch erstellt. Um nun auf dem Terminal die jeweilige Ausgabe in eine Datei zu schreiben nutzt man einen Operator - in diesem Fall:

>

Durch diesen Operator wird die entsprechende Datei erzeugt wenn diese noch nicht existiert und die Ausgabe in diese geschrieben, besteht die Datei schon wird der darin liegende Inhalt durch den neuen ersetzt. Möchte man dies nicht - sondern die neue Ausgabe des Terminals an den alten Inhalt anhängen nutzt man den Operator:

>>

Die Syntax dieser Ausgabe würde nun ganz einfach so lauten:

befehl >> /pfad/zur/datei

In unserem kleinen Beispiel will ich ganz einfach die Ausgabe des vorigen Befehls in die Datei "/home/robert/log.txt" schreiben:

#!/bin/bash ls -a >> /home/robert/log.txt done

Nun, dies war nur ein sehr einfaches Script, wir wollen nun einen weiteren Befehl in dieses Script bringen - nehmen wir gleich einmal das vorige Script, es schreibt die Dateien des aktuellen Verzeichnisses in eine Datei - wir möchten nun wissen wann dieses Script die Dateien erfasst hat. Um auf dem Terminal die Zeit anzuzeigen nutzt man den Befehl:

date

Eine mögliche Ausgabe wäre etwa:

Fr 5. Aug 07:44:21 CEST 2016

Wir müssen nun die Bash dazu bringen zwei einzelne Befehle hintereinander auszuführen, dazu gibt es zwei Möglichkeiten. Man schreibt jeden Befehl in eine neue Zeile, in diesem Fall wollen wir die Zeit vor den erfassten Dateien sehen, also geben wir den Befehl "date" natürlich vor unserer "ls"-Ausgabe an:

#!/bin/bash date ls -a >> /home/robert/log.txt done

Die zweite Möglichkeit wäre es alles in eine Zeile zu schreiben und jeden Befehl durch ein ";" zu trennen:

#!/bin/bash date; ls -a >> /home/robert/log.txt; done

Diese Variante ist jedoch bei größeren Scripts sehr unübersichtlich - vor allem dann wenn wir auch eine Beschreibung der einzelnen Funktionen einbringen wollen.

Wir wollen nun verstehen wie wir einzelnen Funktionen beschreiben, also kleine Hilfen in das Script einfügen die bei längeren Scripts uns zeigen wo sich welche Funktion versteckt. Dies ist gerade bei längeren Scripts hilfreich, will man eine solche Datei später anpassen muss man nicht lange in den Befehlen suchen sondern sieht einfach nur auf die Beschreibung - die Bash hingegen interessiert solches nicht. Beschreibungen setzt man nun ganz einfach hinter eine Raute - also "#", wie man dies nun macht ist jedem selbst überlassen, hier einige Beispiele:

#!/bin/bash # Das Datum anzeigen date ####################################### # # # Dateien und Verzeichnisse erfassen # # # ####################################### ls -a >> /home/robert/log.txt ### Ende des Scripts done

Argumente ein- und ausgeben

Nun wollen wir etwas weiter gehen, das nächste Script hat eigentlich nichts praktisches an sich - es soll nur zeigen wie die Bash arbeitet um das Dahinter etwas mehr zu verstehen, zu Beginn einmal das Script:

#!/bin/bash let summe=0 for n in $* do case $n in *[!0-9]*) echo keine Zahl: $n ;; *) let summe=$summe+$n echo Zahl: $n ;; esac done echo Summe: $summe

Ich nenne dieses Script ganz einfach "zahlen-addieren.sh", es tut nichts anderes als Zahlen die man dem Script als Option mit gibt addieren, gibt man Buchstaben mit an werden diese ignoriert. Als kleines Beispiel für den Start des Scriptes:

sh zahlen-addieren.sh 1 a 2 B 3 c 4 5

Als kleines Beispiel für die Ausgabe:

Zahl: 1 keine Zahl: a Zahl: 2 keine Zahl: B Zahl: 3 keine Zahl: c Zahl: 4 Zahl: 5 Summe: 15

Die Erklärung dieses Scripts: Zu Beginn sehen Sie natürlich den Shebang "#!/bin/bash", die nächste Zeile "let summe=0" definiert die erste Variable die sich "summe" nennt (zu Variablen mehr später), diese Variable hat den Wert "0" - dies ist der Start-Wert zum Addieren der folgenden Zahlen. "let" wiederum sorgt dafür das es sich bei der nötigen Eingabe um Zahlen zu handeln hat (also keine Buchstaben). "for n in $*", "do" und "done" - hier handelt es sich nun um eine Schleife - dies bedeutet die Bash nutzt diesen Befehl so lange bis sie jede angegebene Zahl ausgewertet hat. "n" fungiert hier als Zähler - er nimmt die Werte die vom Nutzer durch "$" angegeben werden an - "do" beginnt die Schleife und "done" beendet diese Schleife. "case $n in" und "esac" sind eine Fall-Entscheidung, sie vergleicht die vom Nutzer angegebenen Werte (also Variablen) ob es sich um Buchstaben "*)" oder Zahlen "*[!0-9]*)" handelt. Weiters gibt "*[!0-9]*)" an das es sich bei den eingegebenen Ziffern um eine von "0" bis "9" handeln muss, wird nun ein Buchstabe eingegeben wird dieser ignoriert, wird nun eine Zahl eingegeben wird das Muster "*[!0-9]*)" aktiv, wird ein Buchstabe eingegeben das Muster "*)". Der Befehl "let summe=$summe+$n" sorgt nun dafür das die zuerst angegebene Summe - also "0" zu den weiteren vom User angegebenen Ziffern addiert werden der Befehl "echo Summe: $summe" gibt dann die Addierte Summe aus.

Variablen und Ausdrücke

Eines der wichtigsten Elemente in Programmiersprachen sind Variablen, dies sind zumeist nicht vorbestimmte / veränderliche Platzhalter für Eingaben vom User oder auch aus Dateien.

Variablen werden einfach definiert indem man zuerst der Variable einen Namen gibt, dann folgt das Ist-Zeichen "=" und danach erfolgt der Wert der Variable, sollte dann etwa so aussehen:

variable=wert

Als anschauliches Beispiel das man einfach ohne Script auf dem Terminal verfolgen kann, geben Sie einfach:

name=ihr-name

auf dem Terminal ein und geben dann den Befehl:

echo $name

ein - nun sollte die Ausgabe:

ihr-name

erscheinen. Durch welchen Namen man Variablen bezeichnet ist vollkommen egal.

Als kleines Beispiel wollen wir wieder unser erstes Script nutzen, diesmal erweitern wir dieses etwas:

#!/bin/bash datum=date "+%d.%m.%y, %H:%M:%S" ls -a /home/robert > /home/log-$datum.txt done

Hier sehen wir zu Beginn nun die Variable "datum", der Befehl:

date "+%d.%m.%y, %H:%M:%S"

gibt unser Datum etwas besser formatiert aus als in unserem Script oben, etwa:

05.08.16, 09:05:13

Danach lassen wir uns die Dateien im Verzeichnis "/home/robert" anzeigen und diese bei jeder neuen Erfassung in eine eigene Datei schreiben die sich nun "log-05.08.16, 09:05:13.txt" nennt. Zuerst wird also die Variable "datum" erfasst und durch "$datum" ausgegeben.

Fall-Entscheidungen

Ein weiteres wichtiges Thema sind Fallentscheidungen, sie können damit festlegen was passieren soll wenn etwas eintrifft, etwa eine bestimmte Eingabe oder eine Datei schon existiert die eigentlich nicht existieren sollte und vieles mehr. Wichtig ist eine Entscheidung wird zwischen den Angaben "if Bedingung" und "fi" festgelegt und nur dann ausgeführt wenn die Bedingung zutrifft.

Unter Windows erledigt der Admin oftmals Aufgaben mittels Batch- oder Stapeldateien - was unter Windows kompliziert ist ist unter Linux sehr einfach - und vor allem extrem ausbaufähig. Die Standard-Shell ist unter Linux zumeist die Bash - also die Bourne Again Shell, der Unterschied zwischen den verschiedenen Shells ist zumeist deren Syntax und oftmals auch Zusatz-Funktionen.

Da wir ein professionelles Script schreiben wollen werde ich zunächst Mal die einfache Syntax einer "if-then"-Schleife unter der Bash zeigen die wir später in ein Script einbinden werden:

if Bedingung then Befehle elif Bedingung then Befehle else Befehle fi

Der Ausdruck "elif" steht für "else if", "fi" meint das Ende der Schleife, hier im Beispiel der UNIX-C-Shell die auch unter Windows etwas bekannter sein sollte um den Unterschied zur Bash zu zeigen:

if Ausdruck then Befehle else if zweiter-Ausdruck then Befehle else Befehle endif

Als Beispiel will ich nichts aufregendes in ein halbwegs anspruchsvolles Script verwandeln, dazu will ich einfach nur wissen wie viele nicht versteckte Dateien und Verzeichnisse in einem Verzeichnis liegen. Dazu nutze ich einfach den Befehl:

ls -l

der alle nicht versteckten Dateien und Verzeichnisse anzeigt und kombiniere diesen über die Pipe "|" mit dem Befehl:

wc -l

der die Zeilen einer Ausgabe oder einer Textdatei zählt:

ls -l | wc -l

Das Script würde demnach also so aussehen:

#!/bin/bash ls -l | wc -l done

Das Script nenne ich jetzt schnell einmal "lsmyhome.sh", mache es wie immer ausführbar:

chmod +x lsmyhome.sh

Nun ist das Script noch nicht sehr handlich, damit es die Dateien und Verzeichnisse in einem Verzeichnis zählt muss man es in das entsprechende Verzeichnis legen, von dort starten und dann auch noch eine Datei weg rechnen weil es sich selbst auch mit zählt. Hier könnte man nun einfach das entsprechende Verzeichnis angeben - etwa das Verzeichnis "/bin":

#!/bin/bash ls -l /bin | wc -l done

Als Ausgabe erhält man nun aus welchem Verzeichnis heraus man immer das Script startet die Anzahl der Dateien unter "/bin" was jedoch auch nicht sonderlich flexibel ist. Damit wir nun ein beliebiges Verzeichnis auszählen können bauen wir eine Variable ein. Variablen werden immer mit dem Dollar-Zeichen "$" eingeleitet und darauf folgt der Name der Variable - etwa ganz einfach "1", dies würde dann so aussehen "$1", man kann einer Variable nicht nur Zahlen als Namen geben sondern natürlich auch Buchstaben die man jedoch groß schreiben muss, als Beispiel "$VERZEICHNIS". Würde dann etwa so aussehen:

#!/bin/bash ls -l $1 | wc -l done

Nun können wir als Option dem Script das gewünschte Verzeichnis beim Start mit geben, also etwa:

sh lsmyhome.sh /bin

oder:

sh lsmyhome.sh /home/robert

oder welches Verzeichnis auch immer. Nun haben wir aber noch das Problem - geben wir ein Verzeichnis an das Leerzeichen im Dateinamen enthält bekommen wir nur eine Fehlermeldung, dies vermeiden wir indem wir die Variable unter Anführungszeichen setzen:

#!/bin/bash ls -l "$1" | wc -l done

Die Variable "1" ist ein vordefinierter Parameter, er gibt die erste Variable an, nun zeige ich Mal was man mit der Variable "0" nettes kann, auch sie ist vordefiniert und gibt den Namen des Scriptes an. Wollen wir also einfach Mal die Ausgabe des Scriptes ein wenig tunen, hierzu nutzen wir den Befehl:

echo

Dieser gibt einfach alles aus was hinter ihm steht:

#!/bin/bash echo Das Script $0 hat im Verzeichnis "$1" folgende Anzahl an Dateien und Verzeichnissen gezählt: ls -l "$1" | wc -l done

Als Beispiel für den Befehl mit Ausgabe:

sh lsmyhome.sh /bin Das Script lsmyhome.sh hat im Verzeichnis /bin folgende Anzahl an Dateien und Verzeichnissen gezählt: 76

Vor allem dann wenn man Variablen ohne Ende in ein Script einbaut wird die Geschichte unübersichtlich und es empfiehlt sich statt Nummern Namen einzusetzen, noch dazu - etwas mehr Ordnung wenn wir unseren Befehl unter Akzent setzen:

#!/bin/bash DATEIANZAHL=`ls -l "$1" | wc -l` echo Das Script $0 hat im Verzeichnis "$1" $DATEIANZAHL Dateien und Verzeichnisse gezählt done

Als Beispiel für die Ausgabe:

Das Script lsmyhome.sh hat in /bin 76 Dateien und Verzeichnisse gezählt.

Nun macht das Script eigentlich schon alles was es soll, doch wir können es doch noch ein wenig verfeinern, etwa indem wir die Existenz eines Verzeichnisses abfragen oder auch einen kurzen Hilfetext anzeigen lassen wenn man es mit einer bestimmten Option startet. Auf der Bash gibt es ein nettes Kommando zum prüfen von Bedingungen das sich:

test

nennt. Als Beispiel möchte ich wissen ob das Verzeichnis "/usr/bin" denn überhaupt existiert:

test -d /usr/bin

Gibt man diesen Befehl ein auf dem Terminal tut sich nichts, dies liegt daran dass der Befehl nur eine Meldung ausgibt wenn es nicht existiert - er gibt also einen Exit-Code aus, existiert das Verzeichnis (oder eben auch die Datei) ist der Exit-Code "0", existiert das Verzeichnis nicht ist der Code "1". Dazu versuchen Sie einfach Mal ein Verzeichnis anzugeben das existiert und dann eines das es nicht gibt und geben nach jedem Befehl den Befehl:

echo $?

ein - als Ausgabe erhalten Sie den entsprechenden Exit-Code. Dieser Exit-Code kann uns zum Beispiel dabei helfen in diesem Script wenn wir etwa als Option ein Verzeichnis angegeben haben das nicht existiert eine entsprechende Fehlermeldung zu erhalten statt gar keine Ausgabe, dazu als Beispiel:

#!/bin/bash if test -d "$0" then DATEIANZAHL=`ls -l "$1" | wc -l` echo Das Script \"$0\" hat im Verzeichnis \""$1"\" $DATEIANZAHL Dateien und Verzeichnisse gezählt. fi if test -d "$1" then echo Das Verzeichnis existiert nicht. fi done

Dies besagt nichts anderes als das zuerst getestet wird ob die Variable "1" überhaupt existiert und ein Verzeichnis ist, ist dies der Fall werden die Dateien und Verzeichnisse darin gezählt und ausgegeben. "if" / "then" besagt nichts anderes als "ist das so - dann" wird der Befehl weiter ausgeführt. Danach finden Sie die Prüfung ob das Verzeichnis nicht existiert, das Ausrufzeichen kehrt die Richtung des Tests um - prüft also ob das Verzeichnis nicht existiert, ist dies der Fall wird die entsprechende Meldung aus gegeben.

Nun wollen wir noch einen Schritt weiter gehen und dem User eine kleine Hilfe bieten wenn er das Script etwa mit einer der drei Optionen:

lsmyhome.sh -h lsmyhome.sh --help lsmyhome.sh -?

startet. Damit dies funktioniert muss man mehrere Bedingungen testen, trifft eine davon zu wird der Hilfe-Text angezeigt.

#!/bin/bash if test -d "$1" = "-h" -o "$1" = "--help" -o "$1" = "-?" then echo echo Dieses Script gibt die nicht versteckten im angegebenen Verzeichnis aus echo Start mit: $0 verzeichnis echo exit fi if test -d "$0" then DATEIANZAHL=`ls -l "$1" | wc -l echo Das Script \"$0\" hat im Verzeichnis \""$1"\" $DATEIANZAHL Dateien und Verzeichnisse gezählt. fi if ! test -d "$1" then echo Das Verzeichnis existiert nicht. fi done

Hier wird nach dem She-Bang geprüft ob eine der Bedingungen "--help", "-h" oder "-?" als Variable - also als Option angegeben wurde - ist dies der Fall wird der Hilfe-Text ausgegeben, ist keine dieser Optionen angegeben arbeitet das Script normal. Dies kann man nun auch weiter verfeinern indem man etwa auch prüft ob überhaupt eine Option angegeben wurde - wurde etwa weder nach Hilfe gesucht und auch kein Verzeichnis angegeben wird auch der Hilfe-Text angezeigt, dies erreicht man indem man eine Bedingung nach überhaupt keiner Eingabe prüft:

"$1" = ""

Womit nun aus einem Beispiel mit zwei Zeilen ein recht anspruchsvolles Script geworden ist.

Optionen zu "test"

Der Befehl "test" ist sehr hilfreich in Scripten um Bedingungen zu testen, hier mögliche Optionen und deren Bedeutungen.

Mögliche Aufrufe:

test ausdruck [Ausdruck] test option

Statt das Kommando "test" auszuschreiben können Sie ihn weg lassen und den Test der Bedingungen in eckige Klammern setzen, für das obige Beispiel:

if [ "$1" = "" -o "$1" = "-h" -o "$1" = "--help" -o "$1" = "-?" -o ]

Der Ausdruck kann wahr oder falsch sein, oder man nutzt die entsprechende Option.

Die Optionen

  • (Ausdruck) wenn der Ausdruck erfolgreich war
  • ! Ausdruck wenn der Ausdruck falsch war
  • Ausdruck1 -a Audruck2 beide Ausdrücke sind wahr
  • Ausdruck1 -o Ausdruck2 ein Ausdruck ist wahr
  • [-n] Zeichenfolge die Länge der Zeichenfolge ist ungleich Null
  • -z Zeichenfolge die Länge der Zeichenfolge ist Null
  • Zeichenfolge1 = Zeichenfolge2 die Zeichenfolgen sind gleich
  • Zeichenfolge1 != Zeichenfolge2 die Zeichenfolgen sind ungleich
  • Ganzzahl1 -eq Ganzzahl2 die Zahlen sind gleich
  • Ganzzahl1 -ge Ganzzahl2 die erste Zahl ist größer oder gleich der zweiten
  • Ganzzahl1 -gt Ganzzahl2 die erste Zahl ist größer als die zweite
  • Ganzzahl1 -le Ganzzahl2 die erste Zahl ist kleiner oder gleich der zweiten
  • Ganzzahl1 -lt Ganzzahl2 die erste Zahl ist kleiner als die zweite
  • Ganzzahl1 -ne Ganzzahl2 die Zahlen sind nicht gleich
  • Datei1 -ef Datei2 beide Dateien haben dieselbe Device- oder Inode-Nummer
  • Datei1 -nt Datei2 die erste Datei ist aktueller
  • Datei1 -ot Datei2 die erste Datei ist älter
  • -b Datei die Datei ist ein Block
  • -c Datei die Datei ist ein Character
  • -d Datei die Datei ist ein Verzeichnis
  • -e Datei die Datei existiert
  • -f Datei die Datei ist eine reguläre Datei
  • -g Datei die Datei ist set-group-ID
  • -G Datei die Datei hat eine effektive Gruppen-ID
  • -k Datei die Datei hat ein gesetztes Sticky-Bit
  • -L Datei die Datei ist ein symbolischer Link
  • -O Datei die Datei hat eine effektive User-ID
  • -p Datei die Datei ist eine Pipe mit Namen
  • -r Datei die Datei ist lesbar
  • -s Datei die Datei ist größer als Null
  • -S Datei die Datei ist ein Socket
  • -t Datei der Datei-Descriptor ist auf tty offen
  • -u Datei das set-User-ID-Bit ist gesetzt
  • -w Datei die Datei ist beschreibbar
  • -x Datei die Datei ist ausführbar
  • Als Datei werden unter Linux nicht nur Dateien sondern auch Verzeichnisse bezeichnet. Tipp: Verschiebt man ein Script als Root in eines der Verzeichnisse die der Befehl:

    echo $PATH

    ausgibt kann man es von jedem Verzeichnis heraus aus aufrufen.

    Grafik auf dem Terminal - kein Problem

    Besonders für Einsteiger ist etwas Grafik am Terminal alles andere als Übel. So ist es natürlich auch sehr einfach möglich etwas mehr Optik in das Terminal zu bringen mit der der Nutzer viel mehr Freude hat, will man ganz neue Frischlinge beglücken bringt man das Terminal gleich auf die grafische Oberfläche, als Fenster in dem man mit der Maus klicken kann wie man will.

    Damit man etwas Grafik auf das Terminal, oder gleich vom Terminal auf die grafische Desktop-Oberfläche bringen muss das jeweilige Paket installieren sein. Dazu installieren Sie je nachdem welche Desktop-Umgebung der Nutzer benutzt das passende Paket über die Paket-Verwaltung. Rein ein wenig Grafik auf dem Terminal bringt das Paket "dialog", unter allen Desktop-Umgebungen bis auf KDE installieren Sie das Paket "zenity" - unter KDE ist bereits alles vorhanden.

    Gleich einmal zu Beginn, Grafik auf das Terminal zu bringen erfordert ein klein wenig mehr-Arbeit und ein kleines Umdenken - denn man fügt hier passende Befehle für die jeweilige grafische Oberfläche hinzu. Statt normale Variablen fest zu legen wie zuvor legt man die Variablen durch die genutzten grafischen Befehle fest - besser gesagt durch deren Exit-Code. Aber keine Angst, es steckt eigentlich nicht viel dahinter und es zahlt sich aus.

    Zu Beginn wollen wir uns einmal die Dinge ansehen die unsere Grafischen Zusätze ermöglichen können:

    dialog (Terminal) zenity (alle anderen) kdialog (KDE)
    --yesno --question --yesno
    --msgbox --info --msgbox
    --infobox --info --passivepopup
    --textbox --textinfo --textbox
    --tailbox
    --pause
    --gauge --progress --progressbar
    --form
    --inputmenu
    --calendar --calendar --calendar
    --timebox
    --inputbox --entry --inputbox
    --editbox --textinfo --textinputbox
    --dselect --file-selection --getexistingdirectory
    --fselect --file-selection --getopenfilename / --getsavefilename
    --checklist --list --checklist
    --radiolist --list --radiolist
    --menu --list --menu

    Durch die Namen der einzelnen Programme kann man sich wohl schon denken was diese können, nun wollen wir wissen wie es funktioniert, hier in einem Beispiel für eine einfache Ja-/Nein-Frage:

    --yesno / --question - Eine einfach Ja-/Nein-Antwort geben, unter Dialog:

    dialog --yesno 'Text' Höhe Breite

    Höhe und Breite gibt man in Pixel an, Beispiel für Dialog:

    dialog --yesno 'Wollen Sie wirklich?' 40 100

    Shellscripte unter Linux erstellen - grafische Dialoge

    Shellscripte unter Linux erstellen - grafische Dialoge

    Unter Zenity:

    zenity --question

    Shellscripte unter Linux erstellen - grafische Dialoge

    Shellscripte unter Linux erstellen - grafische Dialoge

    Unter Kdialog:

    kdialog --yesno 'Wollen Sie wirklich?'

    Shellscripte unter Linux erstellen - grafische Dialoge

    Shellscripte unter Linux erstellen - grafische Dialoge

    Alle drei Programme geben als Exit-Code für Ja den Wert "0" und für Nein den Wert "1" aus.

    Jedes einzelne Programm wirklich durch zu gehen wäre etwas fehl am Platz - wir haben ja unsere Manpages die wir mittels:

    man dialog dialog --help man zenity zenity --help man kdialog kdialog --help

    öffnen.

    Wir müssen also unsere Variable nur noch durch das grafische Tool - ob nun dialog, zenity oder kadialog abfragen und auszugebende Werte durch ein Tool das Informationen anzeigen kann ausgeben lassen.

    Suche Nach oben Startseite Mail an den Autor Links rund um Linux









    SiteLock