Ankers in reguliere expressies

Ankers, of atomische asserties met nul breedte, geven een positie op in de tekenreeks waar een overeenkomst moet plaatsvinden. Wanneer u een anker in uw zoekexpressie gebruikt, gaat de reguliere expressie-engine niet verder door de tekenreeks of verbruikt de tekens; er wordt alleen gezocht naar een overeenkomst op de opgegeven positie. Hiermee geeft u bijvoorbeeld ^ op dat de overeenkomst moet beginnen aan het begin van een regel of tekenreeks. De reguliere expressie ^http: komt daarom alleen overeen met http:wanneer deze zich aan het begin van een regel voordoet. De volgende tabel bevat de ankers die worden ondersteund door de reguliere expressies in .NET.

Anker	Beschrijving
^	Standaard moet de overeenkomst plaatsvinden aan het begin van de tekenreeks; in de modus met meerdere regels moet deze plaatsvinden aan het begin van de regel. Zie Begin van tekenreeks of lijn voor meer informatie.
$	Standaard moet de overeenkomst plaatsvinden aan het einde van de tekenreeks of vóór \n aan het einde van de tekenreeks. In de modus met meerdere regels moet deze plaatsvinden aan het einde van de regel of vóór \n aan het einde van de regel. Zie Einde van tekenreeks of lijn voor meer informatie.
\A	De overeenkomst moet alleen aan het begin van de tekenreeks voorkomen (geen ondersteuning voor meerdere regels). Zie Alleen begin van tekenreeks voor meer informatie.
\Z	De overeenkomst moet plaatsvinden aan het einde van de tekenreeks of vóór \n aan het einde van de tekenreeks. Zie Einde tekenreeks of Voordat u nieuwe regel beëindigt voor meer informatie.
\z	De overeenkomst moet alleen aan het einde van de tekenreeks plaatsvinden. Zie Alleen einde tekenreeks voor meer informatie.
\G	De overeenkomst moet beginnen op de positie waar de vorige overeenkomst is geëindigd, of als er geen vorige overeenkomst was, op de positie in de tekenreeks waar overeenkomend is begonnen. Zie Aaneengesloten overeenkomsten voor meer informatie.
\b	De overeenkomst moet plaatsvinden op een woordgrens. Zie Word Boundary voor meer informatie.
\B	De overeenkomst mag niet plaatsvinden op een woordgrens. Zie Niet-Woordgrens voor meer informatie.

Begin van tekenreeks of lijn: ^

Standaard geeft het ^ anker aan dat het volgende patroon moet beginnen op de eerste tekenpositie van de tekenreeks. Als u de optie gebruikt ^ (zie Opties voor reguliere expressie), moet de overeenkomst plaatsvinden aan het begin van elke RegexOptions.Multiline regel.

In het volgende voorbeeld wordt het ^ anker gebruikt in een reguliere expressie waarmee informatie wordt geëxtraheerd over de jaren waarin sommige professionele honkbalteams bestonden. In het voorbeeld worden twee overbelastingen van de Regex.Matches methode aangeroepen:

• De aanroep naar de Matches(String, String) overbelasting vindt alleen de eerste subtekenreeks in de invoertekenreeks die overeenkomt met het reguliere expressiepatroon.

