VBA - Regelbundna uttryck

Denna handledning syftar till att förklara alla komplexa relaterade till användningen av reguljära uttryck. Du lär dig att navigera genom strängar för att hitta substrängar med regelbundna uttryck (vanligtvis kallad RegExp ).

förutsättningar

I VBA-redigeraren.

Gå till Verktyg-menyn> Referenser.
Bläddra igenom de olika referenserna och kolla följande alternativ "Microsoft VBScript Regular Expression 5.5".

Syntax och deklaration

I dessa exempel är de enda villkor som vi behöver:

Påståendet

Två alternativ är tillgängliga:

Som objekt

 Dim reg Som Objekt Ange reg = CreateObject ("vbscript.regexp")

VBScript_RegExp_55.regexp

 Dim reg Som VBScript_RegExp_55.regexp Ange reg = Ny VBScript_RegExp_55.regexp

Egenskaperna

Oavsett hur du angav RegExp, kommer egenskaperna att ha samma syntax.

Mönstret

Mönstret måste överensstämma med substrängen. Det låter dig navigera genom strängen.

 reg.Pattern = "IciLeMotif"

Testa

Vi testar strängen, om mönstret hittas returnerar det följande booleska värdet: True.

 reg.Test = "IciLeMotif"

Strängen börjar med A (stor bokstav)

Mönstret skulle vara:

i början av strängen
Det finns en A

Notationen av detta mönster är: ^ A

 Funktion Prem_Lettre_A (uttryck som sträng) Som Boolean Dim Reg som Objektuppsättning reg = CreateObject ("vbscript.regexp") "Le Pattern är ett motiv för att se om du vill" début de chaîne: ^ 'doit être: A reg.Pattern = "^ A" 'le test renvoie un Boolean (parfait pour notre fonction Booléenne !!!) Prem_Lettre_A = reg.test (uttryck) Slutfunktion

För att ringa funktionen:

 Sub Test_A () 'Nous allons chercher si un String startar med "A" Majuscule MsgBox Prem_Lettre_A ("alors?") MsgBox Prem_Lettre_A ("Ahhh") MsgBox Prem_Lettre_A ("Pas mal non?") End Sub

Strängen börjar med a eller A

Mönstret på mönstret är [aA]

 Sub-test_a_ou_A () 'Allmänna chercher si un String startar med "a" ou "A" MsgBox Prem_Lettre_a_ou_A ("alors?") MsgBox Prem_Lettre_a_ou_A ("Ahhh") MsgBox Prem_Lettre_a_ou_A ("Pas mal non?") End Sub Function Prem_Lettre_a_ou_A uttryck som sträng) Som Boolean Dim Reg som Objektuppsättning reg = CreateObject ("vbscript.regexp") 'ici la première lettre: ^' gör det: a ou A => [aA] reg.Pattern = "^ [aA]" Prem_Lettre_a_ou_A = reg.test (uttryck) Slutfunktion

Strängen börjar med en stor bokstav

Notationen för detta mönster är: [AZ]

 Sub Commence_par_Majuscule () MsgBox "Alors? Commence par une majuscule:" & Prem_Lettre_Majuscule ("alors?") MsgBox "Ahhh börjar med en gång maj:" & Prem_Lettre_Majuscule ("Ahhh") MsgBox " & Prem_Lettre_Majuscule ("Pas mal non?") End Sub-funktion Prem_Lettre_Majuscule (uttryck som sträng) Som Boolean Dim Reg som Objektuppsättning reg = CreateObject ("vbscript.regexp") 'ici la première lettre: ^' gör det lättare att använda Majuscule: [AZ] reg.Pattern = "^ [AZ]" Prem_Lettre_Majuscule = reg.test (uttryck) Slutfunktion

Strängen slutar med

Använd följande notering: $

 Sub Fini_Par () MsgBox "La frase: Läs RegExp är super! Se termine par super:" & Fin_De_Phrase ("Les RegExp är super!") MsgBox "La frase: C'est super les RegExp! Se termine par super: "& Fin_De_Phrase (" C'est super les RegExp! ") End Sub-funktion Fin_De_Phrase (uttryck som sträng) Som booleskt dim reg som Objekt Set reg = CreateObject (" vbscript.regexp ")" La fin de la chaine doit être : super! 'notation de fin de chaîne: $ reg.Pattern = "super! $"' notera läsplatsen placera en fin ... Fin_De_Phrase = reg.test (uttryck) Slutfunktion

Strängen innehåller ett nummer

Notationen för detta mönster är [0-9] . Om du vill hitta ett tal mellan 3 och 7: [3-7]

 Sub Contient_un_chiffre () MsgBox "aze1rty contient un chiffre:" & A_Un_Chiffre ("aze1rty") MsgBox "azerty contient un chiffre:" & A_Un_Chiffre ("azerty") Slutdel Funktion A_Un_Chiffre (uttryck som sträng) Som Booles Dim Dim reg = CreateObject ("vbscript.regexp") "gör en komprimerare från den 0 till 9 n'importe ou (début, milieu, fin de chaine ...) reg.Pattern =" [0-9] "" remarque [0 -9] s'écrit également: \ d 'reg.Pattern = "\ d" A_Un_Chiffre = reg.test (uttryck) Slutfunktion

Strängen innehåller ett 3-siffrigt nummer

