VBA Join in Excel — Array zurück zu einem String, die exakte Umkehrung von Split

TL;DR — Join(sourceArray, delimiter) fasst ein eindimensionales Array zu einem String zusammen und setzt delimiter zwischen jedes Element. Es ist die exakte Umkehrung von Split: Split zerschneidet einen String zu einem Array, Join klebt das Array zurück. Es ersetzt die Schleife s = s & item & "," — und lässt, anders als jene Schleife, kein Trennzeichen am Ende. Der Haken: Join nimmt ein 1-D-Array, keinen Range und kein 2-D-Array, also schlägt Join(Range("A1:A10").Value, ",") fehl, bis Sie die Spalte zuerst auf 1-D flach machen.

Sub JoinDemo()
    Dim parts As Variant, line As String
    parts = Array("Jones", "Sarah", "Finance")

    line = Join(parts, ",")          ' mit einem Komma zwischen den Elementen verkleben
    Debug.Print line                  ' Jones,Sarah,Finance   <- kein Komma am Ende

    Debug.Print Join(parts)           ' Jones Sarah Finance   <- Standardtrennzeichen ist ein LEERZEICHEN
    Debug.Print Join(parts, "")       ' JonesSarahFinance     <- leeres Trennzeichen = verketten
End Sub

Die Signatur — beachten Sie, dass das Trennzeichen optional ist und standardmäßig ein Leerzeichen ist, nicht nichts:

Join(sourceArray, [delimiter])
'    1-D-Array     Standard ist " " (ein Leerzeichen), nicht ""

Was Sie lernen

Das mentale Modell — Join ist Split rückwärts gelaufen
Warum Join die Verkettungsschleife ersetzt (und den Trailing-Trennzeichen-Bug tötet)
Die Falle Nummer eins: Join braucht ein 1-D-Array, also scheitert ein Range oder 2-D-Array
Der Trennzeichen-Standard ist ein Leerzeichen, und jedes Element wird in Text umgewandelt
Der Split-Filter-Join-Rundlauf, der aus einer Schleife eine Zeile macht

Das mentale Modell: Join ist Split, rückwärts

Halten Sie Split und Join als passendes Paar, und beide hören auf, fummelig zu sein. Split nimmt einen String mit eingebackener Struktur — eine CSV-Zeile, einen Last,First-Namen, eine getrennte Logzeile — und reicht Ihnen die Felder als Array. Join tut das Gegenteil: Es nimmt jene Felder und schweißt sie mit einem Trenner Ihrer Wahl dazwischen wieder zu einem String zusammen. Ist Split das „Ent-Verketten", ist Join das „diese ganze Liste auf einmal verketten".

Weil sie Umkehrungen sind, komponieren sie sauber. Zerlegen Sie eine Zeile, ändern Sie einige Stücke, fügen Sie sie mit Join zurück:

Dim parts As Variant
parts = Split("Jones,Sarah,Finance", ",")
parts(2) = "Operations"                       ' ein Feld aendern
Debug.Print Join(parts, ",")                  ' Jones,Sarah,Operations

Warum Join die Verkettungsschleife schlägt

Jeder schreibt die stringbauende Schleife, bevor er von Join weiß, und jeder schreibt denselben Bug:

' ACHTUNG: die Schleife mit dem klassischen Trailing-Trennzeichen-Bug
Dim i As Long, s As String
For i = 0 To UBound(parts)
    s = s & parts(i) & ","          ' hinterlaesst "Jones,Sarah,Finance," - Komma am Ende
Next i
s = Left(s, Len(s) - 1)             ' der haessliche Trick, um es abzuschneiden

Jenes abschließende Trennzeichen ist kein seltener Randfall — es ist jedes Mal, weshalb die Amputation Left(s, Len(s) - 1) so ein häufiger Anblick ist. Join hat dieses Problem nicht, weil es das Trennzeichen von Bauart zwischen die Elemente setzt, nie nach dem letzten:

s = Join(parts, ",")                ' Jones,Sarah,Finance - korrekt, gleich beim ersten Mal

Ein Aufruf, kein abschließendes Zeichen, keine Len - 1-Rechnerei, und auch bei einem leeren Array nichts falsch zu machen (Join eines leeren Arrays ist einfach "").

Die Falle Nummer eins: Join braucht ein 1-D-Array, keinen Range

Daher kommen die meisten „Join funktioniert nicht"-Meldungen. Join akzeptiert nur ein eindimensionales Array. In dem Moment, in dem Sie ihm etwas Zweidimensionales reichen, scheitert es — und das Lesen eines Mehrzellenbereichs gibt Ihnen genau das:

' SCHLAEGT FEHL - .Value eines Mehrzellenbereichs ist ein 2-D-Array (10 Zeilen x 1 Spalte)
s = Join(Range("A1:A10").Value, ",")          ' Typkonflikt / Fehler 13

Range("A1:A10").Value ist keine Liste — es ist ein 10 x 1 zweidimensionales Variant-Array, und Join hat keine Ahnung, was es mit zwei Dimensionen anfangen soll. Sie müssen die Spalte zuerst auf 1-D flach machen. Der idiomatische Flatten ist Application.Transpose, der die Singleton-Dimension einer einzelnen Spalte fallen lässt:

Dim flat As Variant
flat = Application.Transpose(Range("A1:A10").Value)   ' 2-D-Spalte -> 1-D-Array
s = Join(flat, ",")                                   ' jetzt ist Join zufrieden