• De aanroep van de Matches(String, String, RegexOptions) overbelasting met de options parameterset om alle vijf subtekenreeksen te RegexOptions.Multiline vinden.

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        string input = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957\n" +
                     "Chicago Cubs, National League, 1903-present\n" +
                     "Detroit Tigers, American League, 1901-present\n" +
                     "New York Giants, National League, 1885-1957\n" +
                     "Washington Senators, American League, 1901-1960\n";
        string pattern = @"^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+";
        Match match;

        match = Regex.Match(input, pattern);
        while (match.Success)
        {
            Console.Write("The {0} played in the {1} in",
                              match.Groups[1].Value, match.Groups[4].Value);
            foreach (Capture capture in match.Groups[5].Captures)
                Console.Write(capture.Value);

            Console.WriteLine(".");
            match = match.NextMatch();
        }
        Console.WriteLine();

        match = Regex.Match(input, pattern, RegexOptions.Multiline);
        while (match.Success)
        {
            Console.Write("The {0} played in the {1} in",
                              match.Groups[1].Value, match.Groups[4].Value);
            foreach (Capture capture in match.Groups[5].Captures)
                Console.Write(capture.Value);

            Console.WriteLine(".");
            match = match.NextMatch();
        }
        Console.WriteLine();
    }
}
// The example displays the following output:
//    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
//
//    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
//    The Chicago Cubs played in the National League in 1903-present.
//    The Detroit Tigers played in the American League in 1901-present.
//    The New York Giants played in the National League in 1885-1957.
//    The Washington Senators played in the American League in 1901-1960.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957" + vbCrLf +
                              "Chicago Cubs, National League, 1903-present" + vbCrLf +
                              "Detroit Tigers, American League, 1901-present" + vbCrLf +
                              "New York Giants, National League, 1885-1957" + vbCrLf +
                              "Washington Senators, American League, 1901-1960" + vbCrLf

        Dim pattern As String = "^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+"
        Dim match As Match

        match = Regex.Match(input, pattern)
        Do While match.Success
            Console.Write("The {0} played in the {1} in",
                              match.Groups(1).Value, match.Groups(4).Value)
            For Each capture As Capture In match.Groups(5).Captures
                Console.Write(capture.Value)
            Next
            Console.WriteLine(".")
            match = match.NextMatch()
        Loop
        Console.WriteLine()

        match = Regex.Match(input, pattern, RegexOptions.Multiline)
        Do While match.Success
            Console.Write("The {0} played in the {1} in",
                              match.Groups(1).Value, match.Groups(4).Value)
            For Each capture As Capture In match.Groups(5).Captures
                Console.Write(capture.Value)
            Next
            Console.WriteLine(".")
            match = match.NextMatch()
        Loop
        Console.WriteLine()
    End Sub
End Module
' The example displays the following output:
'    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
'    
'    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
'    The Chicago Cubs played in the National League in 1903-present.
'    The Detroit Tigers played in the American League in 1901-present.
'    The New York Giants played in the National League in 1885-1957.
'    The Washington Senators played in the American League in 1901-1960.

Het reguliere expressiepatroon ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+ wordt gedefinieerd zoals wordt weergegeven in de volgende tabel.

