VBA Join dans Excel — du tableau à la chaîne, l'exact inverse de Split

TL;DR — Join(sourceArray, delimiter) réduit un tableau unidimensionnel en une seule chaîne, en plaçant delimiter entre chaque élément. C'est l'exact inverse de Split : Split coupe une chaîne en tableau, Join recolle le tableau. Il remplace la boucle s = s & item & "," — et, contrairement à cette boucle, ne laisse aucun délimiteur de fin. Le hic : Join prend un tableau 1D, pas une Range et pas un tableau 2D, donc Join(Range("A1:A10").Value, ",") échoue tant que vous n'avez pas d'abord aplati la colonne en 1D.

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

    line = Join(parts, ",")          ' colle avec une virgule entre chaque
    Debug.Print line                  ' Jones,Sarah,Finance   <- pas de virgule finale

    Debug.Print Join(parts)           ' Jones Sarah Finance   <- le delimiteur par defaut est une ESPACE
    Debug.Print Join(parts, "")       ' JonesSarahFinance     <- delimiteur vide = concatener
End Sub

La signature — notez que le délimiteur est facultatif et vaut une espace par défaut, pas rien :

Join(sourceArray, [delimiter])
'    tableau 1D    defaut " " (une espace), pas ""

Ce que vous allez apprendre

Le modèle mental — Join, c'est Split à l'envers
Pourquoi Join remplace la boucle de concaténation (et tue le bug du délimiteur de fin)
Le piège numéro un : Join a besoin d'un tableau 1D, donc une Range ou un tableau 2D échoue
Le délimiteur par défaut est une espace, et chaque élément est converti en texte
L'aller-retour Split-Filter-Join qui transforme une boucle en une ligne

Le modèle mental : Join, c'est Split à l'envers

Tenez Split et Join comme une paire assortie et les deux cessent d'être capricieux. Split prend une chaîne à la structure intégrée — une ligne CSV, un nom Nom,Prénom, une ligne de log délimitée — et vous rend les champs sous forme de tableau. Join fait l'inverse : il prend ces champs et les soude de nouveau en une seule chaîne, avec un séparateur de votre choix entre eux. Si Split, c'est « désassembler », Join, c'est « assembler toute cette liste d'un coup ».

Parce qu'ils sont inverses, ils se composent proprement. Découpez une ligne, changez quelques morceaux, recollez-la avec Join :

Dim parts As Variant
parts = Split("Jones,Sarah,Finance", ",")
parts(2) = "Operations"                       ' modifier un champ
Debug.Print Join(parts, ",")                  ' Jones,Sarah,Operations

Pourquoi Join bat la boucle de concaténation

Tout le monde écrit la boucle de construction de chaîne avant de connaître Join, et tout le monde écrit le même bug :

' ATTENTION - la boucle avec le classique bug du delimiteur de fin
Dim i As Long, s As String
For i = 0 To UBound(parts)
    s = s & parts(i) & ","          ' laisse "Jones,Sarah,Finance," - virgule finale
Next i
s = Left(s, Len(s) - 1)             ' le vilain bricolage pour la couper

Ce séparateur de fin n'est pas un cas limite rare — c'est à chaque fois, et c'est pourquoi l'amputation Left(s, Len(s) - 1) est un spectacle si courant. Join n'a pas ce problème parce qu'il place le délimiteur entre les éléments par conception, jamais après le dernier :

s = Join(parts, ",")                ' Jones,Sarah,Finance - correct, du premier coup

