Erstellen von Bash-Skripten. Bash-Funktionen in Skripten. Bedingungen. Mehrfachauswahl

Für Schreiben eines einfachen Bash-Skripts Wir müssen die folgenden einfachen Schritte ausführen:

So funktioniert das Ganze:

Die erste Zeile unseres Skripts #!/bin/bash ist für die erfolgreiche Ausführung unseres Skripts unerlässlich.

die zweite Zeile mkdir testdir erstellt das Verzeichnis testdir

die dritte zeile cd testdir ermöglicht den wechsel in das angelegte verzeichnis testdir

Team berühren in der nächsten zeile touch datei1 datei2 datei3 erstellt drei dateien

und der letzte Befehl in der Zeile unseres Skripts ls -al ermöglicht es uns, den Inhalt des aktuellen Verzeichnisses anzuzeigen, in dem dank der vorherigen Zeile drei leere Dateien erschienen sind.

Wie wir sehen können, in unserem einfaches Skript Alle Befehle beginnen in einer neuen Zeile. Jede Zeile führt beim Start des Skripts nacheinander ihre Arbeit aus und führt bestimmte Aktionen aus.

Wenn Sie unter Linux jeden Tag eine Reihe identischer Befehle (mit konstanten Parametern) ausführen, ist es möglicherweise sinnvoll, dieselben zu schreiben einfaches Bash-Skript, wodurch Sie Zeit sparen und Ihre Arbeit automatisieren können.

Schreiben von Skripten unter Linux (Lernen anhand von Beispielen)

———————————————————————————-

1. Einleitung

Was Sie zum Schreiben von Skripten benötigen
Kenntnisse der Kommandozeilen-Tools und deren notwendigen Optionen.
Grundkenntnisse in Englisch auf Grundschulniveau werden nicht beeinträchtigt.

Warum Skripte benötigt werden
Erstens läuft die Verwaltung eines Linux-Servers bis zu einem gewissen Grad auf die systematische Ausführung derselben Befehle hinaus. Darüber hinaus ist es nicht erforderlich, dass diese Befehle von einer Person ausgeführt werden. Sie können so programmiert werden, dass sie von einer Maschine ausgeführt werden.
Zweitens ist selbst das Ausführen einer normalen Aufgabe, die (plötzlich) 20-1000 ... sich wiederholende Operationen ausmacht, VIEL einfacher in einem Skript zu implementieren.

Was ist ein Skript
Ein Skript ist eine Reihe von Anweisungen, die ein Computer in einer bestimmten Reihenfolge und zu einem bestimmten Zeitpunkt ausführen muss. Anweisungen können entweder interne Shell-Befehle (Schleifen, Bedingungen, Verarbeitung von Textinformationen, Arbeiten mit Umgebungsvariablen usw.) oder jedes Programm sein, das wir in der Konsole mit den erforderlichen Parametern ausführen.

Wie schreibt man ein Drehbuch
In unserem Fall ist das Skript eine Textdatei mit Ausführungsattributen. Wenn eine Skriptdatei mit #! beginnt, was in der UNIX-Welt sha-bang genannt wird, teilt dies dem System mit, welchen Interpreter es verwenden soll, um das Skript auszuführen. Wenn dies schwer verständlich ist, denken Sie einfach daran, dass wir alle Skripte mit der Zeile #!/bin/bash oder #!/bin/sh schreiben, und dann werden die Befehle und Kommentare dorthin gesendet.

Abschiedswort
Ich rate Ihnen dringend, zu fast jeder Zeile im Skript so viele Kommentare wie möglich zu schreiben. Die Zeit vergeht und Sie müssen das einmal geschriebene Drehbuch ändern oder modernisieren. Wenn Sie sich nicht erinnern oder nicht verstehen, was im Skript geschrieben steht, wird es schwierig, es zu ändern, und es ist einfacher, von Grund auf neu zu schreiben.

Welche Skripte könnten wir brauchen:

Festlegen von Firewall-Regeln beim Systemstart.

Durchführen von Backups von Einstellungen und Daten.

Hinzufügen von Postfächern zum Mailserver (genauer gesagt zur MySQL-Datenbank)

Starten Sie zu einer bestimmten Zeit (vorzugsweise jede Nacht) ein Programm, das die Protokolle des Proxy-Servers scannt und einen praktischen Webbericht über die Menge des heruntergeladenen Datenverkehrs ausgibt.

Senden Sie uns per E-Mail die Information, dass jemand über ssh auf unseren Server zugegriffen hat, die Verbindungszeit und die Client-Adresse.

Über die Skripttechnik
Wir erstellen eine Textdatei, bearbeiten sie, setzen Ausführungsrechte, führen sie aus, überprüfen Fehler, beheben sie, führen sie aus, überprüfen Fehler ...
Wenn alles geleckt ist und korrekt funktioniert, legen wir es für eine bestimmte Zeit in Autoload oder in den Scheduler.

———————————————————————————-

2. Lernen, Skripte in der internen BASH-Sprache zu schreiben
Original: https://www.linuxconfig.org/Bash_scripting_Tutorial

Dieses Tutorial setzt keine Vorkenntnisse zum Schreiben von Skripten (im Folgenden als Skripte bezeichnet) unter Verwendung der Bash-internen Sprache voraus. Mit Hilfe dieses Leitfadens werden Sie schnell feststellen, dass das Schreiben von Skripten eine sehr einfache Aufgabe ist. Beginnen wir unser Tutorial mit einem einfachen Skript, das die Zeichenfolge "Hello World!" (übersetzt aus dem Englischen - Hallo zusammen!)

1. Szenario „Hallo zusammen“
Hier ist Ihr erstes Beispiel für ein Bash-Skript:

#!/bin/bash
Echo "Hallo Welt"

Wechseln Sie in das Verzeichnis, das unsere Datei hello_world.sh enthält, und machen Sie sie ausführbar:

Code: Alles auswählen $ chmod +x hello_world.sh

Führen Sie das Skript zur Ausführung aus

Code: Alle $ ./hello_world.sh auswählen

2. Ein einfaches Archivierungs-Bash-Skript

#!/bin/bash
tar -czf myhome_directory.tar.gz /home/user

Code: Wählen Sie alle $ ./backup.sh aus

$ du -sh meinhome_directory.tar.gz
41M myhome_directory.tar.gz

3. Arbeiten mit Variablen
In diesem Beispiel deklarieren wir eine einfache Variable und zeigen sie mit dem echo-Befehl auf dem Bildschirm an.

#!/bin/bash
STRING="HALLO WELT!!!"
echo $STRING

Code: Alle $ ./hello_world.sh auswählen
HALLO WELT!!!

Unser Archivierungsskript mit Variablen:

#!/bin/bash
OF=myhome_directory_$(date +%Y%m%d).tar.gz
IF=/home/benutzer
tar -czf $OF $IF

Code: Wählen Sie alle $ ./backup.sh aus
tar: Entfernen des führenden "\" aus Mitgliedsnamen
$ du -sh *tar.gz
41M myhome_directory_20100123.tar.gz

3.1 Globale und lokale Variablen

#!/bin/bash
# Deklarieren Sie eine globale Variable
# Diese Variable kann überall in diesem Skript verwendet werden
VAR="globale Variable"
Funktions-Bash (
# Deklarieren Sie eine lokale Variable
# Eine solche Variable ist nur für die Funktion gültig, in der sie deklariert ist
local VAR="lokale Variablen"
echo $VAR
}
echo $VAR
bash
# Beachten Sie, dass sich die globale Variable nicht geändert hat
echo $VAR

Code: Alle $ ./variables.sh auswählen
globale Variablen
lokale Variable
globale Variablen

4. Übergeben von Argumenten an das Skript

#!/bin/bash
# Verwenden Sie vordefinierte Variablen, um auf Argumente zuzugreifen
# Argumente auf dem Bildschirm ausgeben
echo $1 $2 $3 ' -> echo $1 $2 $3'

#Wir können auch über ein spezielles Array auf die Argumente zugreifen args=(" [E-Mail geschützt]»)
# Argumente auf dem Bildschirm ausgeben
echo $(args) $(args) $(args) ‘ -> args=(“ [E-Mail geschützt]»); echo $(args) $(args) $(args)'

# Verwenden Sie eine Variable [E-Mail geschützt] um alle Argumente auf einmal anzuzeigen
Echo [E-Mail geschützt]' -> Echo [E-Mail geschützt]’

