Comment utiliser les expressions régulières (regex) dans Microsoft Excel à la fois dans la cellule et les boucles

Comment puis-je utiliser des expressions régulières dans Excel et profiter de la puissante configuration de type grille d'Excel pour la manipulation des données?

• Fonction dans la cellule pour renvoyer un modèle correspondant ou une valeur remplacée dans une chaîne.
• Sub pour parcourir une colonne de données et extraire les correspondances avec les cellules adjacentes.
• Quelle configuration est nécessaire?
• Quels sont les caractères spéciaux d'Excel pour les expressions régulières?

Je comprends Regex n'est pas idéal pour de nombreuses situations ( à utiliser ou ne pas utiliser des expressions régulières? ) Car Excel peut utiliser Left, Mid, Right, Instrcommandes de type pour des manipulations similaires.

Les expressions régulières sont utilisées pour la correspondance de motifs.

Pour utiliser dans Excel, procédez comme suit:

Étape 1 : ajouter une référence VBA à «Microsoft VBScript Regular Expressions 5.5»

• Sélectionnez l'onglet "Développeur" ( je n'ai pas cet onglet, que dois-je faire? )
• Sélectionnez l'icône "Visual Basic" dans la section du ruban "Code"
• Dans la fenêtre "Microsoft Visual Basic pour Applications", sélectionnez "Outils" dans le menu supérieur.
• Sélectionnez "Références"
• Cochez la case à côté de "Microsoft VBScript Regular Expressions 5.5" à inclure dans votre classeur.
• Cliquez sur OK"

Étape 2 : définissez votre modèle

Définitions basiques:

- Intervalle.

• Par exemple, a-zcorrespond à des lettres minuscules de a à z
• Par exemple, 0-5correspond à n'importe quel nombre de 0 à 5

[] Faites correspondre exactement l'un des objets à l'intérieur de ces crochets.

• Par exemple, [a]correspond à la lettre a
• Par exemple, [abc]correspond à une seule lettre qui peut être a, b ou c
• Par exemple, [a-z]correspond à n'importe quelle lettre minuscule de l'alphabet.

()Regroupe différents matchs à des fins de retour. Voir les exemples ci-dessous.

{} Multiplicateur pour les copies répétées du motif défini avant lui.

• Par exemple, [a]{2}correspond à deux lettres minuscules consécutives a:aa
• Par exemple , [a]{1,3}correspond à au moins un et jusqu'à trois lettres minuscules a, aa,aaa

+ Faites correspondre au moins un ou plusieurs des motifs définis avant lui.

• Par exemple , a+correspondra à un consécutive de a, aa, aaa, etc.

? Faites correspondre zéro ou l'un des motifs définis avant lui.

• Par exemple, le motif peut être présent ou non, mais ne peut être apparié qu'une seule fois.
• Par exemple, [a-z]?correspond à une chaîne vide ou à n'importe quelle lettre minuscule.

* Faites correspondre zéro ou plus du motif défini avant lui. - Par exemple, Wildcard pour un motif qui peut ou non être présent. - Par exemple, [a-z]*correspond à une chaîne vide ou une chaîne de lettres minuscules.

. Correspond à n'importe quel caractère sauf la nouvelle ligne \n

• Par exemple, a.correspond à une chaîne de deux caractères commençant par un et se terminant par tout sauf\n

| Opérateur OU

• Par exemple, a|bsignifie soit aou bpeut être apparié.
• Par exemple, red|white|orangecorrespond exactement à l'une des couleurs.

^ PAS opérateur

• Par exemple, le [^0-9]caractère ne peut pas contenir de nombre
• Par exemple, le [^aA]caractère ne peut pas être en minuscule aou en majusculeA

\ Échappe le caractère spécial qui suit (remplace le comportement ci-dessus)