Patroon	Beschrijving
^	Begin de overeenkomst aan het begin van de invoertekenreeks (of het begin van de regel als de methode wordt aangeroepen met de RegexOptions.Multiline optie).
((\w+(\s?)){2,}	Kom overeen met een of meer woordtekens gevolgd door nul of door één spatie ten minste twee keer. Dit is de eerste opnamegroep. Deze expressie definieert ook een tweede en derde vastleggende groep: De tweede bestaat uit het vastgelegde woord en de derde bestaat uit de vastgelegde witruimte.
,\s	Overeenkomst met een komma gevolgd door een spatieteken.
(\w+\s\w+)	Komt overeen met een of meer woordtekens gevolgd door een spatie, gevolgd door een of meer woordtekens. Dit is de vierde opnamegroep.
,	Komma's overeen.
\s\d{4}	Komt overeen met een spatie gevolgd door vier decimalen.
(-(\d{4}|present))?	Kom overeen met nul of één exemplaar van een afbreekstreepje, gevolgd door vier decimalen of de tekenreeks 'aanwezig'. Dit is de zesde vastleggende groep. Het bevat ook een zevende vastleggende groep.
,?	Kom overeen met nul of één exemplaar van een komma.
(\s\d{4}(-(\d{4}|present))?,?)+	Komt overeen met een of meer exemplaren van het volgende: een spatie, vier decimalen, nul of één exemplaar van een afbreekstreepje, gevolgd door vier decimale cijfers of de tekenreeks 'aanwezig', en nul of één komma. Dit is de vijfde vastleggende groep.

Einde van tekenreeks of lijn: $

Het $ anker geeft aan dat het voorgaande patroon moet plaatsvinden aan het einde van de invoertekenreeks of vóór \n aan het einde van de invoertekenreeks.

Als u deze RegexOptions.Multiline optie gebruikt$, kan de overeenkomst ook aan het einde van een regel voorkomen. Houd er rekening mee dat $ is voldaan aan maar niet aan \n\r\n (de combinatie van regelterugloop en nieuwelijntekens, of CR/LF). Als u de combinatie van CR/LF-tekens wilt verwerken, neemt u deze op \r?$ in het reguliere expressiepatroon. Houd er rekening mee dat \r?$ deze in \r de overeenkomst worden opgenomen.

In het volgende voorbeeld wordt het $ anker toegevoegd aan het reguliere expressiepatroon dat wordt gebruikt in het voorbeeld in de sectie Begin van tekenreeks of lijn . Bij gebruik met de oorspronkelijke invoertekenreeks, die vijf regels tekst bevat, kan de Regex.Matches(String, String) methode geen overeenkomst vinden, omdat het einde van de eerste regel niet overeenkomt met het $ patroon. Wanneer de oorspronkelijke invoertekenreeks wordt gesplitst in een tekenreeksmatrix, slaagt de Regex.Matches(String, String) methode erin om elk van de vijf regels te vergelijken. Wanneer de Regex.Matches(String, String, RegexOptions) methode wordt aangeroepen met de options parameter die is ingesteld op RegexOptions.Multiline, worden er geen overeenkomsten gevonden omdat het reguliere expressiepatroon geen rekening houdt met het regelterugloopteken \r. Wanneer het patroon van de reguliere expressie echter wordt gewijzigd door te vervangen \r?$$ door de methode aan te roepen Regex.Matches(String, String, RegexOptions) met de options parameter die is ingesteld om nogmaals vijf overeenkomsten te RegexOptions.Multiline vinden.

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        string cr = Environment.NewLine;
        string input = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957" + cr +
                       "Chicago Cubs, National League, 1903-present" + cr +
                       "Detroit Tigers, American League, 1901-present" + cr +
                       "New York Giants, National League, 1885-1957" + cr +
                       "Washington Senators, American League, 1901-1960" + cr;
        Match match;

        string basePattern = @"^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+";
        string pattern = basePattern + "$";
        Console.WriteLine("Attempting to match the entire input string:");
        match = Regex.Match(input, pattern);
        while (match.Success)
        {
            Console.Write("The {0} played in the {1} in",
                              match.Groups[1].Value, match.Groups[4].Value);
            foreach (Capture capture in match.Groups[5].Captures)
                Console.Write(capture.Value);

            Console.WriteLine(".");
            match = match.NextMatch();
        }
        Console.WriteLine();

        string[] teams = input.Split(new String[] { cr }, StringSplitOptions.RemoveEmptyEntries);
        Console.WriteLine("Attempting to match each element in a string array:");
        foreach (string team in teams)
        {
            match = Regex.Match(team, pattern);
            if (match.Success)
            {
                Console.Write("The {0} played in the {1} in",
                              match.Groups[1].Value, match.Groups[4].Value);
                foreach (Capture capture in match.Groups[5].Captures)
                    Console.Write(capture.Value);
                Console.WriteLine(".");
            }
        }
        Console.WriteLine();

        Console.WriteLine("Attempting to match each line of an input string with '$':");
        match = Regex.Match(input, pattern, RegexOptions.Multiline);
        while (match.Success)
        {
            Console.Write("The {0} played in the {1} in",
                              match.Groups[1].Value, match.Groups[4].Value);
            foreach (Capture capture in match.Groups[5].Captures)
                Console.Write(capture.Value);

            Console.WriteLine(".");
            match = match.NextMatch();
        }
        Console.WriteLine();

        pattern = basePattern + "\r?$";
        Console.WriteLine(@"Attempting to match each line of an input string with '\r?$':");
        match = Regex.Match(input, pattern, RegexOptions.Multiline);
        while (match.Success)
        {
            Console.Write("The {0} played in the {1} in",
                              match.Groups[1].Value, match.Groups[4].Value);
            foreach (Capture capture in match.Groups[5].Captures)
                Console.Write(capture.Value);

            Console.WriteLine(".");
            match = match.NextMatch();
        }
        Console.WriteLine();
    }
}
// The example displays the following output:
//    Attempting to match the entire input string:
//
//    Attempting to match each element in a string array:
//    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
//    The Chicago Cubs played in the National League in 1903-present.
//    The Detroit Tigers played in the American League in 1901-present.
//    The New York Giants played in the National League in 1885-1957.
//    The Washington Senators played in the American League in 1901-1960.
//
//    Attempting to match each line of an input string with '$':
//
//    Attempting to match each line of an input string with '\r?$':
//    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
//    The Chicago Cubs played in the National League in 1903-present.
//    The Detroit Tigers played in the American League in 1901-present.
//    The New York Giants played in the National League in 1885-1957.
//    The Washington Senators played in the American League in 1901-1960.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957" + vbCrLf +
                              "Chicago Cubs, National League, 1903-present" + vbCrLf +
                              "Detroit Tigers, American League, 1901-present" + vbCrLf +
                              "New York Giants, National League, 1885-1957" + vbCrLf +
                              "Washington Senators, American League, 1901-1960" + vbCrLf

        Dim basePattern As String = "^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+"
        Dim match As Match

        Dim pattern As String = basePattern + "$"
        Console.WriteLine("Attempting to match the entire input string:")
        match = Regex.Match(input, pattern)
        Do While match.Success
            Console.Write("The {0} played in the {1} in",
                              match.Groups(1).Value, match.Groups(4).Value)
            For Each capture As Capture In match.Groups(5).Captures
                Console.Write(capture.Value)
            Next
            Console.WriteLine(".")
            match = match.NextMatch()
        Loop
        Console.WriteLine()

        Dim teams() As String = input.Split(New String() {vbCrLf}, StringSplitOptions.RemoveEmptyEntries)
        Console.WriteLine("Attempting to match each element in a string array:")
        For Each team As String In teams
            match = Regex.Match(team, pattern)
            If match.Success Then
                Console.Write("The {0} played in the {1} in",
                               match.Groups(1).Value, match.Groups(4).Value)
                For Each capture As Capture In match.Groups(5).Captures
                    Console.Write(capture.Value)
                Next
                Console.WriteLine(".")
            End If
        Next
        Console.WriteLine()

        Console.WriteLine("Attempting to match each line of an input string with '$':")
        match = Regex.Match(input, pattern, RegexOptions.Multiline)
        Do While match.Success
            Console.Write("The {0} played in the {1} in",
                              match.Groups(1).Value, match.Groups(4).Value)
            For Each capture As Capture In match.Groups(5).Captures
                Console.Write(capture.Value)
            Next
            Console.WriteLine(".")
            match = match.NextMatch()
        Loop
        Console.WriteLine()

        pattern = basePattern + "\r?$"
        Console.WriteLine("Attempting to match each line of an input string with '\r?$':")
        match = Regex.Match(input, pattern, RegexOptions.Multiline)
        Do While match.Success
            Console.Write("The {0} played in the {1} in",
                              match.Groups(1).Value, match.Groups(4).Value)
            For Each capture As Capture In match.Groups(5).Captures
                Console.Write(capture.Value)
            Next
            Console.WriteLine(".")

            match = match.NextMatch()
        Loop
        Console.WriteLine()
    End Sub
