{{tag>linux}}


====== Navigation/Tastenkombinationen ======

^Kombination ^Bedeutung ^
|Strg+R|Revearse-Search in der History \\ \\ <WRAP> 
* Nächsten Treffer bekommt man per Strg+R usw. 
* Esc -> Übernehme den Befehl in die Bash (ohne ausführen)
* Enter -> Übernehme Befehl und führe ihn sofort aus |
</WRAP>|
|Strg+u|Lösche Eingabe von aktueller Position bis Beginn des Prompts|
|Strg+k|Lösche Eingabe von aktueller Position bis Ende des Prompts|
|Strg+l|Lösche alle Eingaben auf dem Terminal -> entspricht clear|

====== Konstrukte ======

===== for-each-Schleife =====

  * Durchläuft die Schleife für alle Elemente eines Arrays/einer Hash-Map

**Syntax:**
<code>
for //variable// in //Array//
do
    Code;
done
</code>
\\ \\
  * Variable: Variable die den jeweils aktuellen Wert zugewiesen bekommt (damit kann man innerhalb des for-Blocks dann arbeiten) -> nicht den Index
  * Array: Das Array das durchlaufen werden soll bzw. Hashmap
\\ \\
**Beispiel:**
<code>
for myvalue in $myarray
do
       echo "${myvalue}"
done
</code>



===== for-Zählschleife =====

  * Geht nur ohne Variablen (mit festen Werten) direkt in Bash

Syntax:
<code>
for i in {x..y}; do
       code;
done
</code>

Beispiel:
for i in {1..5}; do
       Echo "Hallo"
done
</code>

Obiges Beispiel gibt 5 mal Hallo aus.

  * Mit Variablen muss man das externe "seq" benutzen

Syntax:
<code>
for i in $(seq $a $b); do
    code
done
</code>

Beispiel:
<code>
a=5
for i in $(seq 1 $a); do
    echo "Hallo"
done
</code>

Obiges Beispiel gibt 5 mal Hallo aus

===== Programme aufrufen/ Andere Scripte aurufen =====

Syntax: //Rückgabevariable//=$(//Befehl//) \\ \\

  * Rückgabevariable -> optionale Variable die alles speichert was der Befehl auf stdout ausgibt -> in der Regel das was der Befehl zurückgibt
      * Mehrere Zeilen werden hintereinander durch Leerzeichen getrennt übergeben (also nicht als mehrere Zeilen)
  * per $? kann abgefragt werden was der Rückgabewert war (nicht die Ausgaben, sondern der Return-Wert)




====== Variablen ======

====== Arrays =====

    * Können Deklariert werden
        * declare -a Arrayname
    * += Fügt einen weiteren Wert dem Array hinzu (Bla+=Test)

===== Associative Arrays/Hash-Maps =====

  * Verfügbar ab Bash-Version 4
  * Funktionieren wie Arrays, nur das der Index ein Name ist
  * Müssen deklariert werden