Vi kommer nu att "kvantifiera" i vår RegExp. För att hitta tre händelser, kommer vi att använda de lockiga axlarna {}.

 Sub Contient_Un_Nombre_A_trois_Chiffres () MsgBox "aze1rty contient 3 chiffrar:" & Nb_A_Trois_Chiffre ("aze1rty") MsgBox "a1ze2rty3 kontient 3 chiffrar:" & Nb_A_Trois_Chiffre ("a1ze2rty3") MsgBox "azer123ty kontient 3 chiffrar:" & Nb_A_Trois_Chiffre ("azer123ty") Slut Sub-funktionen Nb_A_Trois_Chiffre (uttryck som sträng) Som booleskt dim reg som objektuppsättning reg = CreateObject ("vbscript.regexp") 'gör komprimerare 3 chiffrar de 0 till 9 qui se suivent' le nombre d'occurrence se not {} reg.Pattern = "\ d {3}" "ekvivalent de: reg.Pattern =" [0-9] {3} "Nb_A_Trois_Chiffre = reg.test (uttryck) Slutfunktion

Strängen innehåller 3 separata nummer

Koden

 Subcontient_trois_Chiffres () MsgBox "aze1rty contient 3 chiffres séparés:" & Trois_Chiffre ("aze1rty") MsgBox "a1ze2rty3 kontient 3 chiffres séparés:" & Trois_Chiffre ("a1ze2rty3") MsgBox "azer123ty kontient 3 chiffres séparés:" & Trois_Chiffre ("azer123ty ") End-delfunktion Trois_Chiffre (uttryck som sträng) Som Boolean Dim Reg som Objektuppsättning reg = CreateObject (" vbscript.regexp ")" gör kompistern 3 chiffrar de 0 till 9 qui ne se suivent pass {} 'le point (.) indikerar en importportfölj med en köpare som håller på att ligga i samma riktning som den här bokstaven (i det här fallet) gör det omöjligt att se till att den är öppen. + (\ d {1}) (.) + (\ d {1}) (.) + (\ d {1}) "Trois_Chiffre = reg.test

En variant

 Sub Contient_trois_Chiffres_Variante () MsgBox "aze1rty contient 3 chiffres séparés:" & Trois_Chiffre_Simplifiee ( "aze1rty") MsgBox "a1ze2rty3 contient 3 chiffres séparés:" & Trois_Chiffre_Simplifiee ( "a1ze2rty3") MsgBox "azer123ty contient 3 chiffres séparés:" & Trois_Chiffre_Simplifiee ( "azer123ty ") End-delfunktion Trois_Chiffre_Simplifiee (uttryck som sträng) Som booleskt dim reg som objektuppsättning reg = CreateObject (" vbscript.regexp ")" Komme le même motiv: (.) + (\ D {1}) se répète trois fois: reg.Pattern = "(. + \ d {1}) {3}" Trois_Chiffre_Simplifiee = reg.test (uttryck) Slutfunktion

Exempel på användning

I vårt exempel är målet att bestämma om strängen består av följande sekvens:

1: Strängen börjar med ordet "Vis"
2: följt av ett mellanslag
3: följt av 1 till 3 bokstäver
4: följt av ett mellanslag
5: följt av bokstaven M
6: följt av 1 till 2 brev
7: följt av en bindestreck
8: följt av 1 till 3 bokstäver
9: följt av ordet "classe" omgiven av mellanslag och i små bokstäver
10: Uppföljning av 1-2 bokstäver
11: följt av en punkt
12: följt av ett brev

Observera att : Varje block i mönstret är inneslutet mellan parenteser.

Notation:

1- => (^ Vis)
2- => ()
3- => ([a-zA-Z] {1, 3})
4- => () --- Anmärkning: På grund av att du har en inblick i det du vill ha ... Missa jag till exempel
5- => (M)
6- => ([a-zA-Z] {1, 2})
7- => (-)
8- => ([a-zA-Z] {1, 3})
9- => (classe)
10- => ([a-zA-Z] {1, 2})
11- => (\.)
12- => ([a-zA-Z] {1})

Detta ger oss följande mönster

"(^ Vis) () ([a-zA-Z] {1, 3}) () (M) ([a-zA-Z] {1, 2}) (-) ([a-zA-Z ] {1, 3}) (classe) ([a-zA-Z] {1, 2}) (.) ([A-zA-Z] {1}) "

Koden:

 Sub Main () Om VerifieMaChaine ("Visa xx Mxx-x classe xx.x") Då MsgBox "bra" Else MsgBox "pass glop" Avsluta om "manque l'espace avant le M: Om VerifieMaChaine (" Visa xxMxx-x classe xx.x ") Då MsgBox" bra "Else MsgBox" pass glop "Avsluta om End Sub-funktion VerifieMaChaine (uttryck som sträng) Som booleskt Dim Reg som Objekt Set reg = CreateObject (" vbscript.regexp ")" Det finns enklare exempel, men den här är den mest kompletta reg.Pattern = "(^ Vis) () ([a-zA-Z] {1, 3}) () (M) ([a-zA-Z] {1, 2} ) (-) ([a-zA-Z] {1, 3}) (classe) ([a-zA-Z] {1, 2}) (.) ([a-zA-Z] {1}) "VerifieMaChaine = reg.test (uttryck) Slutfunktion Slut Sub