End Module
' The example displays the following output:
'    Attempting to match the entire input string:
'    
'    Attempting to match each element in a string array:
'    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
'    The Chicago Cubs played in the National League in 1903-present.
'    The Detroit Tigers played in the American League in 1901-present.
'    The New York Giants played in the National League in 1885-1957.
'    The Washington Senators played in the American League in 1901-1960.
'    
'    Attempting to match each line of an input string with '$':
'    
'    Attempting to match each line of an input string with '\r?$':
'    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
'    The Chicago Cubs played in the National League in 1903-present.
'    The Detroit Tigers played in the American League in 1901-present.
'    The New York Giants played in the National League in 1885-1957.
'    The Washington Senators played in the American League in 1901-1960.

Alleen begin van tekenreeks: \A

Het \A anker geeft aan dat een overeenkomst moet plaatsvinden aan het begin van de invoertekenreeks. Het is identiek aan het ^ anker, behalve dat \A de RegexOptions.Multiline optie wordt genegeerd. Daarom kan deze alleen overeenkomen met het begin van de eerste regel in een invoerreeks met meerdere regels.

Het volgende voorbeeld is vergelijkbaar met de voorbeelden voor de ^ en $ ankers. Het gebruikt het \A anker in een reguliere expressie die informatie ophaalt over de jaren waarin sommige professionele honkbalteams bestonden. De invoerreeks bevat vijf regels. De aanroep van de Regex.Matches(String, String, RegexOptions) methode vindt alleen de eerste subtekenreeks in de invoertekenreeks die overeenkomt met het reguliere expressiepatroon. Zoals in het voorbeeld wordt weergegeven, heeft de Multiline optie geen effect.

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        string input = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957\n" +
                       "Chicago Cubs, National League, 1903-present\n" +
                       "Detroit Tigers, American League, 1901-present\n" +
                       "New York Giants, National League, 1885-1957\n" +
                       "Washington Senators, American League, 1901-1960\n";

        string pattern = @"\A((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+";

        Match match = Regex.Match(input, pattern, RegexOptions.Multiline);
        while (match.Success)
        {
            Console.Write("The {0} played in the {1} in",
                              match.Groups[1].Value, match.Groups[4].Value);
            foreach (Capture capture in match.Groups[5].Captures)
                Console.Write(capture.Value);

            Console.WriteLine(".");
            match = match.NextMatch();
        }
        Console.WriteLine();
    }
}
// The example displays the following output:
//    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957" + vbCrLf +
                            "Chicago Cubs, National League, 1903-present" + vbCrLf +
                            "Detroit Tigers, American League, 1901-present" + vbCrLf +
                            "New York Giants, National League, 1885-1957" + vbCrLf +
                            "Washington Senators, American League, 1901-1960" + vbCrLf

        Dim pattern As String = "\A((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+"

        Dim match As Match = Regex.Match(input, pattern, RegexOptions.Multiline)
        Do While match.Success
            Console.Write("The {0} played in the {1} in",
                              match.Groups(1).Value, match.Groups(4).Value)
            For Each capture As Capture In match.Groups(5).Captures
                Console.Write(capture.Value)
            Next
            Console.WriteLine(".")
            match = match.NextMatch()
        Loop
        Console.WriteLine()
    End Sub
