VBA Concatenate in Excel — & vs. + und die Null-Falle, die Ihre Strings zerstört

TL;DR — VBA bietet Ihnen zwei Operatoren, die beide so aussehen, als würden sie Text verbinden: & und +. Nur einer ist sicher. & behandelt beide Seiten immer als Text — Zahlen werden zu ihren Ziffern, und Null gilt als leerer String. + rechnet, sobald es Zahlen sieht, und wird ansteckend, sobald es Null sieht (ein einziges Null macht das ganze Ergebnis Null). Eine Regel ohne Ausnahme: Nehmen Sie & zum Aufbauen von Strings und behalten Sie + für die Mathematik. Und wenn Sie in einer Schleife Tausende von Teilstücken zusammenfügen, hören Sie auf mit s = s & x — das ist O(n²). Nutzen Sie stattdessen Join auf einem Array.

Verkettung ist das, was Sie in VBA am häufigsten mit Text tun: einen Dateinamen bauen, eine Meldung, einen SQL-String, einen Berichtstitel. Es wirkt trivial — bis eine Zahl oder eine leere Zelle Ihr "Total: " + value entweder in eine falsche Zahl oder ein stilles Null verwandelt, und der Fehler geht in Produktion, weil nichts einen Error geworfen hat.

Was Sie lernen

• Warum & der einzige Verkettungsoperator ist, dem Sie trauen sollten (und was + wirklich tut)
• Die Null-Falle, die + einen ganzen Ausdruck auf null setzen lässt
• Warum s = s & item in einer Schleife heimlich O(n²) ist — und die Join-Lösung
• Die Leerzeichen-Gewohnheit, die den &-als-Typkennzeichen-Bug verhindert

Das mentale Modell: & ist Textkleber, + ist ein Verräter

Stellen Sie sich & als Klebetube mit der Aufschrift „nur für Text" vor. Was immer Sie ihr geben — einen String, eine Zahl, ein Datum, sogar einen leeren Wert — sie wandelt es in Text um und klebt es hinten an. + ist eine identisch aussehende Tube, aber sie trägt die Aufschrift „zuerst rechnen". Wenn beide Seiten zufällig Strings sind, klebt sie. In dem Moment, in dem eine Seite eine Zahl oder ein Null ist, hört sie auf, Kleber zu sein, und rechnet — und Sie merken es erst, wenn die Ausgabe falsch ist.

Sub TwoOperators()
    ' & verkettet immer als Text
    Debug.Print "Item " & 5          ' -> "Item 5"   (Zahl wird zu Text umgewandelt)
    Debug.Print "5" & "5"            ' -> "55"        (zusammengeklebt)

    ' + rechnet in dem Moment, in dem eine Zahl im Spiel ist
    Debug.Print "5" + "5"            ' -> "55"  ... aber nur, weil beide TEXT sind
    Debug.Print 5 + 5               ' -> 10    (Arithmetik)
    Debug.Print "Item " + 5         ' -> run-time error 13: Type mismatch
End Sub

Die letzte Zeile ist der verräterische Hinweis: "Item " + 5 fliegt auf, weil + versucht, eine Zahl zu einem String zu addieren. & hat dieses Problem nie — "Item " & 5 funktioniert einfach.

Die Regel, die den schlimmsten Verkettungsfehler verhindert: die Null-Falle

Hier ist der Fehlermodus, der tatsächlich Daten beschädigt. Wenn Sie einen Wert aus einem Datenbank-Recordset, einer leeren Variant oder einer Zelle lesen, die als Null zurückkam, verhalten sich die beiden Operatoren entgegengesetzt:

Sub TheNullTrap()
    Dim middleName As Variant
    middleName = Null                       ' z. B. ein leeres Feld aus ADO

    ' & behandelt Null als leeren String — sicher
    Debug.Print "Anna " & middleName & " Smith"   ' -> "Anna  Smith"

    ' + ist ansteckend: EIN Null vergiftet den gesamten Ausdruck
    Debug.Print "Anna " + middleName + " Smith"   ' -> Null  (alles weg)
End Sub

Bei + macht ein einziges Null irgendwo in der Kette das gesamte Ergebnis Null. Wenn Sie das dann in eine Zelle schreiben, erhalten Sie eine Leerstelle, wo ein Name stehen sollte — und keinen Fehler, der Ihnen verrät, warum. Das ist der häufigste Grund für Bug-Meldungen wie „meine Verkettung erzeugt zufällig leere Zellen". Die Lösung besteht nicht darin, jeden Wert auf Null zu prüfen. Die Lösung ist, niemals + zum Aufbauen eines Strings zu verwenden. Behalten Sie + für Fälle, in denen Sie die Null-Propagierung tatsächlich als Signal wollen — was in der Praxis fast nie der Fall ist.

Die Leerzeichen-Gewohnheit: & ist auch ein Typ-Deklarationszeichen

Ein subtiler Fall, der Leute trifft, die kompakten Code schreiben. In VBA ist &, an einen Variablennamen angehängt, das alte Typ-Deklarationssuffix für Long (so wie $ für String). Wenn Sie also & ohne Leerzeichen direkt an einen Namen quetschen, kann der Parser es als Typzeichen statt als Verkettungsoperator lesen:

    total = count&"x"      ' mehrdeutig — der VBE könnte count& als Long missdeuten
    total = count & "x"    ' eindeutig — immer Verkettung