Un seul appel, aucun caractère de fin, aucune arithmétique Len - 1, et rien à rater non plus sur un tableau vide (Join d'un tableau vide vaut simplement "").

Le piège numéro un : Join a besoin d'un tableau 1D, pas d'une Range

C'est de là que viennent la plupart des rapports « Join ne marche pas ». Join n'accepte qu'un tableau unidimensionnel. Dès l'instant où vous lui passez quelque chose de bidimensionnel, il échoue — et lire une Range multi-cellules vous donne exactement cela :

' ATTENTION - ECHEC : .Value d'une plage multi-cellules est un tableau 2D (10 lignes x 1 col)
s = Join(Range("A1:A10").Value, ",")          ' type mismatch / erreur 13

Range("A1:A10").Value n'est pas une liste — c'est un tableau variant bidimensionnel 10 x 1, et Join n'a aucune idée de quoi faire de deux dimensions. Vous devez d'abord aplatir la colonne en 1D. L'aplatissement idiomatique, c'est Application.Transpose, qui supprime la dimension unitaire d'une colonne unique :

Dim flat As Variant
flat = Application.Transpose(Range("A1:A10").Value)   ' colonne 2D -> tableau 1D
s = Join(flat, ",")                                   ' maintenant Join est content

C'est exactement pourquoi Transpose figure dans ce trio — c'est le pont des cellules vers le tableau 1D dont Join et Filter ont tous deux besoin. (Attention à sa propre limite : Application.Transpose plafonne à 65 536 éléments, alors aplatissez les colonnes très hautes avec une boucle à la place.)

Le délimiteur par défaut et la conversion en texte

Deux plus petites surprises. D'abord, si vous omettez le délimiteur, Join utilise une espace unique, pas une chaîne vide — Join(parts) donne "Jones Sarah Finance". Passez "" explicitement quand vous voulez une concaténation directe, sans rien entre les éléments.

Ensuite, Join convertit chaque élément en texte. Les nombres, dates et booléens sont convertis selon les paramètres régionaux de votre système — un Double peut s'afficher 1.5 ou 1,5 selon la machine, et une date suit le format local. S'il vous faut un format précis (un point décimal . invariant, une date ISO), formatez chaque élément avec Format ou CStr avant le Join, plutôt que de faire confiance à la locale. Un élément de tableau qui est un objet ou un variant non initialisé déclenchera une erreur au lieu d'être converti.

L'avis : ne construisez plus jamais une chaîne délimitée dans une boucle

Si vous concaténez des éléments de tableau avec & dans une boucle For, vous écrivez un bug que vous corrigerez ensuite avec Left(s, Len(s) - 1). Join existe précisément pour supprimer ce schéma. La règle est simple : dès que la source est déjà un tableau, construisez la chaîne avec Join ; dès que la source est dans des cellules, aplatissez-la d'abord en tableau 1D, puis Join — ne bouclez pas.

Et gardez la paire à l'esprit comme un pipeline. Split, Filter, Join se composent en une seule expression honnête qui se lit comme la phrase que vous diriez à voix haute — « prends cette ligne, garde les champs mentionnant 2026, et joins-les par des virgules » :

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

Split analyse, Filter extrait un sous-ensemble, Join réassemble — trois fonctions intégrées, sans boucle, sans erreur de décalage.

Comment ExcelMaster vous aide

Joindre n'est jamais le vrai but. Le but, c'est « construire la ligne d'objet de l'e-mail à partir de ces champs », ou « écrire une ligne délimitée par enregistrement dans un log ». Le temps d'aplatir la plage, de formater chaque nombre pour que les décimales survivent, et de choisir le délimiteur, la plomberie est plus longue que l'idée. ExcelMaster vous laisse décrire la sortie en langage courant — « fais une liste séparée par des points-virgules des noms de clients de chaque région » — et génère du Python qui lit les cellules, les formate de façon prévisible et sauvegarde votre fichier avant d'écrire — vous décrivez la sortie, et il gère l'aplatissement, les formats de nombres et les délimiteurs.

Foire aux questions

Que fait Join en VBA ?

Join(sourceArray, delimiter) prend un tableau unidimensionnel et renvoie une seule chaîne avec delimiter placé entre chaque élément. Join(Array("a", "b", "c"), ",") renvoie "a,b,c". C'est l'inverse de Split, et il ne laisse jamais de délimiteur de fin après le dernier élément.

Pourquoi VBA Join donne-t-il un type mismatch sur une plage ?

Parce que Range("A1:A10").Value est un tableau bidimensionnel (lignes par colonnes), et Join n'accepte qu'un tableau unidimensionnel. Aplatissez d'abord la colonne avec Application.Transpose(Range("A1:A10").Value), qui transforme un tableau 2D à colonne unique en tableau 1D, puis passez-le à Join.

Quel est le délimiteur par défaut de VBA Join ?

Une espace unique. Join(parts) sans délimiteur renvoie les éléments séparés par des espaces, pas collés ensemble. Passez une chaîne vide, Join(parts, ""), quand vous voulez une concaténation directe, sans rien entre les éléments.

Comment joindre un tableau sans virgule finale en VBA ?

Utilisez Join au lieu d'une boucle. Join(parts, ",") place la virgule seulement entre les éléments, donc il n'y a jamais de séparateur de fin à retirer. La boucle s = s & item & "," en laisse toujours un, c'est pourquoi les gens la coupent ensuite avec Left(s, Len(s) - 1) — Join supprime le besoin entièrement.

VBA Join gère-t-il les nombres et les dates ?

Oui, mais il convertit chaque élément en texte selon vos paramètres régionaux, donc les décimales et les formats de date suivent la machine locale. Pour un résultat prévisible, formatez chaque élément avec Format ou CStr avant de joindre, plutôt que de vous fier à la locale. Des objets ou des variants non initialisés dans le tableau provoquent une erreur.

Testé dans

Testé dans : Excel 365 (Windows 11), VBA 7.1 — vérifié le 03/09/2026.

Guides associés : VBA Split · VBA Filter · VBA Transpose · VBA Format · VBA For Loop