Visual Basic 2012 Voorbeelden
   

visual basic 2012 broncode voorbeelden

Blijf op de hoogte van de recente aanpassingen op vbvoorbeelden!

Microsoft Visual Studio 2012Microsoft Developers Network - Visual BasicMicrosoft .NET Framework

28.1. Regular Expressions - Inleiding

Print Email Deel op Twitter Deel op Facebook

Dit artikel is gepubliceerd op maandag 15 oktober 2012 op vbvoorbeelden, bezoek de website voor een recente versie van dit artikel of andere artikels.

Patterns in reguliere expressies worden onder andere opgesteld aan de hand van een reeks van karakters, "quantifiers" en "positional assertions".
De karakters kunnen specifiek verwijzen naar de karakters die men wenst op te zoeken ("literal characters") of kunnen via het gebruik van "meta characters" een bepaald soort van karakter voorstellen.
Quantifiers duiden aan hoeveel karakters men verwacht en positional assertions geven aan waar men bepaalde karakters verwacht.

28.1.1. Regex en Match

Een eenvoudig voorbeeld vind je hieronder.  Er wordt op zoek gegaan naar alle telefoonnummers in een bepaalde tekst.

Een getal kan worden voorgesteld aan de hand van de shorthand character class \d.
Visual Basic 2012 Broncode - Codevoorbeeld 695
Imports System.Text.RegularExpressions
Class Example1
    Public Shared Sub Main()
        Dim sentence, mobilePattern As String
        sentence = "My home number is 0123/45.67.89, " & _
                   "my office number is 0123/56.78.90."
        mobilePattern = "\d\d\d\d/\d\d\.\d\d\.\d\d"
        '
        Console.WriteLine(Regex.IsMatch(sentence, mobilePattern)) ' True
        '
        Dim firstMatch As Match = Regex.Match(sentence, mobilePattern)
        If firstMatch.Success Then
            Console.WriteLine(firstMatch.Value)                  ' 0123/45.67.89
            Console.WriteLine(firstMatch.ToString())             ' 0123/45.67.89
            Console.WriteLine(firstMatch.Length)                 ' 13
            Console.WriteLine(firstMatch.Index)                  ' 18
        End If
        '
        Dim nextMatch As Match = firstMatch.NextMatch()
        Console.WriteLine(nextMatch.Index)                       ' 53
        '
        Console.ReadLine()
    End Sub
End Class
Console Application Output
True
0123/45.67.89
0123/45.67.89
13
18
53
Bovenstaand voorbeeld maakt gebruik van de Regex en Match klassen uit de System.Text.RegularExpressions namespace.

De shared method IsMatch kan gebruikt worden om na te gaan of een bepaald pattern wordt gevonden in een bepaalde tekst.

Shared method Match levert een Match object op, die bruikbaar is om informatie over de gevonden substring op te halen.  Zo kan de Succes property geraadpleegd worden om te zien of er wel een substring werd gevonden.  Value levert net als ToString de gevonden substring op.  De Length property vertelt ons hoe lang de gevonden substring is, en Index levert ons de startpositie van de gevonden substring.
Property NextMatch levert in Match vorm het volgende zoekresultaat op.  Zelfs indien er geen volgende substring werd gevonden, krijgen we een Match object, maar dan zal de Succes property van dit object False opleveren.

In tegenstelling tot deze shared members kan men ook een instantie van het type Regex creëren, om via een instance method Match het zoekresultaat op te vragen :
Visual Basic 2012 Broncode - Codevoorbeeld 696
Imports System.Text.RegularExpressions
Class Example2
    Public Shared Sub Main()
        Dim sentence, mobilePattern As String
        sentence = "My home number is 0123/45.67.89, " & _
                   "my office number is 0123/56.78.90."
        mobilePattern = "\d\d\d\d/\d\d\.\d\d\.\d\d"
        '
        Dim mobileRegex As Regex = New Regex(mobilePattern)
        Dim firstMatch As Match = mobileRegex.Match(sentence)
        Console.WriteLine(firstMatch.Index)                                 ' 18
        '
        Console.ReadLine()
    End Sub
End Class
Console Application Output
18
Het gebruik van de instance methods van een Regex object, in tegenstelling tot het gebruik van de shared methods van Regex, codeert iets makkelijker wanneer men verschillende malen via hetzelfde pattern op zoek gaat.
Wanneer men echter veel verschillende reguliere expressies herhaaldelijk gaat gebruiken, kan het instantiëren en opnieuw vrijgeven van de verschillende Regex object die hiervoor worden gemaakt, natuurlijk voor een performance overhead zorgen.  In dat geval kan men beter de shared methods gebruiken.