Verwenden Sie die Variable $#, um die Anzahl der an das Skript übergebenen Argumente anzuzeigen
echo Anzahl der übergebenen Argumente: $# ‘ -> echo Anzahl der übergebenen Argumente: $#’

Code: Alle auswählen $ ./arguments.sh Bash Scripting Tutorial
Bash-Scripting-Tutorial -> echo $1 $2 $3
Bash-Scripting-Tutorial -> args=(" [E-Mail geschützt]"); echo $(args) $(args) $(args)
Bash-Scripting-Tutorial -> echo [E-Mail geschützt]
Anzahl übergebener Argumente: 3 -> echo Anzahl übergebener Argumente: $#

5. Ausführen von Shell-Befehlen in einem Skript

#!/bin/bash
# Backticks » ` ` » verwenden, um einen Shell-Befehl auszuführen
echo `uname -o`
# Versuchen wir es jetzt ohne Anführungszeichen
echo uname -o

Code: Alle auswählen $ uname -o
GNU/Linux
$ ./bash_backtricks.sh
GNU/Linux
uname-o

Wie Sie sehen können, wurde im zweiten Fall der Befehl selbst angezeigt und nicht das Ergebnis seiner Ausführung.

6. Benutzereingaben lesen (Interaktivität)

#!/bin/bash
echo -e "Hallo, bitte geben Sie das Wort ein: \c"
Wort lesen
echo "Das eingegebene Wort ist: $word"
echo -e "Können Sie bitte zwei Wörter eingeben? »
Lies Wort1 Wort2
echo "Hier ist Ihre Eingabe: \"$word1\" \"$word2\""
echo -e "Wie denkst du über Bash-Scripting? »
# Der Lesebefehl speichert jetzt eine Antwort in der standardmäßig eingebauten Variable $REPLY
lesen
echo "Du hast $ANTWORT gesagt, das freut mich zu hören! »
echo -e "Was sind deine Lieblingsfarben? »
# -a veranlasst den Lesebefehl, in ein Array einzulesen
lesen Sie -a Farben
echo "Meine Lieblingsfarben sind auch $(Farben), $(Farben) und $(Farben):-)"

Code: Wählen Sie alle $ ./read.sh aus
Hallo, bitte geben Sie das Wort ein: etwas
Das eingegebene Wort ist: etwas
Können Sie bitte zwei Wörter eingeben?
Debian-Linux
Hier ist Ihre Eingabe: "Debian" "Linux"
Was denkst du über Bash-Scripting?
gut
Du sagtest gut, das freut mich zu hören!
Was sind deine Lieblingsfarben?
blau grün schwarz
Meine Lieblingsfarben sind auch blau, grün und schwarz :-)

7. Mit der Falle

#!/bin/bash
# deklariere eine Falle
Falle Bashtrap INT
# den Bildschirm löschen
klar;
# Die Hook-Funktion wird ausgeführt, wenn der Benutzer STRG-C drückt:
# Wird angezeigt => Executing bash trap subrutine !
# aber das Skript wird weiter ausgeführt
Schlagfalle ()
{
echo "STRG+C erkannt !…bash trap ausführen !"
}
# Das Skript zählt bis 10
für a in "seq 1 10"; tun
echo "$a/10 zum Beenden."
schlafen1;
fertig
echo "Exit Bash Trap Beispiel!!!"

Code: Alle $ ./trap.sh auswählen
1/10
2/10
3/10
4/10
5/10
6/10

7/10
8/10
9/10
STRG+C Erkannt ! ... Bash-Trap wird ausgeführt !
10/10
Exit Bash Trap Beispiel!!!

Wie Sie sehen können, hat die Tastenkombination Strg-C die Skriptausführung nicht gestoppt.

8. Arrays
8.1 Ein einfaches Array deklarieren