End Module
' The example displays the following output:
'    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.

Einde van tekenreeks of voor einde van nieuwe regel: \Z

Het \Z anker geeft aan dat een overeenkomst moet plaatsvinden aan het einde van de invoertekenreeks of vóór \n aan het einde van de invoertekenreeks. Het is identiek aan het $ anker, behalve dat \Z de RegexOptions.Multiline optie wordt genegeerd. Daarom kan in een tekenreeks met meerdere regels alleen worden voldaan aan het einde van de laatste regel of aan de laatste regel vóór \n.

Houd er rekening mee dat \Z is voldaan aan \n maar niet tevreden is bij \r\n (de combinatie van CR/LF-tekens). Als u CR/LF wilt behandelen alsof dit het was \n, neemt u dit op \r?\Z in het reguliere expressiepatroon. Houd er rekening mee dat dit het \r deel van de overeenkomst maakt.

In het volgende voorbeeld wordt het \Z anker gebruikt in een reguliere expressie die vergelijkbaar is met het voorbeeld in de sectie Start of String of Line , waarmee informatie wordt geëxtraheerd over de jaren waarin sommige professionele honkbalteams bestonden. De subexpressie \r?\Z in de reguliere expressie ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\Z wordt voldaan aan het einde van een tekenreeks, en ook aan het einde van een tekenreeks die eindigt op \n of \r\n. Als gevolg hiervan komt elk element in de matrix overeen met het reguliere expressiepatroon.

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        string[] inputs = { "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957",
                          "Chicago Cubs, National League, 1903-present" + Environment.NewLine,
                          "Detroit Tigers, American League, 1901-present" + Regex.Unescape(@"\n"),
                          "New York Giants, National League, 1885-1957",
                          "Washington Senators, American League, 1901-1960" + Environment.NewLine};
        string pattern = @"^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\Z";

        foreach (string input in inputs)
        {
            Console.WriteLine(Regex.Escape(input));
            Match match = Regex.Match(input, pattern);
            if (match.Success)
                Console.WriteLine("   Match succeeded.");
            else
                Console.WriteLine("   Match failed.");
        }
    }
}
// The example displays the following output:
//    Brooklyn\ Dodgers,\ National\ League,\ 1911,\ 1912,\ 1932-1957
//       Match succeeded.
//    Chicago\ Cubs,\ National\ League,\ 1903-present\r\n
//       Match succeeded.
//    Detroit\ Tigers,\ American\ League,\ 1901-present\n
//       Match succeeded.
//    New\ York\ Giants,\ National\ League,\ 1885-1957
//       Match succeeded.
//    Washington\ Senators,\ American\ League,\ 1901-1960\r\n
//       Match succeeded.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim inputs() As String = {"Brooklyn Dodgers, National League, 1911, 1912, 1932-1957",
                              "Chicago Cubs, National League, 1903-present" + vbCrLf,
                              "Detroit Tigers, American League, 1901-present" + vbLf,
                              "New York Giants, National League, 1885-1957",
                              "Washington Senators, American League, 1901-1960" + vbCrLf}
        Dim pattern As String = "^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\Z"

        For Each input As String In inputs
            Console.WriteLine(Regex.Escape(input))
            Dim match As Match = Regex.Match(input, pattern)
            If match.Success Then
                Console.WriteLine("   Match succeeded.")
            Else
                Console.WriteLine("   Match failed.")
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'    Brooklyn\ Dodgers,\ National\ League,\ 1911,\ 1912,\ 1932-1957
'       Match succeeded.
'    Chicago\ Cubs,\ National\ League,\ 1903-present\r\n
'       Match succeeded.
'    Detroit\ Tigers,\ American\ League,\ 1901-present\n
'       Match succeeded.
'    New\ York\ Giants,\ National\ League,\ 1885-1957
'       Match succeeded.
'    Washington\ Senators,\ American\ League,\ 1901-1960\r\n
'       Match succeeded.