• Par exemple \., \\, \(, \?, \$,\^

Modèles d'ancrage:

^ La correspondance doit se produire au début de la chaîne

• Par exemple, le ^apremier caractère doit être une lettre minusculea
• Par exemple, le ^[0-9]premier caractère doit être un nombre.

$ La correspondance doit se produire à la fin de la chaîne

• Par exemple, le a$dernier caractère doit être une lettre minusculea

Tableau de priorité:

Order  Name                Representation
1      Parentheses         ( )
2      Multipliers         ? + * {m,n} {m, n}?
3      Sequence & Anchors  abc ^ $
4      Alternation         |

Abréviations de caractères prédéfinies:

abr    same as       meaning
\d     [0-9]         Any single digit
\D     [^0-9]        Any single character that's not a digit
\w     [a-zA-Z0-9_]  Any word character
\W     [^a-zA-Z0-9_] Any non-word character
\s     [ \r\t\n\f]   Any space character
\S     [^ \r\t\n\f]  Any non-space character
\n     [\n]          New line

Exemple 1 : exécuter en tant que macro

L'exemple de macro suivant examine la valeur dans la cellule A1pour voir si les 1 ou 2 premiers caractères sont des chiffres. Si tel est le cas, ils sont supprimés et le reste de la chaîne s'affiche. Sinon, une boîte apparaît vous indiquant qu'aucune correspondance n'est trouvée. Les A1valeurs de cellule de 12abcrenverront abc, la valeur de 1abcrenverra abc, la valeur de abc123renverra "Non apparié" car les chiffres n'étaient pas au début de la chaîne.

Private Sub simpleRegex()
    Dim strPattern As String: strPattern = "^[0-9]{1,2}"
    Dim strReplace As String: strReplace = ""
    Dim regEx As New RegExp
    Dim strInput As String
    Dim Myrange As Range

    Set Myrange = ActiveSheet.Range("A1")

    If strPattern <> "" Then
        strInput = Myrange.Value

        With regEx
            .Global = True
            .MultiLine = True
            .IgnoreCase = False
            .Pattern = strPattern
        End With

        If regEx.Test(strInput) Then
            MsgBox (regEx.Replace(strInput, strReplace))
        Else
            MsgBox ("Not matched")
        End If
    End If
End Sub

Exemple 2 : exécuter en tant que fonction dans la cellule

Cet exemple est le même que l'exemple 1 mais est configuré pour s'exécuter en tant que fonction dans la cellule. Pour l'utiliser, changez le code en ceci:

Function simpleCellRegex(Myrange As Range) As String
    Dim regEx As New RegExp
    Dim strPattern As String
    Dim strInput As String
    Dim strReplace As String
    Dim strOutput As String


    strPattern = "^[0-9]{1,3}"

    If strPattern <> "" Then
        strInput = Myrange.Value
        strReplace = ""

        With regEx
            .Global = True
            .MultiLine = True
            .IgnoreCase = False
            .Pattern = strPattern
        End With

        If regEx.test(strInput) Then
            simpleCellRegex = regEx.Replace(strInput, strReplace)
        Else
            simpleCellRegex = "Not matched"
        End If
    End If
End Function

Placez vos cordes ("12abc") dans la cellule A1. Entrez cette formule =simpleCellRegex(A1)dans la cellule B1et le résultat sera "abc".

Exemple 3 : boucle à travers la plage

Cet exemple est le même que l'exemple 1, mais il parcourt une plage de cellules.

Private Sub simpleRegex()
    Dim strPattern As String: strPattern = "^[0-9]{1,2}"
    Dim strReplace As String: strReplace = ""
    Dim regEx As New RegExp
    Dim strInput As String
    Dim Myrange As Range

    Set Myrange = ActiveSheet.Range("A1:A5")

    For Each cell In Myrange
        If strPattern <> "" Then
            strInput = cell.Value

            With regEx
                .Global = True
                .MultiLine = True
                .IgnoreCase = False
                .Pattern = strPattern
            End With

            If regEx.Test(strInput) Then
                MsgBox (regEx.Replace(strInput, strReplace))
            Else
                MsgBox ("Not matched")
            End If
        End If
    Next
End Sub

Exemple 4 : séparation de différents motifs

Cet exemple parcourt une plage ( A1, A2& A3) et recherche une chaîne commençant par trois chiffres suivis d'un seul caractère alpha, puis de 4 chiffres. La sortie sépare la correspondance des motifs en cellules adjacentes à l'aide de la (). $1représente le premier motif correspondant dans le premier ensemble de ().

Private Sub splitUpRegexPattern()
    Dim regEx As New RegExp
    Dim strPattern As String
    Dim strInput As String
    Dim Myrange As Range

    Set Myrange = ActiveSheet.Range("A1:A3")

    For Each C In Myrange
        strPattern = "(^[0-9]{3})([a-zA-Z])([0-9]{4})"

        If strPattern <> "" Then
            strInput = C.Value

            With regEx
                .Global = True
                .MultiLine = True
                .IgnoreCase = False
                .Pattern = strPattern
            End With

            If regEx.test(strInput) Then
                C.Offset(0, 1) = regEx.Replace(strInput, "$1")
                C.Offset(0, 2) = regEx.Replace(strInput, "$2")
                C.Offset(0, 3) = regEx.Replace(strInput, "$3")
            Else
                C.Offset(0, 1) = "(Not matched)"
            End If
        End If
    Next
End Sub

Résultats:

Exemples de modèles supplémentaires

String   Regex Pattern                  Explanation
a1aaa    [a-zA-Z][0-9][a-zA-Z]{3}       Single alpha, single digit, three alpha characters
a1aaa    [a-zA-Z]?[0-9][a-zA-Z]{3}      May or may not have preceding alpha character
a1aaa    [a-zA-Z][0-9][a-zA-Z]{0,3}     Single alpha, single digit, 0 to 3 alpha characters
a1aaa    [a-zA-Z][0-9][a-zA-Z]*         Single alpha, single digit, followed by any number of alpha characters

</i8>    \<\/[a-zA-Z][0-9]\>            Exact non-word character except any single alpha followed by any single digit

Pour utiliser des expressions régulières directement dans des formules Excel, l'UDF (fonction définie par l'utilisateur) suivante peut être utile. Il expose plus ou moins directement la fonctionnalité d'expression régulière en tant que fonction Excel.