#!/bin/bash
# Deklarieren Sie ein einfaches Array mit 4 Elementen
ARRAY=('Debian Linux' 'Redhat Linux' Ubuntu Linux)
# Holen Sie sich die Anzahl der Elemente im Array
ELEMENTE=$(#ARRAY[@])

# jedes Element des Arrays durchlaufen
für ((i=0;i<$ELEMENTS;i++)); do
echo $(ARRAY[$(i)])
fertig

Code: Wählen Sie alle $./arrays.sh aus
Debian-Linux
redhat linux
Ubuntu
Linux

8.2 Füllen eines Arrays mit Werten aus einer Datei

#!/bin/bash
# Deklarieren Sie ein Array
deklarieren Sie -a ARRAY
# exec-Befehl # stdin (normalerweise die Tastatur) wird aus dieser Datei erzeugt. Dadurch ist ein Lesen möglich
# den Inhalt der Datei, Zeile für Zeile, und jede eingegebene Zeile mit sed und/oder awk parsen.
Ausführung 10 letcount=0

während lesen LINE<&10; do

ARRAY[$count]=$LINE
((zählen++))
fertig

echo Anzahl der Elemente: $(#ARRAY[@])
# Array-Werte anzeigen
echo $(ARRAY[@])
# Datei schließen
exec 10>&-

Code: Alle auswählen $ cat bash.txt
Debian-Linux
redhat linux
Ubuntu
Linux
$ ./arrays.sh
Anzahl der Elemente: 4
Debian Linux Redhat Linux Ubuntu Linux

9. If-then-else-Bedingungen
9.1. Einfache Verwendung von „if-else“-Bedingungen
Achten Sie auf Leerzeichen in eckigen Klammern, ohne die die Bedingung nicht funktioniert.

#!/bin/bash
directory="./BashScripting"

# prüfen, ob das Verzeichnis existiert
if [ -d $verzeichnis ]; dann
echo "Verzeichnis existiert"
anders
Echo "Verzeichnis existiert nicht"
fi

Code: Alle auswählen $ ./if_else.sh
Verzeichnis existiert nicht
$ mkdir BashScripting
$ ./if_else.sh
Verzeichnis existiert

9.2 Verschachtelte if-else-Bedingungen

#!/bin/bash
# Deklarieren Sie eine Variable mit dem Wert 4
Wahl=4
# Anzeige
echo "1. bash"
echo "2. Skripterstellung»
echo "3. Lernprogramm"

# Ausführen solange die Variable gleich vier ist
# Schleife
while [ $choice -eq 4 ]; tun

# Benutzereingabe lesen
Wahl lesen
# verschachtelte "if-else"-Bedingung
if [ $choice -eq 1 ] ; dann

Echo "Sie haben Wort gewählt: Bash"

if [ $choice -eq 2 ] ; dann
echo "Sie haben Wort gewählt: Scripting"
anders

if [ $choice -eq 3 ] ; dann
Echo "Sie haben Wort gewählt: Tutorial"
anders
echo "Bitte treffen Sie eine Auswahl zwischen 1-3!"
echo "1. bash"
echo "2. Skripterstellung»
echo "3. Lernprogramm"
echo -n "Bitte wählen Sie ein Wort ? »
Wahl=4
fi
fi
fi
fertig

Code: Wählen Sie alle $ ./nested.sh aus
1. Schlag
2. Skripterstellung
3. Lernprogramm

5

1. Schlag
2. Skripterstellung
3. Lernprogramm
Bitte wählen Sie ein Wort
4
Bitte treffen Sie eine Auswahl zwischen 1-3 !
1. Schlag
2. Skripterstellung
3. Lernprogramm
Bitte wählen Sie ein Wort
3
Sie haben das Wort gewählt: Tutorial

Daher wird zuerst der Rumpf der „while“-Schleife ausgeführt, weil die Auswahlvariable wird anfänglich auf vier gesetzt. Dann lesen wir die Benutzereingabe hinein, und wenn die Eingabe nicht gleich 1,2 oder 3 ist, dann setzen wir unsere Variable wieder gleich 4, in Verbindung damit wiederholt sich der Schleifenkörper (Sie müssen erneut 1,2 oder 3 eingeben).

10. Vergleiche
10.1 Arithmetische Vergleiche

Leutnant<
-gt>
-le<=
-ge >=
-eq ==
-ne !=

#!/bin/bash

NUM1=2
NUM2=2
wenn [ $NUM1 -eq $NUM2 ]; dann
Echo "Beide Werte sind gleich"
anders
Echo "Werte sind NICHT gleich"
fi

Code: Wählen Sie alle $ ./equals.sh aus
Beide Werte sind gleich

#!/bin/bash
# Variablen mit ganzzahligen Werten deklarieren
NUM1=2
NUM2=3
wenn [ $NUM1 -eq $NUM2 ]; dann
Echo "Beide Werte sind gleich"
anders
Echo "Werte sind NICHT gleich"
fi

Code: Wählen Sie alle $ ./equals.sh aus
Werte sind NICHT gleich

#!/bin/bash
# Variablen mit ganzzahligen Werten deklarieren
NUM1=2
NUM2=1
wenn [ $NUM1 -eq $NUM2 ]; dann
Echo "Beide Werte sind gleich"
elif [ $NUM1 -gt $NUM2 ]; dann
echo "$NUM1 ist größer als $NUM2"
anders
echo "$NUM2 ist größer als $NUM1"
fi

Code: Wählen Sie alle $ ./equals.sh aus
2 ist größer als 1

10.2 Zeichen-Text-Vergleiche

Das gleiche
!= nicht gleich
< меньще чем
> mehr als
-n s1 Variable s1 ist nicht leer
-z s1 Variable s1 ist leer

#!/bin/bash

S1="Bash"

S2="Skripterstellung"
wenn [$S1 = $S2]; dann

anders
Echo "Strings sind NICHT gleich"
fi

Code: Wählen Sie alle $ ./statement.sh aus
Strings sind NICHT gleich

#!/bin/bash
# Symbolische Variable S1 deklarieren
S1="Bash"
# Symbolische Variable S2 deklarieren
S2="Bash"
wenn [$S1 = $S2]; dann
echo "Beide Strings sind gleich"
anders
Echo "Strings sind NICHT gleich"
fi

Code: Wählen Sie alle $ ./statement.sh aus
Beide Saiten sind gleich

11. Dateien prüfen

B Dateiname Spezielle Datei blockieren
-c Dateiname Datei mit Sonderzeichen
-d Verzeichnisname Prüfen Sie, ob das Verzeichnis existiert
-e Dateiname Prüfen Sie, ob die Datei existiert
-f Dateiname Prüfen Sie, ob eine reguläre Datei vorhanden ist, kein Verzeichnis
-G Dateiname Prüft, ob die Datei existiert und der effektiven Gruppen-ID gehört.
-g Dateiname wahr, wenn die Datei existiert und die Gruppen-ID ist.
-k Dateiname Sticky-Bit
-L Dateiname Symbolischer Link
-O Dateiname Wahr, wenn die Datei existiert und der effektiven Benutzer-ID gehört.
-r Dateiname Prüfe, ob die Datei lesbar ist
-S Dateiname Prüft, ob die Datei ein Socket ist
-s Dateiname Prüft, ob die Datei eine Größe ungleich Null hat
-u Dateiname Prüfe, ob das Dateiset-ser-id-Bit gesetzt ist
-w Dateiname Prüft, ob die Datei beschreibbar ist
-x Dateiname Prüfe, ob die Datei ausführbar ist

#!/bin/bash
file="./file"
if [ -e $datei ]; dann
echo "Datei existiert"
anders
Echo "Datei existiert nicht"
fi

Code: Wählen Sie alle $ ls
Datei.sh
$ ./file.sh
Die Datei existiert nicht
$ Touch-Datei
$ls
Datei Datei.sh
$ ./file.sh
Datei existiert

In ähnlicher Weise können wir für das Beispiel „while“-Schleifen verwenden, um zu prüfen, ob die Datei nicht existiert. Dieses Skript wird schlafen, bis die Datei existiert. Beachten Sie das Bash-Negativ "!" was die Option -e negiert (invertiert).

12. Zyklen
12.1. Für Schleife

#!/bin/bash
# for-Schleife
für f in $(ls /var/); tun
echo $f
fertig

Ausführen einer for-Schleife über die Bash-Befehlszeile:

Code: Wählen Sie alle $ für f in $(ls /var/); do echo $f; fertig Code: Wähle alle $ für f in $(ls /var/); do echo $f; fertig
Sicherungen
Zwischenspeicher
Absturz
Spiele
lib
lokal
sperren
Protokoll
Post
opt
Lauf
Spule
temp
www

12.2. while-Schleife

#!/bin/bash
ANZAHL=6
# while-Schleife
während [ $COUNT -gt 0 ]; tun

sei COUNT=COUNT-1
fertig

Code: Alle auswählen $ ./while_loop.sh
Zählwert ist: 6
Zählwert ist: 5
Zählwert ist: 4
Zählwert ist: 3
Zählwert ist: 2
Zählwert ist: 1

12.3. bis Schleife

#!/bin/bash
ANZAHL=0
#bis-Schleife
bis [ $COUNT -gt 5 ]; tun
echo Wert von count ist: $COUNT
sei COUNT=COUNT+1
fertig

Code: Alle auswählen $ ./until_loop.sh
Zählwert ist: 0
Zählwert ist: 1
Zählwert ist: 2
Zählwert ist: 3
Zählwert ist: 4
Zählwert ist: 5

12.4. Schleifen mit impliziten Bedingungen
Im folgenden Beispiel ist die Bedingung der While-Schleife das Vorhandensein einer Standardeingabe.
Der Rumpf der Schleife wird so lange ausgeführt, wie etwas von der Standardausgabe zum Lesebefehl umgeleitet werden soll.

#!/bin/bash
# Dieses Skript findet und entfernt Leerzeichen
# in Dateien und ersetzt sie durch Unterstriche
DIR="."
Steuerung der Schleife mit dem Lesebefehl durch Umleitung der Ausgabe in der Schleife.
finde $DIR -type f | während Datei gelesen wird; tun
# Verwenden Sie die POSIX-Klasse [:space:], um Leerzeichen in Dateinamen zu finden
if [[ "$file" = *[[:space:]]* ]]; dann
# Leerzeichen durch Unterstriche ersetzen
mv "$file" `echo $file | tr ‘ ‘ ‘_’’
fi;
fertig

Code: Alle auswählen $ ls -1
script.sh
$ "Datei mit Leerzeichen" berühren
$ls-1
Datei mit Leerzeichen
script.sh
$ ./script.sh
$ls-1
file_with_spaces
script.sh

13. Funktionen

#!/bin/bash
# Funktionen können in beliebiger Reihenfolge deklariert werden
Funktion Funktion_B(
Echofunktion B.
}
Funktion Funktion_A(
Echo $1
}
Funktion Funktion_D(
Echo-Funktion D.
}
Funktion_C(
Echo $1
}
# Funktionen aufrufen
# Parameter an Funktion A übergeben
function_A "Funktion A."
Funktion_B
# Übergabeparameter an Funktion C-Funktion
function_C "Funktion C."
Funktion_D

Code: Wählen Sie alle $ ./functions.sh aus
Funktion A.
Funktion B.
Funktion C.
Funktion D.

14. Betreiber auswählen - Auswählen

#!/bin/bash
PS3='Wähle ein Wort:'
# wählen
Wählen Sie das Wort in "Linux" "Bash" "Scripting" "Tutorial"
tun
echo "Das ausgewählte Wort ist: $word"
# Break, sonst wird die Schleife unendlich.
brechen
fertig
Ausgang 0

Code: Alle auswählen $ ./select.sh
1) Linux
2) bash
3) Skripterstellung
4) Anleitung
Wähle ein Wort: 4
Das Wort, das Sie ausgewählt haben, ist: Tutorial

15. Auswahloperator - Fall

#!/bin/bash
echo "Was ist Ihre bevorzugte Programmier-/Skriptsprache"
echo "1) bash"
Echo "2) Perl"
Echo "3) Phyton"
echo "4) c++"
Echo "5) Ich weiß nicht!"
Fall lesen;
# eine einfache Case-Choice-Struktur
# Beachten Sie, dass $case in diesem Beispiel nur eine Variable ist
# und muss nicht so heißen. Dies ist nur ein Beispiel
$Fall rein
1) Echo "Sie haben bash ausgewählt";;
2) Echo "Sie haben Perl ausgewählt";;
3) Echo "Sie haben Phyton ausgewählt";;
4) Echo "Sie haben C++ ausgewählt";;
5) Ausgang
esac

Code: Alle $ ./case.sh auswählen
Was ist Ihre bevorzugte Programmier-/Skriptsprache?
1) bash
2) Perle
3) Pflanzen
4) c++
5) Ich weiß nicht!
4
Sie haben c++ ausgewählt

———————————————————————————-

Nähere Informationen erhalten Sie aus verschiedenen Quellen, zum Beispiel hier
Original: https://www.linuxconfig.org/Bash_scripting_Tutorial
https://ruslandh.narod.ru/howto_ru/Bash-Prog-Intro/
https://bug.cf1.ru/2005-03-17/programmin … -book.html

https://ubuntologia.ru/forum/viewtopic.php?f=109&t=2296

Heute werden wir über Bash-Skripte sprechen. Dies sind Befehlszeilenskripte, die für die Bash-Shell geschrieben wurden. Es gibt andere Shells wie zsh, tcsh, ksh, aber wir konzentrieren uns auf bash. Dieses Material ist für alle bestimmt, die einzige Bedingung ist die Fähigkeit, auf der Linux-Befehlszeile zu arbeiten.

Befehlszeilenskripte sind Sätze derselben Befehle, die über die Tastatur eingegeben, in Dateien gesammelt und durch einen gemeinsamen Zweck vereint werden können. Gleichzeitig können die Ergebnisse der Teamarbeit entweder von eigenständigem Wert sein oder als Input für andere Teams dienen. Skripte sind eine leistungsstarke Möglichkeit, häufig ausgeführte Aktionen zu automatisieren.

Wenn wir also über die Befehlszeile sprechen, können Sie mehrere Befehle gleichzeitig ausführen, indem Sie sie mit einem Semikolon eingeben:

pwd ; Wer bin ich
Wenn Sie dies in Ihrem Terminal ausprobiert haben, wurde Ihr erstes Bash-Skript, das zwei Befehle verwendet, bereits geschrieben. Es funktioniert so. Der Befehl pwd zeigt zuerst Informationen über das aktuelle Arbeitsverzeichnis an, dann zeigt der Befehl whoami Informationen über den Benutzer an, unter dem Sie angemeldet sind.

Mit einem ähnlichen Ansatz können Sie beliebig viele Befehle in einer Zeile kombinieren, die Grenze ist nur die maximale Anzahl von Argumenten, die an das Programm übergeben werden können. Sie können diese Grenze mit dem folgenden Befehl definieren:

Getconf ARG_MAX
Die Befehlszeile ist ein großartiges Werkzeug, aber Sie müssen jedes Mal Befehle eingeben, wenn Sie sie benötigen. Was wäre, wenn wir eine Reihe von Befehlen in eine Datei schreiben und diese Datei einfach aufrufen, um sie auszuführen? Tatsächlich wird die Datei, über die wir sprechen, als Befehlszeilenskript bezeichnet.

Funktionsweise von Bash-Skripten

Erstellen Sie mit dem Touch-Befehl eine leere Datei. In der ersten Zeile müssen Sie angeben, welche Shell wir verwenden werden. Wir interessieren uns für bash , also lautet die erste Zeile der Datei:

#!/bin/bash
An anderer Stelle in dieser Datei wird das Hash-Symbol verwendet, um Kommentare anzuzeigen, die die Shell nicht verarbeitet. Die erste Zeile ist jedoch ein Sonderfall, bei dem ein Rautezeichen gefolgt von einem Ausrufezeichen (als Shebang bezeichnet) und ein Bash-Pfad dem System anzeigen, dass das Skript speziell für bash geschrieben wurde.

Shell-Befehle werden durch einen Zeilenvorschub getrennt, Kommentare werden durch ein Nummernzeichen getrennt. So sieht es aus:

#!/bin/bash # Dies ist ein Kommentar pwd whoami
Hier können Sie, genau wie in der Befehlszeile, Befehle in einer Zeile schreiben, indem Sie sie durch ein Semikolon trennen. Wenn Sie Befehle jedoch in verschiedene Zeilen schreiben, ist die Datei einfacher zu lesen. In jedem Fall verarbeitet die Shell sie.

Festlegen von Berechtigungen für eine Skriptdatei

Speichern Sie die Datei und nennen Sie sie myscript , und Sie sind mit dem Bash-Skript fast fertig. Jetzt müssen Sie diese Datei nur noch ausführbar machen, da Sie sonst beim Versuch, sie auszuführen, auf einen Permission denied-Fehler stoßen.

Versuch, eine Skriptdatei mit falsch konfigurierten Berechtigungen auszuführen

Machen wir die Datei ausführbar:

Chmod +x ./myscript
Versuchen wir nun, es auszuführen:

./myscript
Nach dem Setzen der Berechtigungen funktioniert alles wie es soll.

Führen Sie das Bash-Skript erfolgreich aus

Meldungsausgabe

Der echo-Befehl wird verwendet, um Text auf der Linux-Konsole auszugeben. Lassen Sie uns das Wissen um diese Tatsache nutzen und unser Skript bearbeiten, indem wir Erklärungen zu den Daten hinzufügen, die die bereits darin enthaltenen Befehle ausgeben:

#!/bin/bash # hier steht unser Kommentar echo "Das aktuelle Verzeichnis ist:" pwd echo "Der angemeldete Benutzer ist:" whoami
Folgendes passiert nach dem Ausführen des aktualisierten Skripts.

Nachrichten aus einem Skript ausgeben

Jetzt können wir mit dem echo-Befehl erklärende Beschriftungen anzeigen. Wenn Sie nicht wissen, wie Sie eine Datei mit Linux-Tools bearbeiten, oder den echo-Befehl noch nicht kennen, werfen Sie einen Blick auf diesen Artikel.

Verwenden von Variablen

Mit Variablen können Sie Informationen in der Skriptdatei speichern, beispielsweise die Ergebnisse von Befehlen zur Verwendung durch andere Befehle.

Es spricht nichts dagegen, einzelne Befehle auszuführen, ohne die Ergebnisse ihrer Arbeit zu speichern, aber die Möglichkeiten dieses Ansatzes sind sehr begrenzt.

Es gibt zwei Arten von Variablen, die in Bash-Skripten verwendet werden können:

• Umgebungsvariablen
• Benutzervariablen

Umgebungsvariablen

Manchmal müssen Shell-Befehle mit einigen Systemdaten arbeiten. So zeigen Sie beispielsweise das Home-Verzeichnis des aktuellen Benutzers an:

#!/bin/bash # Benutzer-Home-Echo anzeigen "Home für den aktuellen Benutzer ist: $HOME"
Bitte beachten Sie, dass wir die Systemvariable $HOME in doppelten Anführungszeichen verwenden können, dies wird das System jedoch nicht daran hindern, sie zu erkennen. Folgendes passiert, wenn Sie das obige Skript ausführen.

Verwenden einer Umgebungsvariablen in einem Skript

Aber was ist, wenn Sie ein Dollarzeichen anzeigen möchten? Lass uns das versuchen:

Echo "Ich habe 1 $ in meiner Tasche"
Das System erkennt ein Dollarzeichen in einem durch Anführungszeichen begrenzten String und geht davon aus, dass wir auf eine Variable verwiesen haben. Das Skript versucht, den Wert der undefinierten Variablen $1 anzuzeigen. Das brauchen wir nicht. Was zu tun ist?

In einer solchen Situation hilft die Verwendung des Backslash-Steuerzeichens vor dem Dollarzeichen:

Echo "Ich habe \$1 in meiner Tasche"
Das Skript gibt nun genau das aus, was erwartet wird.

Verwenden einer Escape-Sequenz zur Ausgabe eines Dollarzeichens

Benutzervariablen

Zusätzlich zu Umgebungsvariablen können Sie mit Bash-Skripten Ihre eigenen Variablen im Skript festlegen und verwenden. Solche Variablen halten einen Wert, bis das Skript endet.

Auf Benutzervariablen kann wie auf Systemvariablen mit dem Dollarzeichen zugegriffen werden:
TNW-CUS-FMP - Promo-Code für 10 % Rabatt auf unsere Dienstleistungen, der innerhalb von 7 Tagen aktiviert werden kann
#!/bin/bash # Testvariablen grade=5 person="Adam" echo "$person ist ein guter Junge, er ist in der Klasse $grade"
Folgendes passiert nach dem Ausführen eines solchen Skripts.

Benutzerdefinierte Variablen im Skript

Befehlsersetzung

Eine der nützlichsten Funktionen von Bash-Skripten ist die Möglichkeit, Informationen aus der Ausgabe von Befehlen zu extrahieren und sie Variablen zuzuweisen, wodurch Sie diese Informationen überall in der Skriptdatei verwenden können.

Dies kann auf zwei Arten erfolgen.

• Mit dem Backtick-Zeichen "`"
• Mit dem $()-Konstrukt

Wenn Sie den ersten Ansatz verwenden, achten Sie darauf, kein einfaches Anführungszeichen anstelle eines Backticks zu verwenden. Der Befehl muss in zwei solche Symbole eingeschlossen werden:

mydir=`pwd`
Im zweiten Ansatz wird dasselbe wie folgt geschrieben:

mydir=$(pwd)
Und das Skript könnte am Ende so aussehen:

#!/bin/bash mydir=$(pwd) echo $mydir
Im Laufe seiner Arbeit wird die Ausgabe des pwd-Befehls in der mydir-Variablen gespeichert, deren Inhalt mit dem echo-Befehl in die Konsole fällt.

Skript, das die Ergebnisse des Befehls in einer Variablen speichert

Mathematische Operationen

Um mathematische Operationen in einer Skriptdatei auszuführen, können Sie eine Konstruktion wie $((a+b)) verwenden:

#!/bin/bash var1=$((5 + 5)) echo $var1 var2=$(($var1 * 2)) echo $var2

Mathematische Operationen in einem Skript

wenn-dann Kontrollstruktur

In einigen Szenarien ist es erforderlich, den Fluss der Befehlsausführung zu steuern. Wenn beispielsweise ein bestimmter Wert größer als fünf ist, muss eine Aktion ausgeführt werden, andernfalls eine andere. Dies ist in vielen Situationen anwendbar, und das Wenn-Dann-Kontrollkonstrukt wird uns hier helfen. In seiner einfachsten Form sieht es so aus:

Wenn Befehl dann Befehle fi
Und hier ist ein funktionierendes Beispiel:

#!/bin/bash if pwd then echo "It works" fi
Wenn in diesem Fall der pwd-Befehl erfolgreich abgeschlossen wird, wird der Text „es funktioniert“ auf der Konsole ausgegeben.

Lassen Sie uns unser Wissen nutzen und ein komplexeres Szenario schreiben. Nehmen wir an, Sie möchten einen Benutzer in /etc/passwd finden und, wenn Sie ihn finden können, melden, dass er existiert.

#!/bin/bash user=likegeeks if grep $user /etc/passwd then echo "The user $user Exists" fi
Das passiert nach dem Ausführen dieses Skripts.

Benutzersuche

Hier haben wir den Befehl grep verwendet, um den Benutzer in der Datei /etc/passwd zu finden. Wenn Ihnen der grep-Befehl nicht vertraut ist, finden Sie seine Beschreibung hier.

Wenn der Benutzer in diesem Beispiel gefunden wird, zeigt das Skript eine entsprechende Meldung an. Was ist, wenn der Benutzer nicht gefunden werden konnte? In diesem Fall schließt das Skript die Ausführung einfach ab, ohne uns etwas mitzuteilen. Ich möchte, dass er uns auch davon erzählt, also lasst uns den Code verbessern.

Das if-then-else-Kontrollkonstrukt

Damit das Programm sowohl die Ergebnisse einer erfolgreichen als auch einer fehlgeschlagenen Suche melden kann, verwenden wir das if-then-else-Konstrukt. So wird es eingerichtet:

if befehl then befiehlt else befiehlt fi
Wenn der erste Befehl Null zurückgibt, was bedeutet, dass er erfolgreich war, ist die Bedingung wahr und die Ausführung geht nicht über den Else-Zweig. Andernfalls, wenn etwas anderes als Null zurückgegeben wird, was einen Fehler oder ein falsches Ergebnis bedeutet, werden die Befehle nach dem else ausgeführt.

Lassen Sie uns das folgende Skript schreiben:

#!/bin/bash user=anotherUser if grep $user /etc/passwd then echo "Der Benutzer $user existiert" else echo "Der Benutzer $user existiert nicht" fi
Seine Ausführung erfolgte entlang des Else-Zweigs.

Ausführen eines Skripts mit einem if-then-else-Konstrukt

Nun, machen wir weiter und fragen uns nach schwierigeren Bedingungen. Was ist, wenn Sie nicht eine Bedingung, sondern mehrere prüfen müssen? Wenn beispielsweise der erforderliche Benutzer gefunden wird, sollte eine Nachricht angezeigt werden, wenn eine andere Bedingung erfüllt ist, sollte eine andere Nachricht angezeigt werden und so weiter. In einer solchen Situation helfen uns verschachtelte Bedingungen. Es sieht aus wie das:

Wenn Befehl1 dann elif befiehlt, befiehlt Befehl2 dann fi
Wenn der erste Befehl null zurückgibt, was einen Erfolg anzeigt, werden die Befehle im ersten then-Block ausgeführt, andernfalls, wenn die erste Bedingung falsch ist und der zweite Befehl null zurückgibt, wird der zweite Codeblock ausgeführt.

#!/bin/bash user=anotherUser if grep $user /etc/passwd then echo "The user $user Exists" elif ls /home then echo "Der Benutzer existiert nicht, aber trotzdem gibt es ein Verzeichnis unter /home" fi
In einem solchen Skript können Sie beispielsweise mit dem Befehl useradd einen neuen Benutzer erstellen, wenn die Suche keine Ergebnisse liefert, oder etwas anderes nützliches tun.

Zahlenvergleich

In Skripten können Sie numerische Werte vergleichen. Nachfolgend finden Sie eine Liste relevanter Befehle.

n1 -eq n2 Gibt wahr zurück, wenn n1 gleich n2 ist.
n1 -ge n2 Gibt wahr zurück, wenn n1 größer oder gleich n2 ist.
n1 -gt n2 Gibt wahr zurück, wenn n1 größer als n2 ist.
n1 -le n2 Gibt wahr zurück, wenn n1 kleiner oder gleich n2 ist.
n1 -lt n2 Gibt wahr zurück, wenn n1 kleiner als n2 ist.
n1 -ne n2 Gibt wahr zurück, wenn n1 ungleich n2 ist.

Lassen Sie uns als Beispiel einen der Vergleichsoperatoren ausprobieren. Beachten Sie, dass der Ausdruck in eckige Klammern eingeschlossen ist.

#!/bin/bash val1=6 if [ $val1 -gt 5 ] then echo "Der Testwert $val1 ist größer als 5" else echo "Der Testwert $val1 ist nicht größer als 5" fi
Hier ist, was dieser Befehl ausgeben wird.

Vergleichen von Zahlen in Skripten

Der Wert der Variable val1 ist größer als 5, dadurch wird der then-Zweig des Vergleichsoperators ausgeführt und die entsprechende Meldung in der Konsole ausgegeben.

String-Vergleich

Skripte können auch Zeichenfolgenwerte vergleichen. Vergleichsoperatoren sehen recht einfach aus, aber String-Vergleichsoperatoren haben einige Besonderheiten, auf die wir weiter unten eingehen werden. Hier ist eine Liste von Operatoren.

str1 = str2 Testet Strings auf Gleichheit, gibt true zurück, wenn Strings identisch sind.
s tr1 != str2 Gibt wahr zurück, wenn die Zeichenketten nicht identisch sind.
str1< str2 Возвращает истину, если str1 меньше, чем str2 .
str1 > str2 Gibt wahr zurück, wenn str1 größer als str2 ist.
-n str1 Gibt wahr zurück, wenn die Länge von str1 größer als Null ist.
-z str1 Gibt wahr zurück, wenn die Länge von str1 Null ist.

Hier ist ein Beispiel für einen Zeichenfolgenvergleich in einem Skript:

#!/bin/bash user ="likegeeks" if [$user = $USER] then echo "Der Benutzer $user ist der aktuell angemeldete Benutzer" fi
Als Ergebnis der Skriptausführung erhalten wir Folgendes.

Zeichenfolgenvergleich in Skripten

Hier ist eine Funktion des String-Vergleichs, die es wert ist, erwähnt zu werden. Die Operatoren „>“ und „<» необходимо экранировать с помощью обратной косой черты, иначе скрипт будет работать неправильно, хотя сообщений об ошибках и не появится. Скрипт интерпретирует знак «>' als Ausgabeumleitungsbefehl.

So sieht die Arbeit mit diesen Operatoren im Code aus:

#!/bin/bash val1=Text val2="anderer Text" if [ $val1 \>
Hier sind die Ergebnisse des Skripts.

Zeichenfolgenvergleich, Warnung ausgegeben

Beachten Sie, dass das Skript, obwohl es ausgeführt wird, eine Warnung ausgibt:

./myscript: Zeile 5: [: zu viele Argumente
Um diese Warnung zu beseitigen, schließen Sie $val2 in doppelte Anführungszeichen ein:

#!/bin/bash val1=Text val2="anderer Text" if [ $val1 \> "$val2" ] then echo "$val1 ist größer als $val2" else echo "$val1 ist kleiner als $val2" fi
Jetzt funktioniert alles wie es soll.

String-Vergleich

Ein weiteres Merkmal der ">" und "<» заключается в том, как они работают с символами в верхнем и нижнем регистрах. Для того, чтобы понять эту особенность, подготовим текстовый файл с таким содержимым:

Likefreaks likefreaks
Speichern Sie es unter dem Namen myfile und führen Sie dann den folgenden Befehl im Terminal aus:

Meine Datei sortieren
Es sortiert die Zeilen aus der Datei wie folgt:

Likegeeks Likegeeks
Der sort-Befehl sortiert Strings standardmäßig in aufsteigender Reihenfolge, d.h. der Kleinbuchstabe in unserem Beispiel ist kleiner als der Großbuchstabe. Lassen Sie uns nun ein Skript vorbereiten, das dieselben Zeichenfolgen vergleicht:

#!/bin/bash val1=Likegeeks val2=Likegeeks if [ $val1 \> $val2 ] then echo "$val1 ist größer als $val2" else echo "$val1 ist kleiner als $val2" fi
Wenn Sie es ausführen, stellt sich heraus, dass das Gegenteil der Fall ist - der Kleinbuchstabe ist jetzt größer als der Großbuchstabe.

Sortierbefehl und Zeichenfolgenvergleich in der Skriptdatei

Bei Vergleichsbefehlen sind Großbuchstaben kleiner als Kleinbuchstaben. Der String-Vergleich erfolgt hier durch Vergleich der ASCII-Zeichencodes, die Sortierreihenfolge ist also abhängig von den Zeichencodes.

Der Sortierbefehl wiederum verwendet die in den Spracheinstellungen des Systems festgelegte Sortierreihenfolge.

Dateiprüfungen

Vielleicht werden die folgenden Befehle am häufigsten in Bash-Skripten verwendet. Sie ermöglichen es Ihnen, verschiedene Bedingungen in Bezug auf Dateien zu überprüfen. Hier ist eine Liste dieser Befehle.

-d Datei Überprüft, ob die Datei existiert und ein Verzeichnis ist.
-e Datei Prüft, ob eine Datei existiert.
-f Datei Überprüft, ob eine Datei existiert und eine Datei ist.
-r Datei Prüft, ob die Datei existiert und lesbar ist.
-s Datei Prüft, ob die Datei existiert und nicht leer ist.
-w Datei Überprüft, ob die Datei existiert und beschreibbar ist.
-x Datei Prüft, ob die Datei existiert und ausführbar ist.
file1 -nt file2 Überprüft, ob file1 neuer als file2 ist.
file1 -ot file2 Überprüft, ob file1 älter als file2 ist.
-O Datei Überprüft, ob die Datei existiert und dem aktuellen Benutzer gehört.
-G Datei Überprüft, ob die Datei existiert und ob ihre Gruppen-ID mit der Gruppen-ID des aktuellen Benutzers übereinstimmt.

Diese Befehle sowie viele andere, die heute besprochen wurden, sind leicht zu merken. Ihre Namen, die Abkürzungen für verschiedene Wörter sind, weisen direkt auf die von ihnen durchgeführten Kontrollen hin.

Lassen Sie uns einen der Befehle in der Praxis ausprobieren:

#!/bin/bash mydir=/home/likegeeks if [ -d $mydir ] then echo "Das Verzeichnis $mydir existiert" cd $ mydir ls else echo "Das Verzeichnis $mydir existiert nicht" fi
Dieses Skript zeigt für ein vorhandenes Verzeichnis dessen Inhalt an.

Auflisten des Inhalts eines Verzeichnisses

Wir glauben, dass Sie mit den restlichen Befehlen selbst experimentieren können, sie gelten alle nach demselben Prinzip.

Ergebnisse

Heute haben wir darüber gesprochen, wie man mit dem Schreiben von Bash-Skripten beginnt, und einige grundlegende Dinge behandelt. Tatsächlich ist das Thema Bash-Programmierung riesig. Dieser Artikel ist eine Übersetzung des ersten Teils einer großen Serie von 11 Materialien. Wenn Sie gleich weitermachen möchten – hier ist eine Liste der Originale dieser Materialien. Der Einfachheit halber ist diejenige, deren Übersetzung Sie gerade gelesen haben, hier enthalten.

Egal wie einfach die grafische Oberfläche in Linux ist und egal wie viele Funktionen es gibt, es gibt immer noch Aufgaben, die bequemer über das Terminal zu lösen sind. Erstens, weil es schneller ist, und zweitens haben nicht alle Maschinen eine grafische Oberfläche, zum Beispiel werden auf Servern alle Aktionen über das Terminal ausgeführt, um Rechenressourcen zu sparen.

Wenn Sie bereits ein erfahrener Benutzer sind, führen Sie wahrscheinlich häufig verschiedene Aufgaben über das Terminal aus. Oft gibt es Aufgaben, für die Sie mehrere Befehle nacheinander ausführen müssen. Um beispielsweise das System zu aktualisieren, müssen Sie zuerst die Repositories aktualisieren und erst dann neue Versionen von Paketen herunterladen. Dies ist nur ein Beispiel und es gibt viele solcher Aktionen, sogar das Erstellen von Backups und das Hochladen kopierter Dateien auf einen Remote-Server. Um dieselben Befehle nicht mehrmals einzugeben, können Sie daher Skripte verwenden. In diesem Artikel werden wir uns mit dem Schreiben von Skripten in Bash befassen, uns die grundlegenden Operatoren ansehen, sowie wie sie funktionieren, sozusagen Bash-Skripte von Grund auf neu.

Ein Skript, oder wie es auch genannt wird, ein Skript, ist eine Folge von Befehlen, die wiederum von einem Interpreterprogramm gelesen und ausgeführt werden, in unserem Fall ist es ein Kommandozeilenprogramm – bash.

Ein Skript ist eine einfache Textdatei, die die üblichen Befehle auflistet, die wir normalerweise manuell eingeben, sowie das Programm, das sie ausführt. Der Lader, der das Skript ausführt, weiß nicht, wie er mit Umgebungsvariablen arbeiten soll, daher muss er den genauen Pfad an das zu startende Programm übergeben. Und dann wird es Ihr Skript an dieses Programm übergeben und die Ausführung beginnt.

Das einfachste Beispiel eines Skripts für eine Bash-Shell:

!/bin/bash
Echo "Hallo Welt"

Das Echo-Dienstprogramm gibt die ihm übergebene Zeichenfolge als Parameter auf dem Bildschirm aus. Die erste Zeile ist etwas Besonderes, sie gibt das Programm an, das die Befehle ausführt. Grundsätzlich können wir ein Skript auch in jeder anderen Programmiersprache erstellen und den gewünschten Interpreter angeben, beispielsweise in Python:

!/usr/bin/env python
print("Hallo Welt")

Oder in PHP:

!/usr/bin/env php
echo "Hallo Welt";

Im ersten Fall haben wir direkt auf das Programm verwiesen, das die Befehle ausführt; in den nächsten beiden kennen wir die genaue Adresse des Programms nicht, also bitten wir das Dienstprogramm env, es nach Namen zu finden und auszuführen. Dieser Ansatz wird in vielen Skripten verwendet. Aber das ist nicht alles. Damit das System auf einem Linux-System ein Skript ausführen kann, müssen Sie das Executable-Flag für die Datei damit setzen.

Dieses Flag ändert nichts in der Datei selbst, es teilt dem System nur mit, dass dies nicht nur eine Textdatei ist, sondern ein Programm, das ausgeführt werden muss, öffnen Sie die Datei, finden Sie den Interpreter heraus und führen Sie es aus. Wenn kein Interpreter angegeben ist, wird standardmäßig der Interpreter des Benutzers verwendet. Da aber nicht jeder bash verwendet, müssen Sie dies explizit angeben.

Laufen:

chmod ugo+x script_file

Jetzt führen wir unser kleines erstes Programm aus:

./Skriptdatei

Alles arbeitet. Sie wissen bereits, wie man ein kleines Skript für, sagen wir, ein Update schreibt. Wie Sie sehen können, enthalten die Skripte die gleichen Befehle, die im Terminal ausgeführt werden, sie sind sehr einfach zu schreiben. Aber jetzt werden wir die Aufgabe ein wenig erschweren. Da ein Skript ein Programm ist, muss es selbst einige Entscheidungen treffen, die Ergebnisse der Befehlsausführung speichern und Schleifen ausführen. All dies kann mit der Bash-Shell durchgeführt werden. Hier ist zwar alles viel komplizierter. Fangen wir einfach an.

Variablen in Skripten

Das Schreiben von Skripten in Bash ist selten vollständig, ohne temporäre Daten zu speichern, was das Erstellen von Variablen bedeutet. Keine Programmiersprache kommt ohne Variablen aus, unsere primitive Shell-Sprache auch nicht.

Möglicherweise sind Sie schon einmal auf Umgebungsvariablen gestoßen. Das sind also die gleichen Variablen und sie funktionieren auf die gleiche Weise.

Lassen Sie uns zum Beispiel eine String-Variable deklarieren:

string="Hallo Welt"

Der Wert unserer Zeichenfolge steht in Anführungszeichen. Tatsächlich sind Anführungszeichen jedoch nicht immer erforderlich. Das Hauptprinzip von bash wird hier beibehalten - ein Leerzeichen ist ein Sonderzeichen, ein Trennzeichen. Wenn Sie also keine Anführungszeichen verwenden, wird world bereits als separater Befehl betrachtet, aus dem gleichen Grund setzen wir keine Leerzeichen vor und nach dem Gleichheitszeichen Unterschrift.

Das $-Symbol wird verwendet, um den Wert einer Variablen anzuzeigen. Zum Beispiel:

Ändern wir unser Skript:

!/bin/bash
string1="Hallo"
string2=welt
string=$string1$string2
echo $string

Und wir prüfen:

Bash unterscheidet nicht wie Hochsprachen wie C++ zwischen Variablentypen, man kann einer Variablen sowohl eine Zahl als auch einen String zuweisen. Ebenso wird all dies als Zeichenfolge betrachtet. Die Shell unterstützt nur das Zusammenführen von Strings, schreiben Sie dazu einfach die Variablennamen hintereinander:

!/bin/bash
string1="Hallo"
string2=welt
string=$string1$string2\ und\ ich
string3=$string1$string2" und ich"
echo $string3

Wir überprüfen:

Bitte beachten Sie, dass Anführungszeichen, wie gesagt, optional sind, wenn keine Sonderzeichen in der Zeichenfolge enthalten sind. Schauen Sie sich beide Möglichkeiten zum Zusammenführen von Zeichenfolgen genauer an, die Rolle von Anführungszeichen wird hier ebenfalls demonstriert. Wenn Sie eine fortgeschrittenere Zeichenfolgenverarbeitung oder arithmetische Operationen benötigen, ist dies nicht in den Fähigkeiten der Shell enthalten, dafür werden gewöhnliche Dienstprogramme verwendet.

Variablen und Befehlsausgabe

Variablen wären nicht so nützlich, wenn sie das Ergebnis der Ausführung von Dienstprogrammen nicht speichern könnten. Dazu wird folgende Syntax verwendet:

$(Team )

Mit diesem Konstrukt wird die Ausgabe des Befehls direkt dorthin umgeleitet, wo sie aufgerufen wurde, und nicht auf den Bildschirm. Das Datumsdienstprogramm gibt beispielsweise das aktuelle Datum zurück. Diese Befehle sind gleichwertig:

Verstehst du? Lassen Sie uns ein Skript schreiben, in dem Hello World und Date angezeigt werden:

string1="Hallo Welt"
string2=$(datum)

string=$string1$string2

Jetzt wissen Sie genug über Variablen und sind bereit, ein Bash-Skript zu erstellen, aber es kommt noch mehr. Als nächstes betrachten wir die Parameter und Kontrollstrukturen. Ich möchte Sie daran erinnern, dass dies alles normale Bash-Befehle sind und Sie sie nicht in einer Datei speichern müssen, sondern sie sofort unterwegs ausführen können.

Skriptparameter

Es ist nicht immer möglich, ein Bash-Skript zu erstellen, das nicht von Benutzereingaben abhängt. In den meisten Fällen müssen Sie den Benutzer fragen, welche Aktion ausgeführt oder welche Datei verwendet werden soll. Beim Aufruf eines Skripts können wir ihm Parameter übergeben. Alle diese Parameter sind als Variablen verfügbar, die als Zahlen benannt sind.

Die Variable mit dem Namen 1 enthält den Wert des ersten Parameters, die Variable 2 den zweiten und so weiter. Dieses Bash-Skript gibt den Wert des ersten Parameters aus:

!/bin/bash
Echo $1

Steuerkonstrukte in Skripten

Das Erstellen eines Bash-Skripts wäre ohne die Fähigkeit, bestimmte Faktoren zu analysieren und die erforderlichen Aktionen als Reaktion darauf auszuführen, nicht so nützlich. Dies ist ein ziemlich komplexes Thema, aber es ist sehr wichtig, um ein Bash-Skript zu erstellen.

In Bash gibt es einen Befehl zum Prüfen von Bedingungen mit folgender Syntax:

wenn Befehlsbedingung
dann
Team
anders
Team
fi

Dieser Befehl prüft den Exit-Code des Bedingungsbefehls, und wenn 0 (Erfolg) dann den Befehl oder mehrere Befehle nach dem Wort ausführt, dann wird, wenn der Exit-Code 1 ist, der Else-Block ausgeführt, dh der Abschluss des Blocks von Befehle.

Da es uns aber meistens nicht um den Returncode des Befehls geht, sondern um den Vergleich von Strings und Zahlen, wurde der Befehl [[ eingeführt, mit dem Sie verschiedene Vergleiche durchführen und je nach Ergebnis des Vergleichs einen Returncode ausgeben können. Seine Syntax ist:

[[ Parameter1 Operator Parameter2 ]]

Zum Vergleich verwenden wir die bereits bekannten Operatoren<,>,=,!= usw. Wenn der Ausdruck wahr ist, gibt der Befehl 0 zurück, wenn nicht - 1. Sie können sein Verhalten ein wenig im Terminal testen. Der Rückkehrcode des letzten Befehls wird in der Variablen $? gespeichert:

Indem wir all dies kombinieren, erhalten wir ein Skript mit einem bedingten Ausdruck:

!/bin/bash
wenn [[ $1 > 2 ]]
dann
echo $1" ist größer als 2"
anders
echo $1" ist kleiner als 2 oder 2"
fi

Natürlich hat dieses Design leistungsfähigere Funktionen, aber es ist zu kompliziert, um sie in diesem Artikel zu behandeln. Vielleicht schreibe ich später darüber. Lassen Sie uns jetzt zu den Zyklen übergehen.

Schleifen in Skripten

Der Vorteil von Programmen ist, dass wir in mehreren Zeilen angeben können, welche Aktionen mehrfach ausgeführt werden müssen. Beispielsweise ist es möglich, Bash-Skripte zu schreiben, die nur aus wenigen Zeilen bestehen, aber stundenlang laufen, die Parameter parsen und die notwendigen Aktionen ausführen.

Schauen wir uns zuerst die for-Schleife an. Hier ist seine Syntax:

für Variable in Liste
tun
Team
fertig

Iteriert über die gesamte Liste und weist der Variablen nacheinander den Wert aus der Liste zu, führt nach jeder Zuweisung die Befehle aus, die sich zwischen do und done befinden.

Lassen Sie uns beispielsweise über fünf Ziffern iterieren:

für Index in 1 2 3 4 5
tun
echo $index
fertig

Oder Sie können alle Dateien im aktuellen Verzeichnis auflisten:

für Datei in $(ls -l); do echo "$file"; fertig

Wie Sie verstehen, können Sie nicht nur Namen anzeigen, sondern auch die erforderlichen Aktionen ausführen. Dies ist beim Erstellen eines Bash-Skripts sehr nützlich.

Die zweite Schleife, die wir uns ansehen werden, ist die While-Schleife, die ausgeführt wird, während der Bedingungsbefehl den Code 0, Erfolg, zurückgibt. Betrachten Sie die Syntax:

während Befehlsbedingung
tun
Team
fertig

Betrachten Sie ein Beispiel:

!/bin/bash
index=1
während [[ $index< 5 ]]
tun
echo $index
Lassen Sie "index=index+1"
fertig

Wie Sie sehen, ist alles erledigt, der Befehl let führt einfach die angegebene mathematische Operation aus, in unserem Fall erhöht er den Wert der Variablen um eins.

Ich möchte noch etwas anmerken. Konstrukte wie while, for, if sind darauf ausgelegt, in mehreren Zeilen geschrieben zu werden, und wenn Sie versuchen, sie in eine Zeile zu schreiben, erhalten Sie eine Fehlermeldung. Es ist aber trotzdem möglich, dafür dort, wo ein Zeilenumbruch stehen soll, ein Semikolon ";" zu setzen. Beispielsweise hätte die vorherige Schleife als einzelne Zeile ausgeführt werden können:

index=1; während [[ $index< 5 ]]; do echo $index; let "index=index+1"; done;

Alles ist sehr einfach, ich habe versucht, den Artikel nicht mit zusätzlichen Bash-Begriffen und -Funktionen zu komplizieren, nur die grundlegendsten. In einigen Fällen müssen Sie möglicherweise eine GUI für ein Bash-Skript erstellen, dann können Sie Programme wie zenity oder kdialog verwenden, mit denen es sehr praktisch ist, dem Benutzer Nachrichten anzuzeigen und ihn sogar um Informationen zu bitten.

Schlussfolgerungen

Jetzt verstehen Sie die Grundlagen des Skriptings unter Linux und können das Skript schreiben, das Sie zum Beispiel für ein Backup benötigen. Ich habe versucht, Bash-Skripte von Grund auf neu zu betrachten. Daher wurden nicht alle Aspekte berücksichtigt. Vielleicht kommen wir in einem der folgenden Artikel auf dieses Thema zurück.

Jeder weiß, dass die Bash-Shell über eingebaute Befehle verfügt, die nicht in den Ordnern /bin oder /usr/bin zu finden sind. Sie sind in die Shell eingebaut und werden als Funktionen ausgeführt. In einem der vorherigen Artikel haben wir darüber nachgedacht. Wir haben dort fast alles besprochen, wie Skripte aussehen sollten, die Verwendung von Bedingungen, Schleifen, Variablen, aber wir haben nicht bei Funktionen halt gemacht.

Im heutigen Artikel werden wir diesen Mangel beheben. Wie jede Programmiersprache verfügt Bash über Funktionen, deren Verwendung sehr nützlich sein kann. Wir werden uns mit der Verwendung von Bash-Funktionen befassen, wie man sie schreibt und sogar, wie man aus diesen Funktionen Bibliotheken erstellt.

Zuerst müssen wir verstehen, was eine Funktion in unserem Kontext ist. Eine Funktion ist eine Reihe von Befehlen, die unter einem Namen vereint sind und eine bestimmte Aufgabe ausführen. Die Funktion wird mit ihrem Namen aufgerufen, kann Parameter annehmen und das Ergebnis der Arbeit zurückgeben. Kurz gesagt, Bash-Funktionen funktionieren genauso wie in anderen Programmiersprachen.

Die Syntax zum Erstellen einer Funktion ist sehr einfach:

Funktionsname() ( Befehlsliste )

Der Funktionsname darf mit keinem der vorhandenen Befehle oder Funktionen übereinstimmen, und alle Befehle im Funktionsrumpf werden in eine neue Zeile geschrieben.

einfache Funktion

Schreiben wir eine kleine Funktion, die eine Zeichenfolge auf dem Bildschirm ausgibt:

$ vi-Funktion.sh

#!/bin/bash
printstr()(
Echo „Hallo Welt“
}
Druckstr

Der Aufruf einer Bash-Funktion erfolgt wie bei jedem anderen Befehl durch Angabe ihres Namens. Führen Sie unser Skript zur Ausführung aus, vergessen Sie nicht, dass Sie ihm vorher Ausführungsrechte erteilen müssen:

chmod u+x Funktion.sh

Alles funktioniert, jetzt komplizieren wir die Aufgabe, versuchen wir, Argumente an die Funktion zu übergeben.

Funktionsargumente

Funktionsargumente müssen beim Aufruf übergeben werden und werden wie Skriptargumente gelesen. Die Syntax zum Aufrufen einer Funktion mit Bash-Parametern lautet:

Funktionsname Argument1 Argument2 ... ArgumentN

Wie Sie sehen können, ist alles ganz einfach. Parameter werden durch ein Leerzeichen getrennt. Verbessern wir nun unsere Funktion so, dass sie die von uns angegebene Zeichenfolge ausgibt:

!/bin/bash
printstr()(
Echo $1
}
printstr "Hallo Welt"

Sie können mehrere Optionen haben:

!/bin/bash
printstr()(
Echo $1
Echo $2
Echo $3
echo $5
}
printstr "arg1" "arg2" "arg3" "arg4" "arg5"

Es gibt eine andere Möglichkeit, Argumente zu extrahieren, wie in C, indem man den Stack verwendet. Wir holen das erste Argument, rücken dann den Argumentstapelzeiger um eins vor und holen das erste Argument erneut. Usw:

!/bin/bash
printstr()(
Echo $1
Schicht
Echo $1
Schicht
Echo $1
Schicht
Echo $1
}
printstr "arg1" "arg2" "arg3" "arg4"

Rückgabe des Ergebnisses einer Funktion

Sie können nicht nur Funktionen mit Bash-Parametern verwenden, sondern auch das Ergebnis der Arbeit daraus erhalten. Dazu wird der Return-Befehl verwendet. Es beendet die Funktion und gibt den numerischen Wert des Rückkehrcodes zurück. Er kann zwischen 0 und 255 liegen:

!/bin/bash
printstr()(
Rückkehr 134;
}
Druckstr
Echo $?

Wenn Sie den Rückgabewert einer Bash-Funktion anstelle des Statuscodes verwenden müssen, verwenden Sie echo. Der String wird nicht sofort am Terminal ausgegeben, sondern als Ergebnis der Funktion zurückgegeben und kann in eine Variable geschrieben und dann verwendet werden:

!/bin/bash
printstr()(
echo "test"
}
VAR=$(printstr)
echo $VAR

Exportfunktionen

Sie können eine Funktion mit dem Erklärbefehl außerhalb eines Skripts verfügbar machen:

!/bin/bash
printstr()(
Echo „Hallo Welt“
}
deklarieren Sie -x -f Druckstr

Führen Sie dann das Skript mit dem Quellbefehl aus:

Quellfunktion.sh
$printstr

Rekursion

Sie können eine Funktion innerhalb von sich selbst aufrufen, um die Rekursion durchzuführen:

!/bin/bash
printstr()(
Echo „Hallo Welt“
Druckstr
}
Druckstr

Sie können mit der Rekursion experimentieren, es kann in vielen Fällen nützlich sein, denken Sie nur daran, den ersten Bash-Funktionsaufruf zu machen.

Lokale Variablen in einer Funktion

Wenn Sie eine gewöhnliche Variable in einer Funktion deklarieren, ist sie im gesamten Skript verfügbar. Dies ist praktisch, um den Wert der Funktion zurückzugeben, aber manchmal kann es erforderlich sein, sie zu einer lokalen Variablen zu machen. Dafür gibt es einen lokalen Befehl:

!/bin/bash
printstr()(
lokaler VAR=$1
echo $(var)
}
printstr "Hallo Welt"

Funktionsbibliotheken

Wir können einige Bash-Funktionen nehmen und sie in einer Bibliothek kombinieren, sodass wir diese Funktionen mit einem einzigen Befehl importieren können. Dies geschieht ähnlich wie beim Exportieren von Funktionen. Lassen Sie uns zunächst eine Bibliotheksdatei erstellen:

test1()(
echo "Hallo Welt von 1";
}
test2()(
echo "Hallo Welt von 2";
}
test3()(
echo "Hallo Welt von 3";
}

Lassen Sie uns nun ein Skript erstellen, das unsere Funktionen verwendet. Sie können die Bibliothek mit dem Quellbefehl oder einfach durch Angabe des Skriptnamens importieren:

!/bin/bash
Quelle lib.sh
test1
test2
Test3

Schlussfolgerungen

In diesem Artikel haben wir uns Bash-Funktionen angesehen, wie man sie schreibt, anwendet und in Bibliotheken kombiniert. Wenn Sie häufig Skripte in Bash schreiben, werden Ihnen diese Informationen nützlich sein. Sie können Ihre eigenen Funktionen erstellen, die Sie in jedem Skript verwenden und so Ihre Arbeit erleichtern.