Name des Skriptes

testen, ob es schon ein Programm mit dem gewünschten Skriptnamen gibt

type mein_Skript.sh 

Ausführbar machen und aufrufen

chmod +x /pfad/zu/mein_Skript.sh 



starten
/pfad/zu/mein_Skript.sh
./mein_Skript.sh 
bash mein_Skript.sh 


Skript verfügbar machen
~/bin/
~/.profile


ls -l /usr/local/bin
sudo chown root /usr/local/bin/mein_Skript.sh
sudo chgrp root /usr/local/bin/mein_Skript.sh
sudo chmod 755 /usr/local/bin/mein_Skript.sh 


Die Shebang

Shebang:
#!/bin/bash


/bin/sh in der Shebang.


/bin/sh hingegen ist laut POSIX-Standard ein Muss.


Die Bash ist eine komplexere Shell, die nicht auf allen unixoiden Systemen zur Verfügung steht. 


Unter Ubuntu ist /bin/sh ein symbolischer Link auf die Dash. 


1.) Kommentare einfügen
2.) Variablen – Teil 1
2.1.) Variablen belegen
2.2.) Variablen lesen
2.3.) Variablen löschen
2.4.) Variablen abgrenzen
2.5.) Quoting
3.) Befehle
4.) Variablen
5.) Maskierung mit Backslashes
6.) Variablen – Teil 2
7.) Abschneiden von Mustern
8.) Umgebungsvariablen
9.) Rechnen mit der Shell
10.) Arrays
10.1.) Arrays belegen
10.2.) Arrays auslesen
10.3.) Arrays löschen
10.4.) Assoziative Arrays
11.) Interaktion mit dem Benutzer
11.1.) Ausgabe von Text
11.2.) Einlesen von Eingaben
12.) Umleitungen
13.) Das Test-Kommando
14.) Programmführung
14.1.) If-Else-Anweisung
14.2.) Case-Anweisungen
14.3.) Schleifen
15.) Parameter an ein Skript übergeben
16.) Funktionen


#!/bin/bash
#Hallo Welt Skript

echo "Hallo Welt"

11.2.) Einlesen von Eingaben


1.) Kommentare einfügen
# Dies ist ein Kommentar
2.) Variablen – Teil 1
2.1.) Variablen belegen
Im Gegensatz zu vielen anderen Programmiersprachen darf man bei der Shell keine Leerzeichen vor und nach dem Zuweisungszeichen = verwenden!
message=hallo 
message="hallo Welt" 
2.2.) Variablen lesen
echo "$message" 
2.3.) Variablen löschen
unset message
2.4.) Variablen abgrenzen
Gelegentlich kann es der Fall sein, dass man Variablen innerhalb einer Zeichenkette verwenden möchte.

echo "$message" 
echo "$messagelolo" 
echo "${message}lolo"
2.5.) Quoting
3.) Befehle 
echo Hallo, Welt 
echo "Hallo,                   Welt" 



echo * 
-> bin include lib local man sbin share src var
echo "*"
-> *

echo "Dies ist eine
> mehrzeilige Ausgabe.
> Man hält es nicht für möglich." 


4.) Variablen
foo="Hallo,     Welt"
echo "$foo"

echo $foo 

-> Hallo, Welt 


date +%A 
 Der Parameter %A zeigt den ausgeschriebene Wochentag an 
 
 
 Montag
 
 Auf einem deutschen System ist diese Ausgabe wie erwartet auf Deutsch. Man kann nun die Variable $LC_ALL
 
 
 LC_ALL=C date +%A 

Monday


5.) Maskierung mit Backslashes¶
echo \$foo 


$foo

6.) Ausgaben in eine Variable schreiben


Befehlssubstitution


#!/bin/bash
#Ausgaben in Variable schreiben

#Variablendefinition
suchwort=player

liste=$(apropos $suchwort)
echo "      Player-Liste:"
echo "$liste"


#!/bin/bash
#Ausgaben in Variable schreiben

#Variablendefinition
suchwort=player

liste=$(apropos $suchwort)
echo "      Player-Liste:"
echo "$liste"

7.) Abschneiden von Mustern¶


 Eine gewöhnungsbedürftige, aber doch sehr nette Funktion ist das Herausschneiden bestimmter Muster aus der Zeichenkette einer Variablen.
  Schnitt-Funktionen 
 Funktion 	Erklärung
${variable%muster} 	Entfernt rechts das kleinste passende Stück.
${variable%%muster} 	Entfernt rechts das größte passende Stück
${variable#muster} 	Entfernt links das kleinste passende Stück.
${variable##muster} 	Entfernt links das größte passende Stück 


pfadname="/var/www/index.html"

echo $pfadname 

/var/www/index.html

echo "Pfad: ${pfadname%/*}" 

Pfad: /var/www

echo "Dateiname: ${pfadname##*/}" 

Dateiname: index.html

8.) Umgebungsvariablen


HOME 	Enthält das Homeverzeichnis des Benutzers.
PATH 	Suchpfad für Kommandos.
PWD 	Enthält das Aktuelle Verzeichnis.
? 	Enthält den Exitstatus des letzten Kommandos 

9.) Rechnen mit der Shell