Setzen Sie immer Leerzeichen um &. Das ist nicht kosmetisch; es beseitigt eine echte Parsing-Mehrdeutigkeit und macht lange Verkettungen lesbar. Verwenden Sie vbNewLine, vbCrLf und vbTab als Konstanten zwischen den Teilstücken, anstatt Chr(10) hart zu codieren:

    msg = "Line one" & vbNewLine & "Line two" & vbTab & "(indented)"

Warum Ihre Verkettung langsam ist: die O(n²)-Schleife

Das ist die Performance-Entscheidung, die ein Makro, das im Bruchteil einer Sekunde fertig ist, von einem unterscheidet, das 30 Sekunden lang hängt. VBA-Strings sind unveränderlich — jedes s = s & item allokiert einen brandneuen String und kopiert alles, was vorher da war. Tun Sie das 10.000 Mal in einer Schleife, haben Sie den wachsenden String 10.000 Mal kopiert: klassisches O(n²).

' LANGSAM — baut den ganzen String in jeder Iteration neu auf (O(n²))
Dim s As String, i As Long
For i = 1 To 10000
    s = s & data(i) & ","
Next i

' SCHNELL — in einem Array sammeln, einmal mit Join zusammenfügen (O(n))
Dim parts() As String
ReDim parts(1 To 10000)
For i = 1 To 10000
    parts(i) = data(i)
Next i
s = Join(parts, ",")          ' eine einzige Allokation

Join ist das Gegenstück zu Split: Es nimmt ein Array und ein Trennzeichen und gibt in einer einzigen Allokation einen String zurück. Für alles jenseits von ein paar Hundert Iterationen ist es dramatisch schneller — und besser lesbar —, ein Array aufzubauen und einmal Join aufzurufen, als mit & zu akkumulieren.

Die Abwägung: Für eine Handvoll Teilstücke ist & perfekt, und Join wäre übertrieben. Für eine Schleife, die einen großen String aufbaut, greifen Sie jedes Mal zu Join.

Einen Zellbereich verketten

Eine sehr häufige Anforderung: eine Spalte von Zellen zu einem einzelnen, getrennten String zusammenfügen. Schleifen Sie nicht Zelle für Zelle durch, wenn Sie es vermeiden können — Excels eigenes TEXTJOIN (verfügbar über WorksheetFunction) erledigt das in einem einzigen Aufruf und überspringt Leerstellen für Sie:

Sub JoinAColumn()
    Dim result As String
    ' TEXTJOIN(delimiter, ignore_empty, range)
    result = WorksheetFunction.TextJoin(", ", True, Range("A1:A50"))
    Debug.Print result
End Sub

Falls Sie wirklich eine VBA-Schleife brauchen (ältere Excel-Versionen ohne TEXTJOIN), lesen Sie den Bereich zuerst in ein Variant-Array ein, bauen Sie ein String-Array auf und nutzen Sie Join — fassen Sie das Arbeitsblatt niemals 50 Mal innerhalb der Schleife an.

Wie ExcelMaster hilft

Ein Großteil des Verkettungs-VBA existiert, um eine einzige Sache zusammenzubauen: einen sauberen Export — eine CSV-Zeile, ein formatiertes Etikett, einen Schlüssel zum Abgleichen. ExcelMaster baut diese aus einer Beschreibung in einfachem Deutsch: „Erstelle eine Schlüsselspalte aus Kunden-ID plus Bestelldatum, kommagetrennt" — und kümmert sich um die Leerstellen, die Typen und die Trennzeichen, ohne dass Sie über & vs. + oder Null-Propagierung nachdenken müssen.

Sie werden weiterhin VBA schreiben, wenn die Verkettung in einem dauerhaft laufenden Makro steckt. Aber für einmalige „Füge diese Spalten zu einem Export zusammen"-Aufgaben ist es schneller, die Ausgabe zu beschreiben, als die Operatoren von Hand richtig hinzubekommen.

Häufig gestellte Fragen

Was ist der Unterschied zwischen & und + in VBA?

& verkettet immer als Text — es wandelt Zahlen in ihre Ziffern um und behandelt Null als leeren String. + rechnet, sobald eine Zahl im Spiel ist, und propagiert Null (ein Null macht den ganzen Ausdruck Null). Nehmen Sie & zum Aufbauen von Strings und + nur für die Mathematik.

Wie füge ich einen Zeilenumbruch in einen verketteten String ein?

Fügen Sie die Konstante vbNewLine (oder vbCrLf) zwischen die Teilstücke ein: "Line 1" & vbNewLine & "Line 2". Für einen Tabulator nehmen Sie vbTab. Diese sind besser lesbar und portabler als hart codierte Chr(13) und Chr(10).

Warum ist meine VBA-String-Verkettung so langsam?

Mit ziemlicher Sicherheit akkumulieren Sie mit s = s & x innerhalb einer großen Schleife, was O(n²) ist, weil VBA den ganzen String jedes Mal neu aufbaut. Sammeln Sie die Teilstücke in einem String-Array und rufen Sie einmal Join(parts, delimiter) auf.

Wie verkette ich einen Zellbereich in VBA?

Nutzen Sie WorksheetFunction.TextJoin(delimiter, ignore_empty, range) für eine einzeilige Lösung, die zudem Leerstellen überspringt. Greifen Sie nur bei älteren Excel-Versionen ohne TEXTJOIN auf eine Schleife zurück, und lesen Sie selbst dann den Bereich in ein Array ein und nutzen Sie Join, statt über die Zellen zu schleifen.

Getestet in

Getestet in: Excel 365 (Windows 11), VBA 7.1 — zuletzt geprüft am 14.06.2026.

Verwandte Anleitungen: VBA UCase & LCase · VBA Str · VBA Split · VBA CStr · VBA For Loop