Genau deshalb sitzt Transpose in diesem Cluster — es ist die Brücke von Zellen zu dem 1-D-Array, das Join und Filter beide verlangen. (Achten Sie auf sein eigenes Limit: Application.Transpose deckelt bei 65.536 Elementen, machen Sie sehr hohe Spalten also stattdessen mit einer Schleife flach.)

Der Trennzeichen-Standard und die Textumwandlung

Zwei kleinere Überraschungen. Erstens: Lassen Sie das Trennzeichen weg, nutzt Join ein einzelnes Leerzeichen, keinen leeren String — Join(parts) ergibt "Jones Sarah Finance". Übergeben Sie "" ausdrücklich, wenn Sie eine schlichte Verkettung mit nichts dazwischen wollen.

Zweitens: Join wandelt jedes Element in Text um. Zahlen, Daten und Booleans werden über die Regionaleinstellungen Ihres Systems umgewandelt — ein Double kann je nach Maschine als 1.5 oder 1,5 erscheinen, und ein Datum folgt dem lokalen Format. Brauchen Sie ein bestimmtes Format (ein invariantes .-Dezimalzeichen, ein ISO-Datum), formatieren Sie jedes Element mit Format oder CStr, bevor Sie Join aufrufen, statt der Locale zu vertrauen. Ein Array-Element, das ein Objekt oder eine nicht initialisierte Variant ist, wirft einen Fehler, statt sich umwandeln zu lassen.

Die Meinung: nie wieder einen getrennten String in einer Schleife bauen

Wenn Sie Array-Elemente mit & innerhalb einer For-Schleife verketten, schreiben Sie einen Bug, den Sie dann mit Left(s, Len(s) - 1) flicken. Join existiert genau dazu, dieses Muster zu löschen. Die Regel ist einfach: Ist die Quelle schon ein Array, bauen Sie den String mit Join; steckt die Quelle in Zellen, machen Sie sie zuerst auf ein 1-D-Array flach, dann Join — schleifen Sie nicht.

Und behalten Sie das Paar als Pipeline im Kopf. Split, Filter, Join komponieren zu einem ehrlichen Ausdruck, der sich liest wie der Satz, den Sie laut sagen würden — „nimm diese Zeile, behalte die Felder mit 2026, und füge sie mit Kommas zusammen":

result = Join(Filter(Split(line, ","), "2026"), ", ")

Split zerlegt, Filter grenzt ein, Join fügt zusammen — drei eingebaute Funktionen, keine Schleife, kein Off-by-One.

Wie ExcelMaster hilft

Zusammenfügen ist nie das eigentliche Ziel. Das Ziel ist „bau die E-Mail-Betreffzeile aus diesen Feldern" oder „schreib eine getrennte Zeile pro Datensatz in ein Log." Bis Sie den Bereich flach gemacht, jede Zahl formatiert haben, damit die Dezimalstellen überleben, und das Trennzeichen gewählt haben, ist die Verkabelung länger als die Idee. ExcelMaster lässt Sie die Ausgabe in normaler Sprache beschreiben — „mach eine semikolongetrennte Liste der Kundennamen je Region" — und erzeugt Python, das die Zellen liest, sie vorhersehbar formatiert und Ihre Datei vor dem Schreiben sichert — Sie beschreiben die Ausgabe, und es kümmert sich um das Flachmachen, die Zahlenformate und die Trennzeichen.

Häufig gestellte Fragen

Was macht Join in VBA?

Join(sourceArray, delimiter) nimmt ein eindimensionales Array und liefert einen einzigen String, mit delimiter zwischen jedem Element. Join(Array("a", "b", "c"), ",") liefert "a,b,c". Es ist die Umkehrung von Split, und es lässt nie ein Trennzeichen nach dem letzten Element.

Warum gibt VBA Join bei einem Range einen Typkonflikt?

Weil Range("A1:A10").Value ein zweidimensionales Array (Zeilen mal Spalten) ist und Join nur ein eindimensionales Array akzeptiert. Machen Sie die Spalte zuerst mit Application.Transpose(Range("A1:A10").Value) flach, was ein einspaltiges 2-D-Array in ein 1-D-Array verwandelt, und übergeben Sie das an Join.

Was ist das Standardtrennzeichen in VBA Join?

Ein einzelnes Leerzeichen. Join(parts) ohne Trennzeichen liefert die Elemente durch Leerzeichen getrennt, nicht aneinandergeklebt. Übergeben Sie einen leeren String, Join(parts, ""), wenn Sie eine schlichte Verkettung mit nichts zwischen den Elementen wollen.

Wie füge ich in VBA ein Array ohne abschließendes Komma zusammen?

Nutzen Sie Join statt einer Schleife. Join(parts, ",") setzt das Komma nur zwischen die Elemente, also gibt es nie ein abschließendes Trennzeichen zu entfernen. Die Schleife s = s & item & "," lässt immer eines übrig, weshalb Leute es dann mit Left(s, Len(s) - 1) abschneiden — Join macht das ganz überflüssig.

Kann VBA Join mit Zahlen und Daten umgehen?

Ja, aber es wandelt jedes Element über Ihre Regionaleinstellungen in Text um, also folgen Dezimal- und Datumsformate der lokalen Maschine. Für ein vorhersehbares Ergebnis formatieren Sie jedes Element mit Format oder CStr vor dem Zusammenfügen, statt sich auf die Locale zu verlassen. Objekte oder nicht initialisierte Variants im Array verursachen einen Fehler.

Getestet in

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

Verwandte Anleitungen: VBA Split · VBA Filter · VBA Transpose · VBA Format · VBA For Loop