Strings in Bash verketten: Anleitung mit Codebeispielen

Kurz gesagt.

Setze zwei Variablen oder Literale direkt nebeneinander, um sie in Bash zu verketten.
Nutze den Operator +=, wenn du einen String schrittweise aufbaust.
printf steuert Abstände und Zeilenumbrüche präzise.
Heredoc verarbeitet mehrzeilige Strings ohne aufwendiges Escaping.
Die meisten Fehler entstehen durch Anführungszeichen, Leerzeichen oder nicht gesetzte Variablen.

Strings in Bash zu verbinden, wirkt beim ersten Mal ungewöhnlich, denn einen +-Operator gibt es nicht. Du setzt Variablen einfach nebeneinander. Diese Anleitung zeigt dir die wichtigsten Methoden, typische Probleme und die passenden Einsatzbereiche.

Was ist Bash-Scripting?

Beim Bash-Scripting schreibst du kleine Programme für die Bash-Shell. Es gehört zu den gängigsten Formen des Shell-Scriptings unter Linux und eignet sich für Automatisierung, Serververwaltung, Deployments und verbindenden Code zwischen Tools. Bash-Skripte sind einfache Textdateien, die die Shell von oben nach unten liest und Zeile für Zeile als Befehl ausführt.

Auf den meisten Linux-Servern ist Bash standardmäßig installiert. Deshalb erledigst du viele Aufgaben mit Bash-Shell-Skripten besonders schnell: Du schreibst eine .sh-Datei, machst sie ausführbar und startest sie. Weder Compiler noch Build-Schritt sind nötig. Das passt gut zu Aufgaben, bei denen die Stringverarbeitung nur einen Teil eines größeren Ablaufs bildet.

Wann sich Bash für Stringoperationen eignet

Nutze Bash-Skripte, wenn die Strings kurz und die Abläufe einfach sind und das Skript nur vorhandene Systemwerkzeuge verwenden soll. Bash-Variablen und Stringoperationen sind schnell genug, um Konfigurationen zu erzeugen, Logs auszuwerten, Dateinamen zu bilden und kurze Abläufe zu automatisieren.

Für aufwendige Textverarbeitung ist eine andere Sprache meist übersichtlicher. Willst du dagegen nur einige Bash-Variablen zu einem Pfad oder einer Meldung verbinden, ist Bash kaum zu schlagen.

Was bedeutet Stringverkettung unter Linux?

Bei der Stringverkettung verbindest du zwei oder mehr Strings zu einem einzigen String. Ein Bash-String ist eine Zeichenfolge, die in einer Variablen gespeichert oder als Literal angegeben wird. Zum Verketten setzt du die Strings ohne Operator direkt nebeneinander.

first="hello"
second="world"
full="$first $second"
echo "$full"   # hello world

Auf diesem Grundprinzip beruhen fast alle folgenden Methoden.

Methode 1: Variablen aneinanderreihen

Die einfachste Methode ist die direkte Aneinanderreihung: Setze die Bash-Variablen in einer neuen Variablen oder einem String in Anführungszeichen direkt nebeneinander.

name="Ada"
greeting="Hello, $name!"
echo "$greeting"   # Hello, Ada!

Du brauchst weder Operator noch Funktion, sondern nur die richtige Reihenfolge und passende Anführungszeichen.

Literale Strings verketten

Literale Strings verkettest du genauso: Schreibe sie in ein gemeinsames Paar Anführungszeichen oder setze zwei in Anführungszeichen stehende Stringteile direkt nebeneinander.

path="/var""/log"   # /var/log
message="user: ""$USER"

Die zweite Form ist praktisch, wenn du die Teile optisch getrennt halten und trotzdem verbinden möchtest.

Variablennamen mit geschweiften Klammern abgrenzen

Steht neben einer Bash-Variablen Text, der wie ein Teil ihres Namens aussieht, schließe sie in ${} ein. So verhinderst du, dass Bash den String falsch interpretiert.

file="report"
name="${file}_2026.txt"   # report_2026.txt