Beispiel: <code>a=${namen[Anna]</code> \\
Würde den Wert im Array name zurückliefern (in die Variable a), der im Feld Anna steht (zum Beipsiel den Nachnahmen von Anna).

**Deklaration:**
declare -A Hasmap-Name


* += Fügt ein weiteres Argument-Wert-Paar dem Array hinzu


===== Multidimensionale Arrays =====

  * Verfügbar ab Bash Version 4
  * Deklaration wie normale Arrays -> declare -a //Arrayname// bzw. eben gar nicht
 \\
**Zugriff**: ${//Arrayname//[Index1,Index2]} \\ \\


**Beispiel**: ${Namen[0,1]} \\ \\

**Achtung:** Gemischte multidimensionale Arrays (in denen ein Index ein String und der andere eine Zahl ist) scheinen zwar keine Fehler-Ausgaben zu produzieren, aber auch nicht zu funktionieren (beim Auslesen wird immer das ausgegeben was im ersten Feldhinterlegt ist).

====== Operatoren ======

^Operator ^Erklärung ^
|-eq|Vergleich zweier arithemtischer (numerischer) Werte auf Gleichheit \\ \\ Syntax: $a -eq $b|
|-ne|Vergleich zweier arithemtischer (numerischer) Werte auf Ungleichheit \\ \\ Syntax: $a -ne $b|
|-z|Prüfung eines Strings ob dessen Länge 0 ist (String ist leer). \\ \\ Syntax: -z "${a} \\ \\ **Achtung:**Die Variable muss in "" stehen, weil sonst die 0-Länge nicht zuverlässig ermittelt wird (wahrscheinlich wird nur geprüft ob zwischen den "" etwas steht oder nicht)|
|-n| Prüfen eines Strings auf Länge größer 0 (String hat Inhalt) \\ \\ Syntax: -n "$a" \\ \\ **Achtung:**Die Variable muss in "" stehen, weil sonst die Länge nicht unbedingt korrekt ermittelt wird.|


====== Anführungszeichen und Single-Quotes ======

  * Zeichenketten in <code>'</code> und <code>"</code> verhindern/erlauben das expandieren (Steuerbefehle und Variablennamen werden entsprechend ersetzt/interpretiert) von Variablennamen und Steuerbefehlen
      * <pre>"</pre> -> expandiert die Zeichenkette (interpretiert sie)
      * <code>'</code> -> expandiert die Zeichenkette nicht, sondern nimmt sie so wie sie da steht (literal, wörtlich)

<sxh bash>
a=5
echo "$a"
5
</sxh>

Die Zeichenkette hinter "echo" wird expandiert. "$a" wird durch den Wert der Variable (5) ersetzt. \\
Dementsprechend wird "5" ausgegeben

<sxh bash>
a=5
echo "$a"
$a
</sxh>

Die Zeichenkette hinter "echo" wird nicht expandiert/interpretiert. "$a" bleibt der String "$a und wird nicht durch den Inhalt der Variablen ersetzt \\
Dementsprechend wird "$a" ausgegeben.

===== Übergabe an andere Programme =====

Es gibt Programme die Shellkommandos übernehmen um sie dann beim eintreten bestimmter Bedingungen auszuführen. \\
Man muss aufpassen ob man die Shell-Befehlskette die man übergibt in %%"%% oder %%'%% setzt!

<sxh bash>
mycommand -c "echo $a"
</sxh>

  * da der Wert für Parameter "-c" in %%"%% angegeben wurde wird er vor! der Übergabe an mycommand ausgewertet und erhält den Wert von "a" auf der aktuellen Shell.
      * ist "a" auf der aktuellen Shell 5, bekommt mycommand "echo 5" übergeben und nicht! "echo $a"


<sxh bash>
mycommand -c 'echo $a'
</sxh>

  * da der Wert für Parameter "-c" in %%'%% angegeben wurde wird er nicht vor der Übergabe an mycommand ausgewertet
      * d.h. mycoomand bekommt "echo $a" übergeben
====== Debugging/Prüfen ======

===== Validieren =====

  * Überprüft syntaktische Korrektheit der Bash-Befehle
  * Externe Befehle (wenn andere Programme aufgerufen werden bzw. Befehle die nicht Bash-Builtin sind) werden nicht validiert
\\
Snytax: bash -n //Script//


===== Debugausgaben =====

  * Gibt aus welche Befehle ausgeführt werden und welche Variablen wie belegt wurden
\\
Syntax: bash -x //Script//


===== Debuging =====

  * ermöglicht Schritt-für-Schritt-Ausführung von Scripten


Syntax: bash --debug //Scriptname//
\\ \\
Dem Debugger muss man Befehle geben damit er was macht \\
^Befehl ^Bedeutung ^
|s|Step \\ \\ Führe den aktuellen (angezeigten) Befehl aus|
|n|Next \\ \\ Führe den aktuellen Befehl aus (wie bei s), wenn es aber eine Funktion ist mache keine Einzelausführung jedes Befehls in der Funktion, sondern führe die Funktion ohne halt aus und stoppe beim nächsten Befehl nach der Funktion|
|l|list \\ \\ Gibt den Programmcode nach der aktuellen Zeile aus -> ohne ihn auszuführen|
|b|Breakpoint \\ \\ Syntax: b //Zeilennummer// \\ \\ Setzt einen Breakpoint an der Zeile mit Nummer //Zeilennummer// (kann man sich per l ausgeben lassen). \\ Das Script wird (wenn man c eingibt) bis zu dem gesetzten Break-Point|
|c|Continue \\ \\ Führe das Script ab der aktuellen Position aus, ohne Bestätigung für jeden Schritt zu verlangen. \\ Ausführung erfolgt bis zu einem Break-Point oder das Script zu Ende ist|
|W|watchpoint \\ \\ Überwache eine bestimmte Variable und Stoppe an Stellen wo der Wert geändert wird \\ \\ Syntax: w //Variablenname// \\ \\ **Achtung:**Das geht erst nach dem die Variable das erste mal benutzt (deklariert/definiert) wurde. Bedeutet man muss erst mal bis zu einem Punkt gehen wo diese Variable genutzt wird -> erst dort kann dann w //Variablenname// genutzt werden. Von dort aus kann man dann per c (continue) automatisch weiterlaufen lassen|

====== Externe Informationen ======

^Typ ^Name ^Beschreibung ^URL ^
|Wiki|Bash-Hackers|Wiki über die Bash-Programmierung|http://wiki.bash-hackers.org|