Dit opgeleverde Match object kan op dezelfde manier als in het eerste voorbeeld gebruikt worden om informatie over het zoekresultaat op te vragen.

Een eenvoudige manier om alle "matches" van een bepaalde reguliere expressie op te vragen is het gebruik van de Matches method.  Deze levert in MatchCollection vorm een verzameling van alle gevonden zoekresultaten op :
Visual Basic 2012 Broncode - Codevoorbeeld 697
Imports System.Text.RegularExpressions
Class Example3
    Public Shared Sub Main()
        Dim sentence, mobilePattern As String
        sentence = "My home number is 0123/45.67.89, " & _
                   "my office number is 0123/56.78.90."
        mobilePattern = "\d\d\d\d/\d\d\.\d\d\.\d\d"
        '
        Dim mobileRegex As Regex = New Regex(mobilePattern)
        Dim allMatches As MatchCollection = mobileRegex.Matches(sentence)
        For Each match As Match In allMatches
            Console.WriteLine(match.Value)
        Next
        '
        Console.ReadLine()
    End Sub
End Class
Console Application Output
0123/45.67.89
0123/56.78.90
Ook van deze Matches method bestaat een shared variant.

Door haakjes in het pattern te gebruiken creëert men onderdelen ("capture groups" genoemd) in een zoekresultaat, deze kan men ophalen uit het zoekresultaat indien men in deze informatie is geïntresseerd :
Visual Basic 2012 Broncode - Codevoorbeeld 698
Imports System.Text.RegularExpressions
Class Example4
    Public Shared Sub Main()
        Dim sentence, mobilePattern As String
        sentence = "My home number is 0123/45.67.89, " & _
                   "my office number is 0123/56.78.90."
        mobilePattern = "(\d\d\d\d)/(\d\d\.\d\d\.\d\d)"
        '
        Dim mobileRegex As Regex = New Regex(mobilePattern)
        Dim allMatches As MatchCollection = mobileRegex.Matches(sentence)
        For Each match As Match In allMatches
            Console.WriteLine("Match " & match.Value & " : ")
            Dim groups As GroupCollection = match.Groups
            For Each group As Group In groups
                Console.WriteLine("- group " & group.Value & " at index " & group.Index)
            Next
            Console.WriteLine()
        Next
        '
        Console.ReadLine()
    End Sub
End Class
Console Application Output
Match 0123/45.67.89 :
- group 0123/45.67.89 at index 18
- group 0123 at index 18
- group 45.67.89 at index 23

Match 0123/56.78.90 :
- group 0123/56.78.90 at index 53
- group 0123 at index 53
- group 56.78.90 at index 58
Bemerkt hoe ook het volledige pattern als een group wordt beschouwd (de eerste group).

In het pattern kan men een naam geven aan elke group.  Dit doe je door tussen haakjes te beginnen met een ?, deze te laten volgen met <, daarna de naam van de group en als laatste >.

Stel dat we enkel geïntresseerd zijn in de prefixes van de telefoonnummers, dan kunnen we als volgt te werk gaan :
Visual Basic 2012 Broncode - Codevoorbeeld 699
Imports System.Text.RegularExpressions
Class Example5
    Public Shared Sub Main()
        Dim sentence, mobilePattern As String
        sentence = "My home number is 0123/45.67.89, " & _
                   "my office number is 0124/56.78.90."
        mobilePattern = "(?<prefix>\d\d\d\d)/\d\d\.\d\d\.\d\d"
        '
        For Each match As Match In Regex.Matches(sentence, mobilePattern)
            Dim groups As GroupCollection = match.Groups
            Dim prefixGroup As Group = groups.Item("prefix")
            Console.WriteLine(prefixGroup.Value)
        Next
        '
        Console.ReadLine()
    End Sub
End Class
Console Application Output
0123
0124
Ter illustratie werd hier gewerkt met de shared method Matches uit de Regex klasse.

De Item method van een GroupCollection object kan gebruikt worden om via een index of via de naam een Group object op te halen.

In de volgende topics meer informatie over groups.

Dit artikel is gepubliceerd op maandag 15 oktober 2012 op vbvoorbeelden, bezoek de website voor een recente versie van dit artikel of andere artikels.