Ohne die Klammern würde $file_2026 wie eine neue Variable aussehen. Geschweifte Klammern verhindern damit einen der häufigsten Bash-Fehler.

Methode 2: Der Verkettungsoperator +=

Mit dem Operator += hängst du Text in Bash bequem an einen String an. Er erweitert eine Variable direkt, sodass du ihren bisherigen Inhalt nicht erneut schreiben musst. Diese Form der Stringverkettung ist gut lesbar und schnell.

log="Started"
log+=" at $(date)"
echo "$log"
# Output: Started at Mon May 11 17:20:00 CEST 2026

Jedes += hängt Text an den vorhandenen Wert an. Du musst den Variablennamen rechts nicht wiederholen und kannst in langen Strings kein Dollarzeichen vergessen.

Strings in Schleifen schrittweise aufbauen

+= eignet sich besonders für Schleifen. Der Operator funktioniert auch mit Bash-Arrays, wenn du Elemente sammeln und am Ende zu einem String verbinden möchtest. In Schleifen sieht das Muster so aus:

result=""
for item in one two three; do
result+="$item,"
done
echo "${result%,}"   # one,two,three

Bei listenartigen Daten ist es oft übersichtlicher, ein Bash-Array zu verwenden und es anschließend mit IFS zu verbinden. IFS steht für Internal Field Separator und legt fest, wie Bash Felder trennt und verbindet.

parts=(one two three)
IFS=','; joined="${parts[*]}"; unset IFS
echo "$joined"   # one,two,three

Methode 3: Strings mit printf verketten

printf eignet sich, wenn du die Formatierung genau steuern möchtest. Der Befehl verhält sich eindeutiger als echo und kommt deshalb häufig bei Logausgaben oder Daten für andere Tools zum Einsatz. Auch Bash-Strings lassen sich damit übersichtlich verbinden.

first="api"
second="contabo"
third="com"
url=$(printf "%s.%s.%s" "$first" "$second" "$third")
echo "$url"   # api.contabo.com

Der Formatstring bestimmt den Aufbau und jedes %s übernimmt ein Argument. So vermeidest du unerwartete Effekte durch Anführungszeichen oder falsche Abstände.

Methode 4: Here-Strings und Heredoc verwenden

Bei mehrzeiligen Strings werden Anführungszeichen schnell unübersichtlich. Dafür bietet Bash Heredoc: Du schreibst einen mehrzeiligen Bash-String zwischen zwei Markierungen und weist ihn einer Variablen zu, ohne jedes Anführungszeichen zu maskieren. Verwende Heredoc, wenn du sonst mehrere +=-Zeilen oder aufeinanderfolgende echo-Befehle bräuchtest, etwa für Konfigurationsdateien, E-Mail-Vorlagen oder mehrzeilige Logmeldungen.

message=$(cat <<EOF
Hello, $USER.
Your server is ready.
EOF
)
echo "$message"
# Output:
# Hello, yourname.
# Your server is ready.

Variablen werden innerhalb des Blocks ausgewertet. Wenn du den Text unverändert und ohne Auswertung übernehmen möchtest, setze die öffnende Markierung wie bei <<'EOF' in Anführungszeichen. So unterscheidest du zwischen einer Vorlage mit eingesetzten Werten und einem Literalblock, der exakt deine Eingabe ausgibt.

Dasselbe Muster ohne Variablenauswertung eignet sich beispielsweise für einen Konfigurationsausschnitt mit wörtlichen Dollarzeichen:

config=$(cat <<'EOF'
host=$SERVER_HOST
port=$SERVER_PORT
EOF
)
echo "$config"
# Output:
# host=$SERVER_HOST
# port=$SERVER_PORT

Here-Strings sind die kompaktere Variante. Sie übergeben einen einzelnen Bash-String an einen Befehl:

grep "error" <<< "$log"

Beide Muster halten die Verarbeitung mehrzeiliger Bash-Strings gut lesbar.

Methoden zur Stringverarbeitung in Bash

