Como usar expressões regulares (Regex) no Microsoft Excel na célula e em loops

Como posso usar expressões regulares no Excel e aproveitar a poderosa configuração semelhante à grade do Excel para manipulação de dados?

• Função na célula para retornar um padrão correspondente ou um valor substituído em uma sequência.
• Sub para percorrer uma coluna de dados e extrair correspondências para células adjacentes.
• Que configuração é necessária?
• Quais são os caracteres especiais do Excel para expressões regulares?

Eu entendo Regex não é o ideal para muitas situações ( para usar ou não usar expressões regulares? ) Desde excel pode usar Left, Mid, Right, Instrcomandos tipo de manipulações semelhantes.

Expressões regulares são usadas para a correspondência de padrões.

Para usar no Excel, siga estas etapas:

Etapa 1 : Adicione referência VBA a "Microsoft VBScript Regular Expressions 5.5"

• Selecione a guia "Desenvolvedor" ( não tenho essa guia, o que devo fazer? )
• Selecione o ícone "Visual Basic" na seção da faixa de opções 'Código'
• Na janela "Microsoft Visual Basic for Applications", selecione "Ferramentas" no menu superior.
• Selecione "Referências"
• Marque a caixa ao lado de "Microsoft VBScript Regular Expressions 5.5" para incluir na sua pasta de trabalho.
• Clique OK"

Etapa 2 : defina seu padrão

Definições básicas:

- Alcance.

• Por exemplo, a-zcombina letras minúsculas de a a z
• Por exemplo, 0-5corresponde a qualquer número de 0 a 5

[] Combine exatamente um dos objetos dentro desses colchetes.

• Por exemplo, [a]corresponde à letra a
• Por exemplo, [abc]corresponde a uma única letra que pode ser a, b ou c
• Por exemplo, [a-z]corresponde a qualquer letra minúscula do alfabeto.

()Agrupa diferentes correspondências para fins de retorno. Veja exemplos abaixo.

{} Multiplicador para cópias repetidas do padrão definido antes dele.

• Por exemplo, [a]{2}corresponde a duas letras minúsculas consecutivas a:aa
• Por exemplo, [a]{1,3}corresponde a pelo menos um e até três letra minúscula a, aa,aaa

+ Combine pelo menos um, ou mais, do padrão definido antes dele.

• Por exemplo, a+irá corresponder consecutiva de um a, aa, aaa, e assim por diante

? Corresponder a zero ou um dos padrões definidos antes dele.

• Por exemplo, o padrão pode ou não estar presente, mas só pode ser correspondido uma vez.
• Por exemplo, [a-z]?corresponde a uma string vazia ou a qualquer letra minúscula.

* Corresponder a zero ou mais do padrão definido antes dele. - Por exemplo, curinga para o padrão que pode ou não estar presente. - Por exemplo, [a-z]*corresponde a uma sequência vazia ou a uma sequência de letras minúsculas.

. Corresponde a qualquer caractere, exceto nova linha \n

• Por exemplo, a.corresponde a uma cadeia de dois caracteres começando com a e terminando com qualquer coisa, exceto\n

| Operador OR

• Por exemplo, a|bsignifica aou bpode ser correspondido.
• Por exemplo, red|white|orangecorresponde exatamente a uma das cores.

^ Operador NOT

• Por exemplo, o [^0-9]caractere não pode conter um número
• Por exemplo, o [^aA]caractere não pode ser minúsculo aou maiúsculoA

\ Escapa o caractere especial a seguir (substitui o comportamento acima)

