VBA Concatenate dans Excel — & contre + et le piège Null qui casse vos chaînes

TL;DR — VBA vous offre deux opérateurs qui semblent tous deux joindre du texte : & et +. Un seul est sûr. & traite toujours les deux côtés comme du texte — il transforme les nombres en leurs chiffres et traite Null comme une chaîne vide. + fait de l'arithmétique dès qu'il voit des nombres et devient contagieux dès qu'il voit Null (un seul Null rend tout le résultat Null). Règle sans exception : utilisez & pour construire des chaînes, gardez + pour les calculs. Et quand vous collez des milliers de morceaux dans une boucle, arrêtez d'utiliser s = s & x — c'est du O(n²). Utilisez plutôt Join sur un tableau.

La concaténation est l'opération la plus courante que vous réalisez avec du texte en VBA : construire un nom de fichier, un message, une chaîne SQL, un titre de rapport. Cela paraît trivial — jusqu'à ce qu'un nombre ou une cellule vide transforme votre "Total: " + value en un nombre erroné ou en un Null silencieux, et le bug part en production parce que rien n'a déclenché d'erreur.

Ce que vous allez apprendre

• Pourquoi & est le seul opérateur de concaténation digne de confiance (et ce que + fait vraiment)
• Le piège Null qui pousse + à annuler une expression entière
• Pourquoi s = s & item dans une boucle est secrètement en O(n²) — et la solution Join
• L'habitude d'espacement qui évite le bug du & interprété comme caractère de type

Le modèle mental : & est de la colle à texte, + vous trahit

Imaginez & comme un tube de colle étiqueté « texte uniquement ». Quoi que vous lui donniez — une chaîne, un nombre, une date, voire un vide — il le convertit en texte et le colle à la suite. + est un tube d'apparence identique, mais étiqueté « arithmétique d'abord ». Quand les deux côtés sont des chaînes, il colle. Dès qu'un côté est un nombre ou un Null, il cesse d'être de la colle et fait de l'arithmétique — et vous ne le découvrez qu'une fois la sortie erronée.

Sub TwoOperators()
    ' & concatène toujours comme du texte
    Debug.Print "Item " & 5          ' -> "Item 5"   (nombre converti en texte)
    Debug.Print "5" & "5"            ' -> "55"        (collé)

    ' + fait de l'arithmétique dès qu'un nombre est en jeu
    Debug.Print "5" + "5"            ' -> "55"  ... mais seulement parce que les deux sont du TEXTE
    Debug.Print 5 + 5               ' -> 10    (arithmétique)
    Debug.Print "Item " + 5         ' -> run-time error 13: Type mismatch
End Sub

Cette dernière ligne est révélatrice : "Item " + 5 plante parce que + tente d'ajouter un nombre à une chaîne. & n'a jamais ce problème — "Item " & 5 fonctionne tout simplement.

La règle qui évite le pire bug de concaténation : le piège Null

Voici le mode de défaillance qui corrompt réellement les données. Lorsque vous lisez une valeur depuis un recordset de base de données, un variant vide ou une cellule renvoyée comme Null, les deux opérateurs se comportent de manière opposée :

Sub TheNullTrap()
    Dim middleName As Variant
    middleName = Null                       ' p. ex. un champ vide venant d'ADO

    ' & traite Null comme une chaîne vide — sûr
    Debug.Print "Anna " & middleName & " Smith"   ' -> "Anna  Smith"

    ' + est contagieux : UN SEUL Null empoisonne toute l'expression
    Debug.Print "Anna " + middleName + " Smith"   ' -> Null  (tout a disparu)
End Sub

Avec +, un seul Null n'importe où dans la chaîne rend le résultat entier Null. Si vous écrivez ensuite cela dans une cellule, vous obtenez un vide là où devrait figurer un nom — sans aucune erreur pour vous dire pourquoi. C'est la raison numéro un des rapports de bug du type « ma concaténation produit aléatoirement des cellules vides ». La solution n'est pas de vérifier chaque valeur pour Null. La solution est de ne jamais utiliser + pour construire une chaîne. Réservez + aux cas où vous voulez réellement la propagation de Null comme signal — ce qui, en pratique, n'arrive presque jamais.

L'habitude d'espacement : & est aussi un caractère de déclaration de type

Un détail subtil qui piège ceux qui écrivent du code compact. En VBA, & accolé à un nom de variable est l'ancien suffixe de déclaration de type pour Long (comme $ pour String). Donc si vous collez & contre un nom sans espace, l'analyseur peut le lire comme un caractère de type plutôt que comme l'opérateur de concaténation :

    total = count&"x"      ' ambigu — la VBE peut mal interpréter count& comme un Long
    total = count & "x"    ' sans ambiguïté — toujours une concaténation

