VBA Like dans Excel — correspondance par caractères génériques et le piège de la chaîne entière

TL;DR — text Like pattern renvoie un Boolean : la chaîne entière correspond-elle au motif à caractères génériques ? Les jokers sont * (toute suite de caractères), ? (exactement un caractère), # (exactement un chiffre), [abc] (un caractère d'un ensemble) et [!abc] (un caractère hors de l'ensemble). Deux choses mordent : Like teste la chaîne entière, donc chercher une sous-chaîne exige "*abc*", pas "abc" ; et sa sensibilité à la casse se règle à l'échelle du module par Option Compare, sans indicateur par appel comme en possède InStr.

Sub LikeBasics()
    Debug.Print "Excel"   Like "Ex*"        ' True  - commence par "Ex"
    Debug.Print "Excel"   Like "*x*"        ' True  - contient un "x"
    Debug.Print "Excel"   Like "?????"      ' True  - exactement cinq caracteres
    Debug.Print "A-1234"  Like "[A-Z]-####" ' True  - lettre, tiret, quatre chiffres
    Debug.Print "cat"     Like "[!0-9]*"    ' True  - ne commence pas par un chiffre

    Debug.Print "Excel"   Like "x"          ' False - Like teste la chaine ENTIERE
    Debug.Print "Excel"   Like "excel"      ' False - sensible a la casse par defaut
End Sub

Ce que vous allez apprendre

• Le modèle mental — Like est un test de forme, pas une recherche
• Chacun des cinq jokers et exactement ce qu'il capture
• Pourquoi Like teste la chaîne entière, si bien qu'un test de sous-chaîne exige des * autour
• Pourquoi la sensibilité à la casse est un interrupteur Option Compare à l'échelle du module, pas un indicateur par appel
• Comment reconnaître un *, ?, # ou [ littéral avec l'échappement par crochets
• Like contre InStr contre les jokers de feuille, et lequel saisir

Le modèle mental : Like est un test de forme, pas une recherche

Like ne cherche pas à l'intérieur de votre chaîne. Il pose le motif sur la chaîne d'un bout à l'autre et pose une seule question par oui ou non : cette chaîne entière a-t-elle cette forme ? C'est un autre travail que InStr, qui cherche une sous-chaîne et signale où elle se trouve, et qu'une expression régulière, qui sait trouver, compter et extraire des morceaux. Like ne renvoie rien d'autre que True ou False.

Ce cadrage vous dit quand il convient : vous avez une forme fixe et vous voulez un verdict. Est-ce un SKU valide ("[A-Z][A-Z]-####") ? Ce nom de fichier finit-il en .xlsx ("*.xlsx") ? Ce code ne contient-il que des chiffres (Not (s Like "*[!0-9]*")) ? Chacune est une question de forme, et Like y répond en une ligne lisible — aucun objet à créer, aucune boucle, aucune arithmétique de position.

Les jokers, et ce que chacun capture

Cinq jetons spéciaux, et tout le reste du motif est un littéral qui doit apparaître à l'identique :

Les plages entre crochets vont du bas vers le haut ([A-Z], [0-9]), et vous pouvez combiner les ensembles ([A-Za-z0-9]). Le joker # est une commodité VBA sans équivalent dans les jokers de feuille, et la négation [!...] est l'outil derrière l'essentiel de la vraie validation — "*[!0-9]*" signifie « contient au moins un caractère non chiffre quelque part », que vous niez pour affirmer « chiffres seuls ».

Piège 1 : Like teste la chaîne entière, pas une sous-chaîne

C'est la question numéro un « Like ne correspond pas », et elle vient de l'attente d'un comportement de recherche :

Debug.Print "Invoice 2026" Like "2026"     ' False - la chaine n'est pas JUSTE "2026"
Debug.Print "Invoice 2026" Like "*2026*"   ' True  - contient "2026" n'importe ou
Debug.Print "Invoice 2026" Like "Invoice*" ' True  - commence par "Invoice"

Le motif doit décrire la chaîne du premier caractère au dernier. Si vous voulez seulement qu'un fragment apparaisse quelque part, entourez-le de * des deux côtés. Si vous voulez vraiment savoir « ceci contient-il ce texte littéral », InStr est l'outil plus direct — InStr(s, "2026") > 0 — et il est plus rapide car il n'y a aucun motif à interpréter. Réservez Like aux cas où la forme compte (ancrée au début, un chiffre ici, une lettre là), pas la simple présence d'une sous-chaîne.

Piège 2 : la casse dépend d'Option Compare, sans dérogation par appel

Par défaut, un module utilise Option Compare Binary, donc Like est sensible à la casse :

Debug.Print "Excel" Like "excel"   ' False sous Option Compare Binary (le defaut)

Placez Option Compare Text tout en haut du module (au-dessus de chaque procédure) et chaque comparaison de chaînes de ce module — =, Like, InStr sans argument explicite — devient insensible à la casse :

Option Compare Text          ' a l'echelle du module, tout en haut

Sub CaseInsensitive()
    Debug.Print "Excel" Like "excel"   ' True desormais
End Sub