Comment ça fonctionne

Cela prend 2-3 paramètres.

1. Un texte sur lequel utiliser l'expression régulière.
2. Une expression régulière.
3. Une chaîne de format spécifiant à quoi le résultat doit ressembler. Il peut contenir $0, $1, $2et ainsi de suite. $0correspond à l'intégralité de la correspondance $1et correspond aux groupes de correspondance respectifs dans l'expression régulière. Par défaut à $0.

Quelques exemples

Extraire une adresse e-mail:

=regex("Peter Gordon: [email protected], 47", "\w+@\w+\.\w+")
=regex("Peter Gordon: [email protected], 47", "\w+@\w+\.\w+", "$0")

Résulte en: [email protected]

Extraire plusieurs sous-chaînes:

=regex("Peter Gordon: [email protected], 47", "^(.+): (.+), (\d+)$", "E-Mail: $2, Name: $1")

Résulte en: E-Mail: [email protected], Name: Peter Gordon

Pour démonter une chaîne combinée dans une seule cellule en ses composants dans plusieurs cellules:

=regex("Peter Gordon: [email protected], 47", "^(.+): (.+), (\d+)$", "$" & 1)
=regex("Peter Gordon: [email protected], 47", "^(.+): (.+), (\d+)$", "$" & 2)

Résultats en: Peter Gordon [email protected]...

Comment utiliser

Pour utiliser cet UDF, procédez comme suit (basé sur cette page Microsoft . Ils contiennent de bonnes informations supplémentaires!):