• Por exemplo \., \\, \(, \?, \$,\^

Padrões de ancoragem:

^ A correspondência deve ocorrer no início da string

• Por exemplo, o ^aprimeiro caractere deve ser minúsculoa
• Por exemplo, o ^[0-9]primeiro caractere deve ser um número.

$ A correspondência deve ocorrer no final da sequência

• Por exemplo, o a$último caractere deve ser minúsculoa

Tabela de precedência:

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

Abreviações de caracteres predefinidas:

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

Exemplo 1 : Executar como Macro

O exemplo a seguir macro analisa o valor na célula A1para ver se os primeiros 1 ou 2 caracteres são dígitos. Nesse caso, eles são removidos e o restante da string é exibido. Caso contrário, será exibida uma caixa informando que nenhuma correspondência foi encontrada. Os A1valores de célula de 12abcretornarão abc, o valor de 1abcretornará abc, o valor de abc123retornará "Não correspondido" porque os dígitos não estavam no início da sequência.

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

Exemplo 2 : Executar como uma função na célula

Este exemplo é o mesmo que o exemplo 1, mas está configurado para ser executado como uma função na célula. Para usar, altere o código para isso:

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

Coloque suas cordas ("12abc") na célula A1. Digite esta fórmula =simpleCellRegex(A1)na célula B1e o resultado será "abc".

Exemplo 3 : Loop Through Range

Este exemplo é o mesmo que o exemplo 1, mas percorre um intervalo de células.

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

Exemplo 4 : Separando Padrões Diferentes

Este exemplo percorre um intervalo ( A1, A2& A3) e procura uma sequência que comece com três dígitos seguidos por um único caractere alfa e depois por quatro dígitos numéricos. A saída separa as correspondências do padrão em células adjacentes usando o (). $1representa o primeiro padrão correspondente dentro do primeiro conjunto 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

Resultados:

Exemplos adicionais de padrões

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

Para usar expressões regulares diretamente nas fórmulas do Excel, a seguinte UDF (função definida pelo usuário) pode ser útil. Expõe mais ou menos diretamente a funcionalidade de expressão regular como uma função do Excel.

Como funciona

Leva 2-3 parâmetros.

1. Um texto para usar a expressão regular.
2. Uma expressão regular.
3. Uma sequência de formato que especifica a aparência do resultado. Ele pode conter $0, $1, $2, e assim por diante. $0é a correspondência inteira $1e acima correspondem aos respectivos grupos de correspondência na expressão regular. O padrão é $0.

Alguns exemplos

Extraindo um endereço de email:

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

Resulta em: [email protected]

Extraindo várias substrings:

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

Resulta em: E-Mail: [email protected], Name: Peter Gordon

Para desmontar uma sequência combinada em uma única célula em seus componentes em várias células:

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

Resultados em: Peter Gordon [email protected]...

Como usar

Para usar esse UDF, faça o seguinte (basicamente com base nesta página da Microsoft . Eles têm boas informações adicionais lá!):

1. No Excel, em um arquivo ativado por macro ('.xlsm'), pressione ALT+F11para abrir o Microsoft Visual Basic for Applications Editor.
2. Adicione referência VBA à biblioteca de expressões regulares (copiada descaradamente da resposta Portland Runners ++ ):
   1. Clique em Ferramentas -> Referências (desculpe a captura de tela em alemão)
   2. Localize Microsoft VBScript Regular Expressions 5.5 na lista e marque a caixa de seleção ao lado.
   3. Clique em OK .

3. Clique em Inserir módulo . Se você der um nome diferente ao seu módulo, verifique se o Módulo não tem o mesmo nome que o UDF abaixo (por exemplo, nomear o Módulo Regexe a função regexcausa erros de # NOME! ).

   

4. Na grande janela de texto no meio, insira o seguinte:

   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. Salve e feche a janela do Microsoft Visual Basic for Applications Editor.

Expandindo patszim 's resposta para aqueles com pressa.

1. Abra a pasta de trabalho do Excel.
2. Alt+ F11para abrir a janela VBA / Macros.
3. Adicione referência ao regex em Ferramentas e depois em Referências.
   
4. e selecionando Microsoft VBScript Regular Expression 5.5
   
5. Insira um novo módulo (o código precisa residir no módulo, caso contrário não funcionará).
   
6. No módulo recém-inserido,
   

7. adicione o seguinte código:

   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. O padrão regex é colocado em uma das células e a referência absoluta é usada nele. A função será vinculada à pasta de trabalho criada.
   Se houver necessidade de ser usada em pastas de trabalho diferentes, armazene a função no Personal.XLSB

Aqui está a minha tentativa:

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

Eu precisava usar isso como uma função de célula (como SUMou VLOOKUP) e descobri que era fácil:

1. Verifique se você está em um arquivo do Excel ativado por macro (salve como xlsm).
2. Ferramentas abertas para desenvolvedores Alt+F11
3. Adicione expressões regulares do Microsoft VBScript 5.5 como em outras respostas

4. Crie a seguinte função na pasta de trabalho ou em seu próprio módulo:

   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. Em seguida, você pode usar na célula com =REGPLACE(B1, "(\w) (\d+)", "$1$2")(ex: "A 243" a "A243")

Esta não é uma resposta direta, mas pode fornecer uma alternativa mais eficiente para sua consideração. O Google Sheets possui várias funções Regex integradas, que podem ser muito convenientes e ajudar a contornar alguns dos procedimentos técnicos no Excel. Obviamente, existem algumas vantagens em usar o Excel no seu PC, mas para a grande maioria dos usuários, o Google Sheets oferece uma experiência idêntica e pode oferecer alguns benefícios em portabilidade e compartilhamento de documentos.

Eles oferecem

REGEXEXTRACT: Extrai substrings correspondentes de acordo com uma expressão regular.

REGEXREPLACE: substitui parte de uma sequência de texto por uma sequência de texto diferente usando expressões regulares.

SUBSTITUTE: Substitui o texto existente pelo novo texto em uma sequência.

SUBSTITUIR: Substitui parte de uma sequência de texto por uma sequência de texto diferente.

Você pode digitá-las diretamente em uma célula assim e produzirá o que quiser

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

Eles também funcionam muito bem em combinações com outras funções, como instruções IF , como:

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

Esperamos que isso forneça uma solução simples para usuários que se sentem insultados pelo componente VBS do Excel.

Aqui está uma regex_subst()função. Exemplos:

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

Aqui está o código simplificado (mais simples para mim, de qualquer maneira). Não consegui descobrir como criar um padrão de saída adequado usando o acima para funcionar como meus exemplos:

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

Não quero habilitar uma biblioteca de referência, pois preciso que meus scripts sejam portáteis. A Dim foo As New VBScript_RegExp_55.RegExplinha causou User Defined Type Not Definederros, mas encontrei uma solução que funcionou para mim.

O que você deseja fazer é colocar uma sequência de exemplo na célula A1e testar sua strPattern. Quando estiver funcionando, ajuste-o rngconforme desejado.

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

Para adicionar ao conteúdo valioso, gostaria de criar este lembrete sobre por que às vezes o RegEx no VBA não é o ideal. Nem todas as expressões são suportadas, mas podem gerar um Error 5017e deixar o autor adivinhando (que eu sou uma vítima de mim mesmo).

Embora possamos encontrar algumas fontes sobre o que é suportado, seria útil saber quais metacaracteres etc. não são suportados. Uma explicação mais aprofundada pode ser encontrada aqui . Mencionado nesta fonte:

"Embora" a expressão regular do VBScript ... versão 5.5 implementa alguns recursos essenciais de regex que estavam faltando nas versões anteriores do VBScript. ... JavaScript e VBScript implementam expressões regulares no estilo Perl. No entanto, eles não possuem muitos recursos avançados disponíveis no Perl e em outros tipos modernos de expressões regulares: "

Portanto, não suportados são:

• Início do Ancor String \A, como alternativa, use o ^cursor para corresponder à posição antes do 1º caracter na string
• Fim da sequência de caracteres \Z, use alternativamente o $cifrão para corresponder à posição após o último caractere na sequência
• LookBehind positivo, por exemplo: (?<=a)b(enquanto o LookAhead positivo for suportado)
• LookBehind negativo, por exemplo: (?<!a)b(enquanto LookAhead negativo é suportado)
• Agrupamento atômico
• Quantificadores Possessivos
• Unicode, por exemplo: \{uFFFF}
• Grupos de captura nomeados . Como alternativa, use grupos de captura numerados
• Modificadores em linha, por exemplo: /i(distinção entre maiúsculas e minúsculas) ou /g(global) etc. Defina-os nas RegExppropriedades do objeto> RegExp.Global = Truee, RegExp.IgnoreCase = Truese disponíveis.
• Condicionais
• Comentários sobre expressões regulares . Adicione-os com 'comentários regulares no script

Eu já bati em uma parede mais de uma vez usando expressões regulares no VBA. Geralmente com LookBehindmas às vezes até esqueço os modificadores. Eu não experimentei todos esses cenários mencionados acima, mas pensei em tentar ser extenso, referindo-me a algumas informações mais aprofundadas. Sinta-se livre para comentar / corrigir / adicionar. Um grande grito para regular-expressions.info por uma riqueza de informações.

PS: Você mencionou métodos e funções regulares do VBA, e posso confirmar que eles (pelo menos para mim) foram úteis de suas próprias maneiras em que o RegEx falharia.