Mettez toujours des espaces autour de &. Ce n'est pas cosmétique : cela élimine une vraie ambiguïté d'analyse et rend les longues concaténations lisibles. Utilisez vbNewLine, vbCrLf et vbTab comme constantes entre les morceaux plutôt que de coder en dur Chr(10) :

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

Pourquoi votre concaténation est lente : la boucle en O(n²)

Voici le jugement de performance qui distingue une macro terminée en un clin d'œil d'une macro qui se fige pendant 30 secondes. Les chaînes VBA sont immuables — chaque s = s & item alloue une chaîne toute neuve et recopie tout ce qui précédait. Faites-le 10 000 fois dans une boucle et vous avez recopié la chaîne grandissante 10 000 fois : du O(n²) classique.

' LENT — reconstruit toute la chaîne à chaque itération (O(n²))
Dim s As String, i As Long
For i = 1 To 10000
    s = s & data(i) & ","
Next i

' RAPIDE — on collecte dans un tableau, on colle une seule fois avec Join (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, ",")          ' une seule allocation

Join est l'inverse de Split : il prend un tableau et un délimiteur, et renvoie une seule chaîne en une seule allocation. Pour tout ce qui dépasse quelques centaines d'itérations, construire un tableau et appeler Join une fois est radicalement plus rapide — et plus lisible — que d'accumuler avec &.

Le bon jugement : pour une poignée de morceaux, & est parfait et Join serait excessif. Pour une boucle qui construit une grande chaîne, sortez Join à chaque fois.

Concaténer une plage de cellules

Une demande très fréquente : coller une colonne de cellules en une seule chaîne délimitée. Évitez de boucler cellule par cellule si vous le pouvez — le TEXTJOIN natif d'Excel (disponible via WorksheetFunction) le fait en un seul appel et ignore les vides pour vous :

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

Si vous avez vraiment besoin d'une boucle VBA (ancien Excel sans TEXTJOIN), lisez d'abord la plage dans un tableau de variants, construisez un tableau de String, puis faites un Join — ne touchez jamais 50 fois à la feuille de calcul à l'intérieur de la boucle.

Comment ExcelMaster aide

Beaucoup de code VBA de concaténation existe pour assembler une seule chose : un export propre — une ligne CSV, une étiquette formatée, une clé de rapprochement. ExcelMaster les construit à partir d'une description en langage courant : « crée une colonne clé à partir de l'ID client plus la date de commande, séparés par des virgules » — et il gère les vides, les types et les délimiteurs sans que vous ayez à raisonner sur & contre + ou sur la propagation de Null.

Vous écrirez encore du VBA quand la concaténation vit au sein d'une macro permanente. Mais pour les tâches ponctuelles du type « assemble ces colonnes en un export », décrire la sortie est plus rapide que d'aligner correctement les opérateurs à la main.

Questions fréquentes

Quelle est la différence entre & et + en VBA ?

& concatène toujours comme du texte — il convertit les nombres en leurs chiffres et traite Null comme une chaîne vide. + fait de l'arithmétique dès qu'un nombre est en jeu et propage Null (un seul Null rend toute l'expression Null). Utilisez & pour construire des chaînes et + uniquement pour les calculs.

Comment ajouter un saut de ligne dans une chaîne concaténée ?

Insérez la constante vbNewLine (ou vbCrLf) entre les morceaux : "Line 1" & vbNewLine & "Line 2". Pour une tabulation, utilisez vbTab. Elles sont plus lisibles et plus portables que coder en dur Chr(13) et Chr(10).

Pourquoi ma concaténation de chaînes VBA est-elle si lente ?

Vous accumulez presque certainement avec s = s & x dans une grande boucle, ce qui est du O(n²) parce que VBA reconstruit toute la chaîne à chaque fois. Collectez les morceaux dans un tableau de String et appelez Join(parts, delimiter) une seule fois.

Comment concaténer une plage de cellules en VBA ?

Utilisez WorksheetFunction.TextJoin(delimiter, ignore_empty, range) pour une solution en une ligne qui ignore aussi les vides. Ne retombez sur une boucle que sur les anciennes versions d'Excel dépourvues de TEXTJOIN, et même alors, lisez la plage dans un tableau et faites un Join plutôt que de boucler sur les cellules.

Testé dans

Testé dans : Excel 365 (Windows 11), VBA 7.1 — dernière vérification le 14/06/2026.

Guides associés : VBA UCase & LCase · VBA Str · VBA Split · VBA CStr · VBA For Loop