Die Verkettung ist nur ein Teil der Stringverarbeitung in Bash. Für vorhandene Strings bietet Bash Operatoren zum Ausschneiden und Ersetzen von Teilen sowie zum Prüfen der Länge. Zusammen mit echo oder printf kannst du fast jede Ausgabe formen, ohne externe Tools aufzurufen.

Teilstrings extrahieren und ersetzen

Für Teilstrings nutzt Bash ${var:offset:length}, für Ersetzungen ${var/old/new}. Beide Ausdrücke arbeiten direkt mit Bash-Variablen, sodass du weder sed noch awk brauchst.

text="hello world"
echo "${text:0:5}"          # hello
echo "${text/world/bash}"   # hello bash

Die Syntax ist kurz, schnell und direkt in Bash integriert.

Mehrzeilige Strings erweitern

Du kannst einen mehrzeiligen Bash-String erweitern, indem du mit += und einem vorangestellten Zeilenumbruch weitere Zeilen anhängst. Alternativ schreibst du einen zweiten Bash-Heredoc und verbindest beide Blöcke.

block=$(cat <<EOF
Line 1
Line 2
EOF
)
block+=$'\nLine 3'
echo "$block"

Die Syntax $'\n' fügt einen echten Zeilenumbruch ein. Das ist sicherer, als ihn innerhalb doppelter Anführungszeichen einzubetten.

Häufige Fehler bei Bash-Strings und ihre Lösungen

Die meisten Stringfehler in Bash-Skripten folgen wenigen bekannten Mustern. Wenn du auf diese Punkte achtest, vermeidest du einen Großteil der typischen Bash-Fehler.

Variablen mit Leerzeichen nicht in Anführungszeichen setzen: cp $file /tmp schlägt fehl, wenn $file Leerzeichen enthält. Verwende cp "$file" /tmp.
Geschweifte Klammern neben Text vergessen: "$name_log" sucht nach einer Variablen namens name_log. Schreibe "${name}_log".
Einfache Anführungszeichen trotz gewünschter Auswertung verwenden: 'Hello $name' wird wörtlich ausgegeben. Nutze zur Interpolation doppelte Anführungszeichen.
Leere Variablen erzeugen unbemerkt leere Strings: Mit set -u erkennst du nicht gesetzte Variablen frühzeitig.
Arrays und Strings unbedacht mischen: ${arr[*]} und ${arr[@]} verhalten sich innerhalb von Anführungszeichen unterschiedlich.

Viele dieser Punkte wirken wie kleine Stilfragen, können aber echte Skripte zum Scheitern bringen.

FAQ: Strings in Bash verketten

Wie verkette ich Strings in Bash?

Am einfachsten verkettest du Strings in Bash, indem du Variablen und Literale innerhalb doppelter Anführungszeichen direkt nebeneinandersetzt, zum Beispiel full="$first $second". Dafür brauchst du in den meisten Fällen keine zusätzlichen Operatoren.

Wie hänge ich Text an eine Stringvariable in Bash an?

Verwende den Operator +=, um Text an einen Bash-String anzuhängen. Die Verkettung sieht beispielsweise so aus: log+=" more text". Dabei wird die vorhandene Variable direkt erweitert, ohne ihren Inhalt erneut zu schreiben.

Was bewirkt += in einem Bash-Skript?

In Bash-Skripten hängt += den rechten Wert an die vorhandene Bash-Variable auf der linken Seite an. Bei Strings ergänzt der Operator den neuen Text am Ende. Bei Ganzzahlen, die mit declare -i deklariert wurden, führt er stattdessen eine Addition aus.

Wie verbinde ich Strings in Bash über mehrere Zeilen?

Erstelle mit einem Bash-Heredoc einen mehrzeiligen Bash-String und weise ihn mit $(cat <<EOF ... EOF) einer Variablen zu. Bash-Heredoc-Blöcke werten Variablen standardmäßig aus, sodass sich Werte über viele Zeilen gut lesbar verbinden lassen.