Alleen einde van tekenreeks: \z

Het \z anker geeft aan dat een overeenkomst moet plaatsvinden aan het einde van de invoertekenreeks. Net als het $ taalelement negeert \z u de RegexOptions.Multiline optie. In tegenstelling tot het \Z taalelement wordt \z niet voldaan door een \n teken aan het einde van een tekenreeks. Daarom kan deze alleen overeenkomen met het einde van de invoertekenreeks.

In het volgende voorbeeld wordt het \z anker gebruikt in een reguliere expressie die anders identiek is aan het voorbeeld in de vorige sectie, waarmee informatie wordt geëxtraheerd over de jaren waarin sommige professionele honkbalteams bestonden. In het voorbeeld wordt geprobeerd om elk van de vijf elementen in een tekenreeksmatrix te vinden met het reguliere expressiepatroon ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\z. Twee van de tekenreeksen eindigen met regelterugloop en regelinvoertekens, één eindigt met een regelinvoerteken en twee eindigend met geen regelterugloop of een regelinvoerteken. Zoals in de uitvoer wordt weergegeven, komen alleen de tekenreeksen zonder regelterugloop of regelinvoerteken overeen met het patroon.

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        string[] inputs = { "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957",
                          "Chicago Cubs, National League, 1903-present" + Environment.NewLine,
                          "Detroit Tigers, American League, 1901-present\n",
                          "New York Giants, National League, 1885-1957",
                          "Washington Senators, American League, 1901-1960" + Environment.NewLine };
        string pattern = @"^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\z";

        foreach (string input in inputs)
        {
            Console.WriteLine(Regex.Escape(input));
            Match match = Regex.Match(input, pattern);
            if (match.Success)
                Console.WriteLine("   Match succeeded.");
            else
                Console.WriteLine("   Match failed.");
        }
    }
}
// The example displays the following output:
//    Brooklyn\ Dodgers,\ National\ League,\ 1911,\ 1912,\ 1932-1957
//       Match succeeded.
//    Chicago\ Cubs,\ National\ League,\ 1903-present\r\n
//       Match failed.
//    Detroit\ Tigers,\ American\ League,\ 1901-present\n
//       Match failed.
//    New\ York\ Giants,\ National\ League,\ 1885-1957
//       Match succeeded.
//    Washington\ Senators,\ American\ League,\ 1901-1960\r\n
//       Match failed.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim inputs() As String = {"Brooklyn Dodgers, National League, 1911, 1912, 1932-1957",
                              "Chicago Cubs, National League, 1903-present" + vbCrLf,
                              "Detroit Tigers, American League, 1901-present" + vbLf,
                              "New York Giants, National League, 1885-1957",
                              "Washington Senators, American League, 1901-1960" + vbCrLf}
        Dim pattern As String = "^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\z"

        For Each input As String In inputs
            Console.WriteLine(Regex.Escape(input))
            Dim match As Match = Regex.Match(input, pattern)
            If match.Success Then
                Console.WriteLine("   Match succeeded.")
            Else
                Console.WriteLine("   Match failed.")
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'    Brooklyn\ Dodgers,\ National\ League,\ 1911,\ 1912,\ 1932-1957
'       Match succeeded.
'    Chicago\ Cubs,\ National\ League,\ 1903-present\r\n
'       Match failed.
'    Detroit\ Tigers,\ American\ League,\ 1901-present\n
'       Match failed.
'    New\ York\ Giants,\ National\ League,\ 1885-1957
'       Match succeeded.
'    Washington\ Senators,\ American\ League,\ 1901-1960\r\n
'       Match failed.