1. Dans Excel dans un fichier activé par macro ('.xlsm'), appuyez sur ALT+F11pour ouvrir l' éditeur Microsoft Visual Basic pour Applications .
2. Ajoutez une référence VBA à la bibliothèque d'expressions régulières (copiée sans vergogne à partir de la réponse Portland Runners ++ ):
   1. Cliquez sur Outils -> Références (veuillez excuser la capture d'écran allemande)
   2. Recherchez Microsoft VBScript Regular Expressions 5.5 dans la liste et cochez la case à côté.
   3. Cliquez OK .

3. Cliquez sur Insérer un module . Si vous donnez à votre module un nom différent, assurez-vous que le module n'a pas le même nom que l'UDF ci-dessous (par exemple, nommer le module Regexet la fonction regexprovoque des erreurs #NAME! ).

   

4. Dans la grande fenêtre de texte au milieu, insérez ce qui suit:

   Function regex(strInput As String, matchPattern As String, Optional ByVal outputPattern As String = "$0") As Variant
       Dim inputRegexObj As New VBScript_RegExp_55.RegExp, outputRegexObj As New VBScript_RegExp_55.RegExp, outReplaceRegexObj As New VBScript_RegExp_55.RegExp
       Dim inputMatches As Object, replaceMatches As Object, replaceMatch As Object
       Dim replaceNumber As Integer
   
       With inputRegexObj
           .Global = True
           .MultiLine = True
           .IgnoreCase = False
           .Pattern = matchPattern
       End With
       With outputRegexObj
           .Global = True
           .MultiLine = True
           .IgnoreCase = False
           .Pattern = "\$(\d+)"
       End With
       With outReplaceRegexObj
           .Global = True
           .MultiLine = True
           .IgnoreCase = False
       End With
   
       Set inputMatches = inputRegexObj.Execute(strInput)
       If inputMatches.Count = 0 Then
           regex = False
       Else
           Set replaceMatches = outputRegexObj.Execute(outputPattern)
           For Each replaceMatch In replaceMatches
               replaceNumber = replaceMatch.SubMatches(0)
               outReplaceRegexObj.Pattern = "\$" & replaceNumber
   
               If replaceNumber = 0 Then
                   outputPattern = outReplaceRegexObj.Replace(outputPattern, inputMatches(0).Value)
               Else
                   If replaceNumber > inputMatches(0).SubMatches.Count Then
                       'regex = "A to high $ tag found. Largest allowed is $" & inputMatches(0).SubMatches.Count & "."
                       regex = CVErr(xlErrValue)
                       Exit Function
                   Else
                       outputPattern = outReplaceRegexObj.Replace(outputPattern, inputMatches(0).SubMatches(replaceNumber - 1))
                   End If
               End If
           Next
           regex = outputPattern
       End If
   End Function

5. Enregistrez et fermez la fenêtre Microsoft Visual Basic pour Applications Editor.

Élargir la réponse de Patszim pour ceux qui sont pressés.

1. Ouvrez le classeur Excel.
2. Alt+ F11pour ouvrir la fenêtre VBA / Macros.
3. Ajouter une référence à l'expression régulière sous Outils puis Références
   
4. et sélection de Microsoft VBScript Regular Expression 5.5
   
5. Insérez un nouveau module (le code doit résider dans le module sinon il ne fonctionne pas).
   
6. Dans le module nouvellement inséré,
   

7. ajoutez le code suivant:

   Function RegxFunc(strInput As String, regexPattern As String) As String
       Dim regEx As New RegExp
       With regEx
           .Global = True
           .MultiLine = True
           .IgnoreCase = False
           .pattern = regexPattern
       End With
   
       If regEx.Test(strInput) Then
           Set matches = regEx.Execute(strInput)
           RegxFunc = matches(0).Value
       Else
           RegxFunc = "not matched"
       End If
   End Function

8. Le motif d'expression régulière est placé dans l'une des cellules et un référencement absolu est utilisé dessus. La fonction sera liée au classeur dans lequel elle a été créée.
   S'il est nécessaire de l'utiliser dans différents classeurs, stockez la fonction dans Personal.XLSB

Voici ma tentative:

Function RegParse(ByVal pattern As String, ByVal html As String)
    Dim regex   As RegExp
    Set regex = New RegExp

    With regex
        .IgnoreCase = True  'ignoring cases while regex engine performs the search.
        .pattern = pattern  'declaring regex pattern.
        .Global = False     'restricting regex to find only first match.

        If .Test(html) Then         'Testing if the pattern matches or not
            mStr = .Execute(html)(0)        '.Execute(html)(0) will provide the String which matches with Regex
            RegParse = .Replace(mStr, "$1") '.Replace function will replace the String with whatever is in the first set of braces - $1.
        Else
            RegParse = "#N/A"
        End If

    End With
End Function

J'avais besoin de l'utiliser comme fonction de cellule (comme SUMou VLOOKUP) et j'ai trouvé qu'il était facile de:

1. Assurez-vous que vous vous trouvez dans un fichier Excel activé par macro (enregistrez-le au format xlsm).
2. Outils de développement ouverts Alt+F11
3. Ajoutez Microsoft VBScript Regular Expressions 5.5 comme dans les autres réponses

4. Créez la fonction suivante dans le classeur ou dans son propre module:

   Function REGPLACE(myRange As Range, matchPattern As String, outputPattern As String) As Variant
       Dim regex As New VBScript_RegExp_55.RegExp
       Dim strInput As String
   
       strInput = myRange.Value
   
       With regex
           .Global = True
           .MultiLine = True
           .IgnoreCase = False
           .Pattern = matchPattern
       End With
   
       REGPLACE = regex.Replace(strInput, outputPattern)
   
   End Function

5. Ensuite, vous pouvez utiliser dans la cellule avec =REGPLACE(B1, "(\w) (\d+)", "$1$2")(ex: "A 243" à "A243")

Ce n'est pas une réponse directe mais peut fournir une alternative plus efficace pour votre considération. Ce qui est que Google Sheets a plusieurs fonctions Regex intégrées, celles-ci peuvent être très pratiques et aider à contourner certaines des procédures techniques dans Excel. Évidemment, l'utilisation d'Excel sur votre PC présente certains avantages, mais pour la grande majorité des utilisateurs, Google Sheets offrira une expérience identique et peut offrir certains avantages en termes de portabilité et de partage de documents.

Ils offrent

REGEXEXTRACT: extrait les sous-chaînes correspondantes selon une expression régulière.

REGEXREPLACE: remplace une partie d'une chaîne de texte par une chaîne de texte différente à l'aide d'expressions régulières.

SUBSTITUTE: remplace le texte existant par un nouveau texte dans une chaîne.

REMPLACER: remplace une partie d'une chaîne de texte par une chaîne de texte différente.

Vous pouvez les taper directement dans une cellule comme ça et produire ce que vous voulez

=REGEXMATCH(A2, "[0-9]+")

Ils fonctionnent également très bien en combinaison avec d'autres fonctions telles que les instructions IF comme ceci:

=IF(REGEXMATCH(E8,"MiB"),REGEXEXTRACT(E8,"\d*\.\d*|\d*")/1000,IF(REGEXMATCH(E8,"GiB"),REGEXEXTRACT(E8,"\d*\.\d*|\d*"),"")

Espérons que cela fournira une solution de contournement simple aux utilisateurs qui se sentent raillés par le composant VBS d'Excel.

Voici une regex_subst()fonction. Exemples:

=regex_subst("watermellon", "[aeiou]", "")
---> wtrmlln
=regex_subst("watermellon", "[^aeiou]", "")
---> aeeo

Voici le code simplifié (plus simple pour moi, en tout cas). Je ne pouvais pas comprendre comment créer un modèle de sortie approprié en utilisant ce qui précède pour fonctionner comme mes exemples:

Function regex_subst( _
     strInput As String _
   , matchPattern As String _
   , Optional ByVal replacePattern As String = "" _
) As Variant
    Dim inputRegexObj As New VBScript_RegExp_55.RegExp

    With inputRegexObj
        .Global = True
        .MultiLine = True
        .IgnoreCase = False
        .Pattern = matchPattern
    End With

    regex_subst = inputRegexObj.Replace(strInput, replacePattern)
End Function

Je ne veux pas avoir à activer une bibliothèque de référence car j'ai besoin que mes scripts soient portables. La Dim foo As New VBScript_RegExp_55.RegExpligne a causé des User Defined Type Not Definederreurs, mais j'ai trouvé une solution qui fonctionnait pour moi.

Ce que vous voudrez faire est de mettre un exemple de chaîne dans une cellule A1, puis de tester votre strPattern. Une fois que cela fonctionne, ajustez-le rngcomme vous le souhaitez.

Public Sub RegExSearch()
'/programming/22542834/how-to-use-regular-expressions-regex-in-microsoft-excel-both-in-cell-and-loops
'https://wellsr.com/vba/2018/excel/vba-regex-regular-expressions-guide/
'https://www.vitoshacademy.com/vba-regex-in-excel/
    Dim regexp As Object
    'Dim regex As New VBScript_RegExp_55.regexp 'Caused "User Defined Type Not Defined" Error
    Dim rng As Range, rcell As Range
    Dim strInput As String, strPattern As String

    Set regexp = CreateObject("vbscript.regexp")
    Set rng = ActiveSheet.Range("A1:A1")

    strPattern = "([a-z]{2})([0-9]{8})"
    'Search for 2 Letters then 8 Digits Eg: XY12345678 = Matched

    With regexp
        .Global = False
        .MultiLine = False
        .ignoreCase = True
        .Pattern = strPattern
    End With

    For Each rcell In rng.Cells

        If strPattern <> "" Then
            strInput = rcell.Value

            If regexp.test(strInput) Then
                MsgBox rcell & " Matched in Cell " & rcell.Address
            Else
                MsgBox "No Matches!"
            End If
        End If
    Next
End Sub

Pour ajouter au contenu précieux, je voudrais créer ce rappel sur pourquoi parfois RegEx dans VBA n'est pas idéal. Toutes les expressions ne sont pas prises en charge, mais peuvent au lieu de cela jeter un Error 5017et laisser l'auteur deviner (dont je suis moi-même victime).

Bien que nous puissions trouver des sources sur ce qui est pris en charge, il serait utile de savoir quels métacaractères, etc. ne sont pas pris en charge. Une explication plus approfondie peut être trouvée ici . Mentionné dans cette source:

"Bien que" l'expression régulière de VBScript ... la version 5.5 implémente quelques fonctionnalités regex essentielles qui manquaient dans les versions précédentes de VBScript. ... JavaScript et VBScript implémentent des expressions régulières de style Perl. Cependant, il leur manque un certain nombre de fonctionnalités avancées disponibles en Perl et d'autres versions modernes d'expression régulière: "

Donc, non pris en charge:

• Début de l'ancêtre de la chaîne \A, utilisez également le ^curseur pour faire correspondre la position avant le 1er caractère de la chaîne
• Fin de la chaîne ancor \Z, utilisez alternativement le $signe dollar pour faire correspondre la position après le dernier caractère de la chaîne
• LookBehind positif, par exemple: (?<=a)b(tandis que LookAhead positif est pris en charge)
• LookBehind négatif, par exemple: (?<!a)b(tandis que LookAhead négatif est pris en charge)
• Groupement atomique
• Quantificateurs possessifs
• Unicode, par exemple: \{uFFFF}
• Groupes de capture nommés . Vous pouvez également utiliser des groupes de capture numérotés
• Modificateurs en ligne, par exemple: /i(respect de la casse) ou /g(global) etc. Définissez-les via les RegExppropriétés de l' objet> RegExp.Global = Trueet RegExp.IgnoreCase = Truesi disponibles.
• Conditionnels
• Commentaires d'expression régulière . Ajoutez-les avec des 'commentaires réguliers dans le script

J'ai déjà frappé un mur plus d'une fois en utilisant des expressions régulières dans VBA. Habituellement avec LookBehindmais parfois j'oublie même les modificateurs. Je n'ai pas moi-même expérimenté tous ces décors mentionnés ci-dessus, mais j'ai pensé que j'essaierais d'être détaillé en me référant à des informations plus approfondies. N'hésitez pas à commenter / corriger / ajouter. Grand merci à regular-expressions.info pour une mine d'informations.

PS Vous avez mentionné les méthodes et fonctions VBA habituelles, et je peux confirmer qu'elles (au moins pour moi) ont été utiles à leur manière là où RegEx échouerait.