Ausdrücke expression


Ausdrücke können in verschiedenen Formen vorliegen.
- arithmetische Ausdrücke
- Vergleichsausdrücke

arithmetische Ausdrücke

Die bash verwendet bei der Berechnung von arithmetischen Ausdrücken den grössten
auf dem System verfügbaren Intergertyp. Es wird nicht auf Overflow geprüft.
Expression werden verwendet :
  • als Tabellenindex [Subscript]
  • für jedes Argument von let " .. "
  • innerhalb von (( ..... )) ist in der Wirkung identisch mit let " ... "
  • als shiftcount in shift shift b-2
  • als Operanden in arithmetischen Vergleichen bei test [ ] [[ ]]
  • als resource limit in ulimit Ein expression kann eine Konstante oder eine Variable oder ein Ausdruck sein, der mit arithmetischen Operatoren verbunden wird.

    arithmetischen Ausdruck evaluieren

    
    Für die Berechnung eines arithmetischen Ausdrucks kann in der bash gearbeitet werden
    mit:
    
  • let expression let ist ein Build-in Command
  • $[ expression ] veraltete alternative Form
  • (( expression )) alternative Form zu let
  • `expr arg ` diese Form ist aus Kompatibilitätsgründen mit der Bourne-Shell vorhanden und in der bash und ksh enthalten
  • let

    Das Build-in-Command let berechnet einen oder mehrere arithmetische Ausdrücke.
    let arg [...]
    
    
  • die ksh evaluiert jedes arg als einen separaten Ausdruck
  • werden innerhalb des Ausdruck Tabs oder Blanks verwendet, so muß er in "Quotes" eingeschlossen werden.
  • Returnwert 0 (TRUE) wenn letztes Ergebnis ungleich Null 1 (FALSE) wenn letztes Ergebnis gleich Null
  • runde Klammern innerhalb des Ausdruckes legen die Auswertungsfolge fest. Sie erzeugen keine Subshell.
  •  detlef@caro:~/scripts$ cat let_1
    #!/bin/bash
    let x=4   a=x*3
    echo "x=$x     a=$a"
    
    let " b  = x * 2 "     "y = (a + 9) / 2"
    echo "$b    $y"
    
    detlef@caro:~/scripts$ ./let_1
    x=4     a=12
    8    10
    detlef@caro:~/scripts$
    

    (( expression ))

    Es gibt mehrere Schreibweisen für Berechnungen, die Anweisung wird entweder in
    eckige Klammern oder in doppelte runde Klammern eingeschlossen. Zudem wird ein
    Dollar vorangestellt.
    Beide Schreibweisen sind im nächsten Beispiel zu sehen:
    
    detlef@caro:~/scripts$ cat arithm_1
    #!/bin/bash
    wert=20
    wert=$[$wert+1]     # 21  die form $[ausdruck] ist deprecated (veraltet)
    		    # und wird in kommenden bash-Versionen nicht mehr
                        # unterstützt werden.
    
    wert=$(($wert+1))   # 22
    echo "Wert=$wert"   # Ausgabe 22
    : $[wert+=1]        # 23
    : $((wert+=1))      # 24
    echo "Wert=$wert"   # Ausgabe 24
    echo $((wert+=1))   # Die Form wird häufig in Verbindung mit echo verwendet
    		    # um in der Ausgabeanweisung zu rechnen.
                        # Achtung: dabei tritt ein Seiteneffekt auf!
    		    # wert wird dabei erhöht gespeichert
    echo "Wert=$wert"
    detlef@caro:~/scripts$ ./arithm_1
    Wert=22
    Wert=24
    25
    Wert=25
    detlef@caro:~/scripts$
    
    
    Insgesamt machen alle Rechenanweisungen das gleiche, sie erhöhen den Inhalt von Wert um eins. Zeile eins und zwei sind noch recht leicht zu durchschauen, hier wird wie üblich zunächst der Ausdruck rechts vom Gleichzeichen ausgewertet und dann der Variablen zugewiesen. Zeile drei und vier arbeiten vom Prinzip her gleich, denn die Operation "a+=b" ist definiert als "a=$a+b" -- intern wandelt BASH die Kurzschreibweise um --. Ungewöhnlich ist hier der Doppelpunkt vor der Rechenanweisung. Er ist eine Null-Funktion, ein Befehl, der nichts tut. Die BASH wertet die Parameter dahinter genauso wie beim Aufruf jeden anderen Befehls aus, berechnet somit das Ergebnis. Notwendig ist der Doppelpunkt, weil die Rechenoperationen stets durch das Ergebnis, nämlich $wert, ersetzt werden -- ohne den Doppelpunkt wäre dies für BASH ein Befehl -- der aufgerufen würde. Häufg wird die Form echo $(( ausdruck )) verwendet, um in der Ausgabeanweisung zu rechnen. Das Build-in-Command (( ... )) berechnet einen arithmetischen Ausdruck. Es benötigt auch kein $ bei den Variablennamen. Im Gegensatz zu let müssen Blanks und Tabs nicht durch Quotes eingeschlossen sein und auch der : (das null-Command entfällt) * die ksh evaluiert (( ... )) als einen separaten Ausdruck * Returnwert 0 (TRUE) wenn letztes Ergebnis ungleich Null 1 (FALSE) wenn letztes Ergebnis gleich Null * runde Klammern innerhalb des Ausdruckes legen die Auswertungsfolge fest. Sie erzeugen keine Subshell.
    ((x = 4 ))
    ((a=x*3))
    ((y = (a + 9) / 2 ))           # wie in der Mathematik gilt :
                                   # Punktrechnung vor Strichrechnung
                                   # Klammern regeln/erzwingen andere
                                   # Auswertungsfolgen
    
    Es wird empfohlen mit dieser Form (( ausdruck )) zu rechnen.
    

    arithmetische Operatoren

    Ein Ausdruck verbindet expression über Operatoren.
    Die Operatoren haben eine Rangfolge (precedence). Sie legt fest die
    Reihenfolge der Auswertung fest. Bei  gleicher precedence erfolgt die
    Auswertung von von links nach rechts.
    Ausnahme = hier wird von rechts nach links vorgegangen.
    Die folgende Übersicht zeigt die Operatoren in absteigender precedence.
    Operatoren mit gleicher precedence werden unter einem * Punkt zusammengefasst.
    
    
  • (expr) # Klammer legt die Reihenfolge fest
  • -expr # Vorzeichen Minus
  • !expr # Logische Negation ~expr # Bitweise Negation
  • expr * expr # Multiplikation expr / expr # Division expr % expr # Divisionsrest exp1 durch exp2
  • expr + expr # Addition expr - expr # Subtraktion
  • expr << expr # Linksshift exp1 um exp2 Bits nach links expr >> expr # Rechtsshift exp1 um exp2 Bits nach rechts
  • expr <= expr # Vergleich exp1 kleiner oder gleich exp2 expr >= expr # Vergleich exp1 größer oder gleich exp2 expr < expr # Vergleich exp1 kleiner als exp2 expr > expr # Vergleich exp1 größer als exp2
  • expr == expr # Vergleich exp1 kleiner oder gleich exp2 expr != expr # Vergleich exp1 ungleich exp2
  • expr & expr # Bitweise Verknüpfung exp1 AND exp2
  • expr ^ expr # Bitweise Verknüpfung exp1 exlc OR exp2
  • expr | expr # Bitweise Verknüpfung exp1 OR exp2
  • expr && expr # Logical AND wenn der erste expr false ist, # wird der zweite expr nicht mehr evaluiert
  • expr || expr # Logical OR wenn der erste expr true ist, # wird der zweite expr nicht mehr evaluiert
  • expr = expr # Zuweisung
  • expr op= expr # compound Zuweisung, # op ist einer der Operatoren * / % + - << >> & ^ |