Aaneengesloten overeenkomsten: \G

Het \G anker geeft aan dat er een overeenkomst moet plaatsvinden op het punt waar de vorige overeenkomst is geëindigd, of als er geen vorige overeenkomst is, op de positie in de tekenreeks waar overeenkomende is begonnen. Wanneer u dit anker met de Regex.Matches of Match.NextMatch methode gebruikt, zorgt dit ervoor dat alle overeenkomsten aaneengesloten zijn.

Tip

Meestal plaatst u een \G anker aan het linkerkant van uw patroon. In het zeldzame geval dat u een rechts-naar-links zoekopdracht uitvoert, plaatst u het \G anker aan de rechterkant van uw patroon.

In het volgende voorbeeld wordt een reguliere expressie gebruikt om de namen van knaagdieren uit een door komma's gescheiden tekenreeks te extraheren.

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        string input = "capybara,squirrel,chipmunk,porcupine,gopher," +
                       "beaver,groundhog,hamster,guinea pig,gerbil," +
                       "chinchilla,prairie dog,mouse,rat";
        string pattern = @"\G(\w+\s?\w*),?";
        Match match = Regex.Match(input, pattern);
        while (match.Success)
        {
            Console.WriteLine(match.Groups[1].Value);
            match = match.NextMatch();
        }
    }
}
// The example displays the following output:
//       capybara
//       squirrel
//       chipmunk
//       porcupine
//       gopher
//       beaver
//       groundhog
//       hamster
//       guinea pig
//       gerbil
//       chinchilla
//       prairie dog
//       mouse
//       rat

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "capybara,squirrel,chipmunk,porcupine,gopher," +
                              "beaver,groundhog,hamster,guinea pig,gerbil," +
                              "chinchilla,prairie dog,mouse,rat"
        Dim pattern As String = "\G(\w+\s?\w*),?"
        Dim match As Match = Regex.Match(input, pattern)
        Do While match.Success
            Console.WriteLine(match.Groups(1).Value)
            match = match.NextMatch()
        Loop
    End Sub
End Module
' The example displays the following output:
'       capybara
'       squirrel
'       chipmunk
'       porcupine
'       gopher
'       beaver
'       groundhog
'       hamster
'       guinea pig
'       gerbil
'       chinchilla
'       prairie dog
'       mouse
'       rat

De reguliere expressie \G(\w+\s?\w*),? wordt geïnterpreteerd zoals weergegeven in de volgende tabel.