pingu@ubuntu:~$ echo $((100 / 3))
33
pingu@ubuntu:~$ x="62"
pingu@ubuntu:~$ echo $(($x + 12))
74
pingu@ubuntu:~$ ((x++))
pingu@ubuntu:~$ echo "$x"
63 

pingu@ubuntu:~$ a=$((3 + 4 * 2))
pingu@ubuntu:~$ echo "$a"
11
pingu@ubuntu:~$ b=$(((3 + 4) * 2))
pingu@ubuntu:~$ echo "$b"
14

10.) Arrays 
10.1.) Arrays belegen
 Um einen Wert in ein Array zu schreiben, ist es nötig, den Index mit anzugeben. Allgemein sieht das folgendermaßen aus:
Arrayname[i]=Wert 


Soll ein neues Array mit mehreren Werten auf einmal belegt werden, dann bietet sich folgende Schreibweise an:

Arrayname=(Dies sind vier Werte) 


Es können auch Elemente an das Ende eines Arrays angefügt werden. Das Ende ist dabei der höchste bereits existierende Index:

Arrayname+=(all diese sieben Elemente werden einzeln angefügt) 


10.2.) Arrays auslesen

echo ${array[2]} 


Wird als Index ein „@“ oder „*“ angegeben,


    ${array[*]} oder ${array[@]}: Alle Elemente mit Nachbearbeitung wie Globbing oder Word-Splitting.

    "${array[*]}": Kein Globbing, Elemente getrennt durch erstes Zeichen aus $IFS, Endergebnis ist ein Argument.

    "${array[@]}": Kein Globbing, jedes Element wird ein eigenes Argument.
    
    
    
    echo ${array[*]} 
    
    
    Hallo, Welt! bin boot dev etc home lib lost+found media mnt opt proc root run sbin srv sys tmp usr var Noch ein paar Worte und Leerzeichen.
    
10.3.) Arrays löschen



unset array 


10.4.) Assoziative Arrays


declare -A meinarray
meinarray=(
  [zwei]="Zweiter Wert"
  [drei]="Dritter Wert"
  [vier]="Vierter Wert"
)
meinarray[eins]="Ein Wert" 

echo ${meinarray[eins]} 

11.) Interaktion mit dem Benutzer
11.1.) Ausgabe von Text


#!/bin/bash
#Hallo Welt Skript

echo "Hallo Welt"

11.2.) Einlesen von Eingaben

#!/bin/bash
#Begrüßung

read -p "Geben sie ihren Namen ein:" name
echo Hallo: $name

12.) Umleitungen


Operator 	Erklärung
> 	Dient der Umleitung der Standardausgabe in eine Datei.
>> 	Dient ebenfalls der Umleitung in eine Datei, hängt jedoch die Ausgabe an eine bereits bestehende Datei an anstatt diese zu überschreiben.
| 	Mit dem Pipeoperator lässt sich die Ausgabe eines Kommandos als Eingabe für ein anderes verwenden.
< 	Statt von der Standardeingabe (Tastatur) wird aus einer Datei gelesen 



13.) Das Test-Kommando

-d Verzeichnis 	Ist wahr, wenn "Verzeichnis" existiert.
-e Datei 	Ist wahr, wenn Datei existiert.
-f Datei 	Ist wahr, wenn reguläre Datei existiert.
-w Datei 	Ist wahr, wenn die Datei existiert und Schreibzugriff erlaubt ist.
-x Datei 	Ist wahr, wenn Datei existiert und Ausführbar ist.
-n String 	Ist wahr, wenn String nicht leer ist. (Bsp. eine Variable)
-z String 	Ist wahr, wenn String leer ist. (Bsp. eine Variable)
String1 = String2 	Ist wahr, wenn String1 gleich String2 ist.
Zahl1 -eq Zahl2 	Ist wahr, wenn Zahl1 gleich Zahl2 ist. (-eq = equal)
Zahl1 -lt Zahl2 	Ist wahr, wenn Zahl1 kleiner Zahl2 ist. (-lt = less than)
Zahl1 -gt Zahl2 	Ist wahr, wenn Zahl1 größer Zahl2 ist. (-gt = greater than)
Zahl1 -le Zahl2 	Ist wahr, wenn Zahl1 kleiner oder gleich Zahl2 ist. (-le = less or equal)
Zahl1 -ge Zahl2 	Ist wahr, wenn Zahl1 größer oder gleich Zahl2 ist. (-ge = greater or equal)
Zahl1 -ne Zahl2 	Ist wahr, wenn Zahl1 nicht gleich Zahl2 ist. (-ne = not equal)
! foo 	Ist wahr, wenn foo falsch ist, also eine Negation.


14.) Programmführung
14.1.) If-Else-Anweisung


if [ Test-Bedingung ]
  then
    Befehl...
fi

if [ Test-Bedingung ]
  then
    echo "Ok, alles in Ordnung."
  else
    echo "Ahrg...Fehler."
