Arithmetik

(( )) — Arithmetic Compound Command

Das Arithmetic Compound Command ist die moderne, saubere Variante in Bash. Innerhalb der doppelten Klammern wird der Inhalt als arithmetischer Ausdruck ausgewertet, Variablen brauchen kein $, und das Quoting fällt weitgehend weg.

(( a = 5 + 3 ))
echo "$a"

8

Der Rückgabewert von (( )) ist kein Zahlenwert, sondern ein Exit-Code — und der ist umgekehrt zur intuitiven Erwartung: Ist das Resultat des Ausdrucks ungleich Null, gilt der Befehl als erfolgreich (Exit 0). Ist das Resultat Null, gilt er als fehlgeschlagen (Exit 1). Damit lässt sich (( )) direkt als Bedingung verwenden:

if (( a > 10 )); then
    echo "groß"
fi

Variablen werden innerhalb von (( )) automatisch dereferenziert — (( a = b + c )) reicht, das $ ist optional und stört eher. Das macht den Code lesbar und vermeidet die typischen Quoting-Fehler.

$(( )) — Arithmetic Expansion

Wenn du den Wert eines Ausdrucks brauchst — etwa zum Zuweisen, Ausgeben oder als Argument — verwendest du die Arithmetic Expansion $(( )). Sie ersetzt den Ausdruck durch sein numerisches Resultat, ähnlich wie $(...) für Command-Substitution.

result=$(( 5 + 3 ))
echo "$result"

a=4
b=7
echo "$(( a * b ))"

8
28

Die Faustregel ist einfach: (( )) für Anweisungen (Zuweisung, Bedingung, Counter), $(( )) für Ausdrücke, deren Wert weiterverwendet wird. Beide sind Bash-Builtins, beide sind schnell — keine Subshell, kein externer Prozess.

let

let ist ein älterer Bash-Builtin mit demselben Zweck wie (( )). Funktional identisch, aber mit zwei Nachteilen: Argumente mit Leerzeichen müssen gequotet werden, und * wird je nach Aufruf vom Glob-Mechanismus angefasst.

let "a = 5 + 3"
let a=5+3
let "c = a * b"

Empfehlung: (( )) bevorzugen. Es liest sich besser, braucht keine Anführungszeichen für Leerzeichen und ist in jedem moderneren Bash-Code der Standard. let siehst du höchstens noch in alten Skripten.

expr

expr ist kein Builtin, sondern ein externer Befehl aus den Coreutils. Jeder Aufruf forkt eine Subshell und lädt das Programm — entsprechend langsam ist das in Schleifen. Außerdem ist die Syntax sperrig: Operatoren und Operanden müssen durch Leerzeichen getrennt werden, und Sonderzeichen wie * brauchen Backslash-Escape gegen die Shell.

expr 5 + 3
expr 4 \* 7
result=$(expr 10 / 3)
echo "$result"

8
28
3

Heute ist expr praktisch obsolet. Sinnvoll bleibt es nur in POSIX-Skripten ohne Bash (#!/bin/sh), wo (( )) und $(( )) nicht garantiert sind — wobei selbst POSIX $(( )) schon lange unterstützt.

Operatoren

In (( )) und $(( )) stehen alle aus C bekannten Operatoren zur Verfügung — inklusive Bit-Operationen, Compound-Zuweisungen und Ternär.

Beispiele für die wichtigsten Compound-Operatoren:

x=10
(( x += 5 ))
echo "$x"

(( x *= 2 ))
echo "$x"

(( max = x > 50 ? x : 50 ))
echo "$max"

15
30
50

Bash kennt kein Float

Eine harte Wahrheit: Bash rechnet ausschließlich mit Integer. Jede Division ist eine Ganzzahl-Division, alles hinter dem Komma fällt weg.

echo "$(( 1 / 2 ))"
echo "$(( 7 / 3 ))"
echo "$(( 10 / 4 ))"

0
2
2

Wer Float braucht, ruft ein externes Werkzeug — meistens bc mit der Option -l (lädt die Math-Library und setzt scale), awk mit BEGIN-Block oder Python.

echo "scale=2; 1/2" | bc
bc -l <<< "scale=4; 22/7"

.50
3.1428

awk 'BEGIN { printf "%.4f\n", 22/7 }'

3.1429

python3 -c "print(1/3)"

0.3333333333333333

Welches Tool? bc ist die klassische Wahl, in jeder Distro verfügbar. awk ist meist schon da, weil es ohnehin für Textverarbeitung gebraucht wird. python3 ist in Skripten praktisch, wenn ohnehin Python-Logik beteiligt ist — sonst Overkill.

Praxis-Patterns

Ein paar konkrete Muster, die in echten Skripten immer wieder auftauchen.

Counter inkrementieren — der Klassiker in Schleifen. i++ ist Post-Inkrement, gibt also den alten Wert zurück und erhöht danach. Innerhalb von (( )) reicht das ohne weitere Verpackung.

i=0
for f in *.log; do
    (( i++ ))
done
echo "$i Dateien"

Bedingungs-Counter — eine Bedingung als Zahl direkt in eine Summe einrechnen. Vergleiche liefern in (( )) 0 oder 1, und += addiert das einfach drauf.

found=0
for n in 3 7 12 4 9; do
    (( found += n > 5 ))
done
echo "$found Werte über 5"

Bit-Flags setzen — eine Maske mit OR-Zuweisung in eine Flag-Variable schreiben. Klassisch für Permission-Bits, Feature-Flags oder Hardware-Register.

READ=1
WRITE=2
EXEC=4

flags=0
(( flags |= READ ))
(( flags |= EXEC ))
echo "$flags"

Float-Division mit bc — Hier-String an bc schicken. scale=2 bestimmt die Nachkomma-Stellen, -l aktiviert die Math-Library. Praktisch für Prozent-Berechnungen oder Mittelwerte.

ergebnis=$(bc -l <<< "scale=2; 5/3")
echo "$ergebnis"

1.66

Mittelwert mit awk — Werte als Variablen an awk übergeben (-v), im BEGIN-Block die Rechnung ausführen. Vorteil: keine Pipe, kein Parsing, klare Trennung von Bash-Variablen und awk-Logik.

sum=42
n=7
awk -v s="$sum" -v n="$n" 'BEGIN { print s/n }'

6

Basis-Konvertierung — In (( )) lassen sich Literale in beliebiger Basis schreiben: BASIS#WERT. Das macht Hex-, Oktal- oder Binär-Werte in Skripten lesbar.

(( h = 16#FF ))
echo "$h"

(( o = 8#777 ))
echo "$o"

(( b = 2#1010 ))
echo "$b"

255
511
10

Weiterführende Ressourcen

Externe Quellen

• Bash-Manpage: ARITHMETIC EVALUATION — Offizielle Spezifikation aller Operatoren und Auswertungsregeln
• GNU Bash-Handbuch: Shell Arithmetic — Vollständige Referenz mit Beispielen
• bc(1) Manpage — Arbitrary Precision Calculator, Math-Library und Skript-Modus
• awk(1) Manpage — POSIX-awk inklusive numerischer Funktionen
• BashFAQ: How can I do floating point arithmetic? — Praxis-orientierte Sammlung aller Float-Workarounds

Verwandte Artikel

• Bedingungen — if, [[ ]] und numerische Vergleiche
• Schleifen — for, while und C-style-Schleifen mit (( ))
• Funktionen — Rückgabewerte, Parameter und lokale Variablen
• Exit-Codes — Was Exit-Codes bedeuten und warum (( )) invertiert ist
• Skript-Grundlagen — Shebang, robuster Header und set -euo pipefail