Patroon	Beschrijving
\G	Begin waar de laatste wedstrijd is geëindigd.
\w+	Komt overeen met een of meer woordtekens.
\s?	Kom overeen met nul of één spatie.
\w*	Kom overeen met nul of meer woordtekens.
(\w+\s?\w*)	Komt overeen met een of meer woordtekens gevolgd door nul of één spatie, gevolgd door nul of meer woordtekens. Dit is de eerste opnamegroep.
,?	Kom overeen met nul of één exemplaar van een letterlijk kommateken.

Woordgrens: \b

Het \b anker geeft aan dat de overeenkomst moet plaatsvinden op een grens tussen een woordteken (het \w taalelement) en een niet-woordteken (het \W taalelement). Woordtekens bestaan uit alfanumerieke tekens en onderstrepingstekens; een niet-woordteken is een teken dat geen alfanumeriek of een onderstrepingsteken is. (Zie voor meer informatie Tekenklassen.) De overeenkomst kan ook optreden op een woordgrens aan het begin of einde van de tekenreeks.

Het \b anker wordt vaak gebruikt om ervoor te zorgen dat een subexpressie overeenkomt met een heel woord in plaats van alleen het begin of einde van een woord. De reguliere expressie \bare\w*\b in het volgende voorbeeld illustreert dit gebruik. Het komt overeen met elk woord dat begint met de subtekenreeks 'are'. De uitvoer uit het voorbeeld illustreert ook dat \b overeenkomt met zowel het begin als het einde van de invoertekenreeks.

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        string input = "area bare arena mare";
        string pattern = @"\bare\w*\b";
        Console.WriteLine("Words that begin with 'are':");
        foreach (Match match in Regex.Matches(input, pattern))
            Console.WriteLine("'{0}' found at position {1}",
                              match.Value, match.Index);
    }
}
// The example displays the following output:
//       Words that begin with 'are':
//       'area' found at position 0
//       'arena' found at position 10

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "area bare arena mare"
        Dim pattern As String = "\bare\w*\b"
        Console.WriteLine("Words that begin with 'are':")
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("'{0}' found at position {1}",
                              match.Value, match.Index)
        Next
    End Sub
End Module
' The example displays the following output:
'       Words that begin with 'are':
'       'area' found at position 0
'       'arena' found at position 10

Het patroon voor reguliere expressies wordt geïnterpreteerd zoals wordt weergegeven in de volgende tabel.

Patroon	Beschrijving
\b	Begin de overeenkomst bij een woordgrens.
are	Komt overeen met de subtekenreeks 'are'.
\w*	Kom overeen met nul of meer woordtekens.
\b	Beëindig de overeenkomst op een woordgrens.

Niet-Woordgrens: \B

Het \B anker geeft aan dat de overeenkomst niet op een woordgrens mag plaatsvinden. Het is het tegenovergestelde van het \b anker.

In het volgende voorbeeld wordt het \B anker gebruikt om exemplaren van de subtekenreeks 'qu' in een woord te vinden. Het reguliere expressiepatroon \Bqu\w+ komt overeen met een subtekenreeks die begint met een 'qu' die geen woord start en dat verdergaat met het einde van het woord.

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        string input = "equity queen equip acquaint quiet";
        string pattern = @"\Bqu\w+";
        foreach (Match match in Regex.Matches(input, pattern))
            Console.WriteLine("'{0}' found at position {1}",
                              match.Value, match.Index);
    }
}
// The example displays the following output:
//       'quity' found at position 1
//       'quip' found at position 14
//       'quaint' found at position 21

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "equity queen equip acquaint quiet"
        Dim pattern As String = "\Bqu\w+"
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("'{0}' found at position {1}",
                              match.Value, match.Index)
        Next
    End Sub
End Module
' The example displays the following output:
'       'quity' found at position 1
'       'quip' found at position 14
'       'quaint' found at position 21

Het patroon voor reguliere expressies wordt geïnterpreteerd zoals wordt weergegeven in de volgende tabel.

Patroon	Beschrijving
\B	Begin niet met de overeenkomst bij een woordgrens.
qu	Komt overeen met de subtekenreeks qu.
\w+	Komt overeen met een of meer woordtekens.

Zie ook

• Reguliere expressietaal - Snelzoekgids
• Opties voor reguliere expressies