Voici la différence tranchée avec ses cousines : Like n'a aucun indicateur de casse par appel. InStr et Filter prennent tous deux vbTextCompare en argument, si bien que vous pouvez ignorer la casse pour un appel et rester sensible à la casse partout ailleurs. Like ne le peut pas — son comportement de casse est une propriété du module entier. S'il vous faut une correspondance insensible à la casse à un seul endroit sans basculer le module, repliez la casse vous-même avec UCase : UCase(s) Like "EXCEL". Cela garde l'effet local et évident, au lieu de le cacher dans une ligne Option cent lignes plus loin.

Piège 3 : reconnaître un astérisque, un point d'interrogation ou un crochet littéral

Tôt ou tard, vous devez reconnaître un vrai * ou ? — un nom de fichier contenant un joker, une zone de recherche qui contient littéralement #. Échappez un caractère spécial en le mettant entre crochets :

Debug.Print "3*4"  Like "*[*]*"   ' True  - contient un asterisque litteral
Debug.Print "OK?"  Like "*[?]"    ' True  - finit par un point d'interrogation litteral
Debug.Print "C#"   Like "*[#]"    ' True  - diese litteral (pas "un chiffre")
Debug.Print "a[1]" Like "*[[]*"   ' True  - crochet ouvrant litteral

Notez que ce n'est pas la convention des feuilles. Range.Find, Application.Match et COUNTIF échappent un joker avec un tilde de tête (~*, ~?), et ne comprennent ni # ni [!liste]. Deux dialectes de jokers différents vivent dans le même produit, et les confondre — utiliser ~* dans un motif Like, ou [*] dans un Find — est une source subtile et silencieuse de correspondances qui ne se déclenchent jamais.

Like contre InStr contre les jokers de feuille

La décision en une ligne, pour cesser de saisir le mauvais outil :

• InStr — vous voulez savoir si et où une sous-chaîne littérale apparaît. Le plus rapide pour « contient ce texte exact ».
• Like — vous voulez un oui/non sur une forme : ancrée, positionnelle, chiffre contre lettre, un ensemble borné. Un seul Boolean, chaîne entière.
• Range.Find / jokers de feuille — vous comparez à des cellules d'une feuille, et le dialecte est *, ?, et ~ pour échapper. Autre outil, autres jokers.
• RegExp — la forme comporte des comptes de répétition, une alternance (this|that), ou un groupe à extraire. C'est au-delà de ce que Like sait exprimer.

Quand le motif dépasse Like — décrivez le travail plutôt

Like est un régal jusqu'au moment où la forme cesse d'être fixe. Dès que la règle devient « trois à cinq lettres, puis un tiret, puis un nombre variable de chiffres, et sors les chiffres », vous écrivez des boucles autour de Like, ou vous y greffez Mid et InStr, et l'intention disparaît dans la plomberie. C'est le signal soit de grimper vers un vrai motif — soit de sauter le code entièrement. ExcelMaster vous laisse énoncer la règle en langage courant — « garde les lignes dont le code fait trois lettres puis quatre chiffres, et mets les chiffres en colonne D » — et génère du Python qui applique la correspondance, sauvegarde d'abord votre fichier, et écrit le résultat. Vous décrivez la forme ; il gère les jokers, la casse et les bords.

Foire aux questions

Que fait l'opérateur Like en VBA ?

Like compare une chaîne à un motif et renvoie True si la chaîne entière correspond. Le motif peut contenir des jokers : * (toute suite de caractères), ? (un caractère), # (un chiffre), [liste] (un caractère d'un ensemble) et [!liste] (un caractère hors de l'ensemble). Il renvoie un Boolean, donc on l'emploie dans les conditions If et Do While.

Pourquoi ma comparaison VBA Like ne correspond-elle pas ?

Deux causes habituelles. D'abord, Like teste la chaîne entière, donc "Invoice 2026" Like "2026" vaut False — entourez le fragment d'astérisques : "*2026*". Ensuite, il est sensible à la casse sous le Option Compare Binary par défaut, donc "Excel" Like "excel" vaut False jusqu'à ce que vous ajoutiez Option Compare Text en haut du module ou repliiez la casse avec UCase.

Comment rendre VBA Like insensible à la casse ?

Placez Option Compare Text en haut du module — cela rend insensible à la casse chaque comparaison de chaînes du module, Like compris. Like n'a pas d'argument de casse par appel comme en ont InStr et Filter, donc pour une correspondance insensible à la casse ponctuelle sans changer le module, comparez plutôt des chaînes repliées : UCase(value) Like "PATTERN".

Comment reconnaître un astérisque ou un point d'interrogation littéral avec Like ?

Entourez le caractère spécial de crochets : [*] reconnaît un astérisque littéral, [?] un point d'interrogation littéral, [#] un dièse littéral et [[] un crochet ouvrant littéral. Par exemple "3*4" Like "*[*]*" vaut True. Cet échappement par crochets est propre à Like ; les outils de feuille comme Range.Find utilisent plutôt un tilde de tête (~*).

Quand utiliser Like plutôt qu'une expression régulière en VBA ?

Utilisez Like quand la forme est fixe et qu'un oui/non suffit : une extension de fichier, un code de longueur fixe, un contrôle « chiffres seuls ». Passez à une RegExp quand le motif a une répétition variable (\d{2,4}), une alternance (cat|dog), ou un groupe de capture à extraire. Like ne sait ni compter les répétitions ni renvoyer les morceaux correspondants ; une expression régulière le sait.

Testé dans

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

Guides associés : VBA IsNumeric · VBA Regex · VBA InStr · VBA Find · VBA UCase et LCase