fi



if [ Test-Bedingung ]
  then
    Befehl...
  elif [ Test-Bedingung ]
    then
      Befehl...
  else
    Befehl...
fi


#!/bin/bash 
echo "Wie ist Ihr Name?"
read ANTWORT
if [ "$ANTWORT" == "root" ]
    then
        echo "Hallo, Administrator."
    else
        echo "Hallo, Anwender."
fi


Ein Beispiel zeigt, wie man auf die Existenz einer Datei hin prüft und entsprechend dem Ergebnisse eine Meldung dazu ausgibt.

#!/bin/bash
#Dateitest

if [ -f /home/Pingu/test.txt ]
  then
    echo "Die Datei test.txt in Pingus Home ist da."
  else
    echo "Die Datei test.txt in Pingus Home fehlt."
fi

Oder das ganze wird mit einer elif-Konstruktion erweitert.


#!/bin/bash
# Dateitest

if [ -f /home/Pingu/test.txt ]
then
    echo "Die Datei test.txt in Pingus Home ist da."
elif [ -d /home/Pingu/test.txt ]
    then
      echo "test.txt ist ein Verzeichnis"
else
    echo "Die Datei test.txt in Pingus Home fehlt"
fi


14.2.) Case-Anweisungen



#!/bin/bash
dat="$1"
# Schneide vor Dateiendung ab:
ext=${dat/*./}

case $ext in
        pdf)
            xpdf "$dat"
            ;;
        sh)
            shellcheck "$dat"
            ;;
        png|jpg|gif)
            eog "$dat"
            ;;
        wav|mp3)
            aplay "$dat"
            ;;
        *)
            echo Unbekanntes Dateiformat"!"
            ;;
esac


14.3.) Schleifen

    for-Schleife

    while-Schleife

    until-Schleife
    
    
    
    
    params="a b c"
for z in $params
do
    echo $z
done 




#!/bin/bash
# for-schleife
for wort in Hallo "du Welt" "da draußen"
do
    echo "$wort"
done




#!/bin/bash

# Variablendefinition
inputdir="/home/foo/Bilder/ZuBearbeiten"
outputdir="/home/foo/Bilder/Bearbeitet"

# Abarbeiten der eingelesenen Bilder mit Hilfe einer For-Schleife
# und dem Programm ImageMagick.

for pic in "$inputdir"/*.png 
do 
    picname=$(basename "$pic")
    echo "Bearbeite Bild:    $picname"
    convert "$pic" -colorspace Gray "$outputdir/$picname"
done




for wert in "${array[@]}"
do
    Befehl...
done


for ((Anfangswert;Bedingung;Operation))
do
    Befehl1
    Befehl2
    # usw.
done




for ((z=2004;z<=2014;z++))
do
     mkdir Archiv_"$z"
done




while [ Test-Bedingung ]
do
    Befehl1
    Befehl2
    # usw.
done




#!/bin/bash
# Warten auf das richtige Ergebnis.

echo "F
rage: Was ergibt 2 + 2"
echo ""
while ((answer != 4)) 
do
    read -p "Bitte ihre Eingabe:" answer
    case "$answer" in
      4) echo richtig
          ;;
      *) echo falsch
          ;;
    esac
done


Eine while-Schleife eignet sich auch besonders gut, um ohne Interaktion Datendateien abzuarbeiten. Hierzu ein weiteres Beispiel:

#!/bin/bash
# Liste aus einer .csv-Datei verarbeiten
while read stapel
do
    readarray -td\; zeile <<<"$stapel"
echo "
Vorname: ${zeile[0]}
Name: ${zeile[1]}
Funktion: ${zeile[2]}"
done < liste.csv; echo


15.) Parameter an ein Skript übergeben

#!/bin/bash
# willkommen
if [ $1 == "Pingu" ]
then
    echo "Hallo, kleiner Pingu!"
else
    echo "Hallo, $1"
fi


Die Variable $# gibt die Anzahl der verwendeten Parameter aus. So kann man prüfen, ob das Skript sinnvoll verwendet wird:


#!/bin/bash
# Willkommen
if [ $# -ne 1 ]
then
    echo; echo "Verwendung: $0 Name"; echo
elif [ $1 == "Pingu" ]
  then
    echo "Hallo, kleiner Pingu!"
else
    echo "Hallo, $1"
fi


16.) Funktionen


funktionsname(){
    Befehle...
}



#!/bin/bash

PFAD="/home/pingu/"

# Funktionsdefinitionen
wievieledateien() {
	anzahl=0
	for file in "$PFAD"/* ; do 
		(( anzahl++ ))
	done
	echo "Es befinden sich $anzahl Dateien und Ordner in $PFAD"
}


./zaehledateien 



#!/bin/bash

wievieledateien() {
	zaehlpfad="$1"
	for file in "$zaehlpfad"/* ; do 
		(( anzahl++ ))
	done
	echo "Es befinden sich $anzahl Dateien und Ordner in $zaehlpfad"
}
wievieledateien /home/pingu
wievieledateien /home/edit