Delen via

Tekenklassen in reguliere expressies

  • Artikel

Een tekenklasse definieert een set tekens, waarvan elke tekens kan optreden in een invoertekenreeks om een overeenkomst te laten slagen. De reguliere expressietaal in .NET ondersteunt de volgende tekenklassen:

  • Positieve tekengroepen. Een teken in de invoertekenreeks moet overeenkomen met een van een opgegeven set tekens. Zie Groep met positieve tekens voor meer informatie.

  • Negatieve tekengroepen. Een teken in de invoertekenreeks mag niet overeenkomen met een van een opgegeven set tekens. Zie Negatieve tekengroep voor meer informatie.

  • Elk teken. Het . teken (punt of punt) in een reguliere expressie is een jokerteken dat overeenkomt met een willekeurig teken, behalve \n. Zie Any Character voor meer informatie.

  • Een algemene Unicode-categorie of benoemd blok. Een teken in de invoertekenreeks moet lid zijn van een bepaalde Unicode-categorie of moet binnen een aaneengesloten bereik van Unicode-tekens vallen om een overeenkomst te laten slagen. Zie Unicode-categorie of Unicode-blok voor meer informatie.

  • Een negatieve algemene Unicode-categorie of benoemd blok. Een teken in de invoertekenreeks mag geen lid zijn van een bepaalde Unicode-categorie of mag niet binnen een aaneengesloten bereik van Unicode-tekens vallen om een overeenkomst te laten slagen. Zie Negatieve Unicode-categorie of Unicode-blok voor meer informatie.

  • Een woordteken. Een teken in de invoertekenreeks kan behoren tot een van de Unicode-categorieën die geschikt zijn voor tekens in woorden. Zie Word-teken voor meer informatie.

  • Een niet-woordteken. Een teken in de invoertekenreeks kan behoren tot een Unicode-categorie die geen woordteken is. Zie Niet-Word-teken voor meer informatie.

  • Een spatieteken. Een teken in de invoertekenreeks kan elk Unicode-scheidingsteken zijn, evenals een van een van de besturingstekens. Zie Spatieteken voor meer informatie.

  • Een niet-wit spatieteken. Een teken in de invoertekenreeks kan elk teken zijn dat geen witruimteteken is. Zie Niet-spatieteken voor meer informatie.

  • Een decimaal getal. Een teken in de invoertekenreeks kan een willekeurig aantal tekens zijn dat is geclassificeerd als Unicode-decimale cijfers. Zie Het teken decimale cijfers voor meer informatie.

  • Een niet-decimaal getal. Een teken in de invoertekenreeks kan iets anders zijn dan een Unicode-decimaal cijfer. Zie Het teken decimale cijfers voor meer informatie.

.NET ondersteunt aftrekken van tekenklasse-expressies, waarmee u een set tekens kunt definiëren als gevolg van het uitsluiten van een tekenklasse uit een andere tekenklasse. Zie Aftrekken van tekenklasse voor meer informatie.

Notitie

Tekenklassen die overeenkomen met tekens per categorie, zoals \w die overeenkomen met woordtekens of \p{} om overeen te komen met een Unicode-categorie, zijn afhankelijk van de CharUnicodeInfo klasse om informatie over tekencategorieën op te geven. In .NET Framework 4.6.2 en latere versies zijn tekencategorieën gebaseerd op de Unicode-standaard, versie 8.0.0.

Positieve tekengroep: [ ]

Een positieve tekengroep geeft een lijst met tekens op, waarvan een kan worden weergegeven in een invoertekenreeks om een overeenkomst te laten plaatsvinden. Deze lijst met tekens kan afzonderlijk worden opgegeven, als een bereik of beide.

De syntaxis voor het opgeven van een lijst met afzonderlijke tekens is als volgt:

[*character_group*]

waarbij character_group een lijst is van de afzonderlijke tekens die in de invoertekenreeks kunnen worden weergegeven om een overeenkomst te voltooien. character_group kan bestaan uit een combinatie van een of meer letterlijke tekens, escape-tekens of tekenklassen.

De syntaxis voor het opgeven van een reeks tekens is als volgt:

[firstCharacter-lastCharacter]

waarbij firstCharacter het teken is dat het bereik begint en lastCharacter het teken is dat het bereik beëindigt. Een tekenbereik is een aaneengesloten reeks tekens die zijn gedefinieerd door het eerste teken in de reeks, een afbreekstreepje (-) en vervolgens het laatste teken in de reeks op te geven. Twee tekens zijn aaneengesloten als ze aangrenzende Unicode-codepunten hebben. firstCharacter moet het teken met het onderste codepunt zijn en lastCharacter moet het teken met het hogere codepunt zijn.

Notitie

Omdat een positieve tekengroep zowel een reeks tekens als een tekenbereik kan bevatten, wordt een afbreekstreepje (-) altijd geïnterpreteerd als het scheidingsteken voor het bereik, tenzij dit het eerste of laatste teken van de groep is.

Als u een afbreekstreepje wilt opnemen als een niet-perifereel lid van een tekengroep, escapet u het. Als u bijvoorbeeld een tekengroep wilt maken voor het teken a en de tekens van - naar /, is [a\--/]de juiste syntaxis.

Enkele veelvoorkomende reguliere expressiepatronen die positieve tekenklassen bevatten, worden vermeld in de volgende tabel.

Patroon Beschrijving
[aeiou] Match alle klinkers.
[\p{P}\d] Kom overeen met alle interpunctie- en decimaaltekens.
[\s\p{P}] Match alle witruimte en leestekens.

In het volgende voorbeeld wordt een positieve tekengroep gedefinieerd die de tekens 'a' en 'e' bevat, zodat de invoertekenreeks de woorden 'grijs' of 'grijs' moet bevatten, gevolgd door een ander woord voor een overeenkomst.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"gr[ae]y\s\S+?[\s\p{P}]";
      string input = "The gray wolf jumped over the grey wall.";
      MatchCollection matches = Regex.Matches(input, pattern);
      foreach (Match match in matches)
         Console.WriteLine($"'{match.Value}'");
   }
}
// The example displays the following output:
//       'gray wolf '
//       'grey wall.'

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "gr[ae]y\s\S+?[\s\p{P}]"
        Dim input As String = "The gray wolf jumped over the grey wall."
        Dim matches As MatchCollection = Regex.Matches(input, pattern)
        For Each match As Match In matches
            Console.WriteLine($"'{match.Value}'")
        Next
    End Sub
End Module
' The example displays the following output:
'       'gray wolf '
'       'grey wall.'

De reguliere expressie gr[ae]y\s\S+?[\s|\p{P}] wordt als volgt gedefinieerd:

Patroon Beschrijving
gr Komt overeen met de letterlijke tekens 'gr'.
[ae] Komt overeen met een 'a' of een 'e'.
y\s Komt overeen met het letterlijke teken 'y' gevolgd door een witruimteteken.
\S+? Komt overeen met een of meer niet-witruimtetekens, maar zo weinig mogelijk.
[\s\p{P}] Komt overeen met een spatieteken of een interpunctieteken.

Het volgende voorbeeld komt overeen met woorden die beginnen met een hoofdletter. De subexpressie [A-Z] wordt gebruikt om het bereik van hoofdletters van A tot Z weer te geven.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[A-Z]\w*\b";
      string input = "A city Albany Zulu maritime Marseilles";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       A
//       Albany
//       Zulu
//       Marseilles

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b[A-Z]\w*\b"
        Dim input As String = "A city Albany Zulu maritime Marseilles"
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Value)
        Next
    End Sub
End Module

De reguliere expressie \b[A-Z]\w*\b wordt gedefinieerd zoals wordt weergegeven in de volgende tabel.

Patroon Beschrijving
\b Begin bij een woordgrens.
[A-Z] Komt overeen met hoofdletters van A tot Z.
\w* Kom overeen met nul of meer woordtekens.
\b Komt overeen met een woordgrens.

Negatieve tekengroep: [^]

Een negatieve tekengroep geeft een lijst met tekens op die niet mogen worden weergegeven in een invoertekenreeks om een overeenkomst te laten plaatsvinden. De lijst met tekens kan afzonderlijk worden opgegeven, als een bereik of beide.

De syntaxis voor het opgeven van een lijst met afzonderlijke tekens is als volgt:

[*^character_group*]

waarbij character_group een lijst is van de afzonderlijke tekens die niet in de invoertekenreeks kunnen worden weergegeven om een overeenkomst te voltooien. character_group kan bestaan uit een combinatie van een of meer letterlijke tekens, escape-tekens of tekenklassen.

De syntaxis voor het opgeven van een reeks tekens is als volgt:

[^*firstCharacter*-*lastCharacter*]

waarbij firstCharacter het teken is dat het bereik begint en lastCharacter het teken is dat het bereik beëindigt. Een tekenbereik is een aaneengesloten reeks tekens die zijn gedefinieerd door het eerste teken in de reeks, een afbreekstreepje (-) en vervolgens het laatste teken in de reeks op te geven. Twee tekens zijn aaneengesloten als ze aangrenzende Unicode-codepunten hebben. firstCharacter moet het teken met het onderste codepunt zijn en lastCharacter moet het teken met het hogere codepunt zijn.

Notitie

Omdat een negatieve tekengroep zowel een set tekens als een tekenbereik kan bevatten, wordt een afbreekstreepje (-) altijd geïnterpreteerd als het scheidingsteken voor het bereik, tenzij dit het eerste of laatste teken van de groep is.

Twee of meer tekenbereiken kunnen worden samengevoegd. Als u bijvoorbeeld het bereik van decimale cijfers van '0' tot en met '9' wilt opgeven, gebruikt [0-9a-fA-F]u het bereik van kleine letters van 'a' tot en met 'f' en het bereik van hoofdletters van 'A' tot en met F.

Het voorloopteken (^) in een groep met negatieve tekens is verplicht en geeft aan dat de tekengroep een negatieve tekengroep is in plaats van een positieve tekengroep.

Belangrijk

Een negatieve tekengroep in een groter patroon voor reguliere expressies is geen assertie met nul breedte. Na het evalueren van de negatieve tekengroep gaat de reguliere expressie-engine één teken in de invoertekenreeks verder.

Enkele veelvoorkomende reguliere expressiepatronen die negatieve tekengroepen bevatten, worden vermeld in de volgende tabel.

Patroon Beschrijving
[^aeiou] Komt overeen met alle tekens behalve klinkers.
[^\p{P}\d] Komt overeen met alle tekens, behalve leestekens en decimale cijfers.

Het volgende voorbeeld komt overeen met een woord dat begint met de tekens 'th' en wordt niet gevolgd door een 'o'.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\bth[^o]\w+\b";
      string input = "thought thing though them through thus thorough this";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       thing
//       them
//       through
//       thus
//       this

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\bth[^o]\w+\b"
        Dim input As String = "thought thing though them through thus " + _
                              "thorough this"
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Value)
        Next
    End Sub
End Module
' The example displays the following output:
'       thing
'       them
'       through
'       thus
'       this

De reguliere expressie \bth[^o]\w+\b wordt gedefinieerd zoals wordt weergegeven in de volgende tabel.

Patroon Beschrijving
\b Begin bij een woordgrens.
th Komt overeen met de letterlijke tekens 'th'.
[^o] Komt overeen met een willekeurig teken dat geen 'o' is.
\w+ Komt overeen met een of meer woordtekens.
\b Eindig bij een woordgrens.

Elk teken: .

Het puntteken (.) komt overeen met elk teken behalve \n (het nieuwe regelteken), met de volgende twee kwalificaties:

  • Als een normaal expressiepatroon wordt gewijzigd door de RegexOptions.Singleline optie, of als het gedeelte van het patroon dat de . tekenklasse bevat, wordt gewijzigd door de s optie, . komt overeen met een willekeurig teken. Zie Opties voor reguliere expressies voor meer informatie.

    In het volgende voorbeeld ziet u het verschillende gedrag van de . tekenklasse standaard en met de RegexOptions.Singleline optie. De reguliere expressie ^.+ begint aan het begin van de tekenreeks en komt overeen met elk teken. De overeenkomst eindigt standaard aan het einde van de eerste regel; het reguliere expressiepatroon komt overeen met het regelterugloopteken, \rmaar komt niet overeen \n. Omdat de RegexOptions.Singleline optie de hele invoertekenreeks als één regel interpreteert, komt deze overeen met elk teken in de invoertekenreeks, inclusief \n.

    using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "^.+";
      string input = "This is one line and" + Environment.NewLine + "this is the second.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(Regex.Escape(match.Value));

      Console.WriteLine();
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Singleline))
         Console.WriteLine(Regex.Escape(match.Value));
   }
}
// The example displays the following output:
//       This\ is\ one\ line\ and\r
//
//       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

    Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "^.+"
        Dim input As String = "This is one line and" + vbCrLf + "this is the second."
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(Regex.Escape(match.Value))
        Next
        Console.WriteLine()
        For Each match As Match In Regex.Matches(input, pattern, RegexOptions.SingleLine)
            Console.WriteLine(Regex.Escape(match.Value))
        Next
    End Sub
End Module
' The example displays the following output:
'       This\ is\ one\ line\ and\r
'       
'       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

Notitie

Omdat deze overeenkomt met een willekeurig teken behalve \n, komt de . tekenklasse ook overeen \r (het regelterugloopteken).

  • In een positieve of negatieve tekengroep wordt een punt beschouwd als een letterlijk puntteken en niet als een tekenklasse. Zie Positieve tekengroep en Negatieve tekengroep eerder in dit onderwerp voor meer informatie. In het volgende voorbeeld ziet u een afbeelding door een reguliere expressie te definiëren met het puntteken (.) zowel als een tekenklasse als als lid van een positieve tekengroep. De reguliere expressie \b.*[.?!;:](\s|\z) begint bij een woordgrens, komt overeen met een willekeurig teken totdat een van de vijf interpunctietekens wordt aantreft, inclusief een punt, en komt vervolgens overeen met een spatieteken of het einde van de tekenreeks.

    using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b.*[.?!;:](\s|\z)";
      string input = "this. what: is? go, thing.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       this. what: is? go, thing.

    Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As STring = "\b.*[.?!;:](\s|\z)"
        Dim input As String = "this. what: is? go, thing."
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Value)
        Next
    End Sub
End Module
' The example displays the following output:
'       this. what: is? go, thing.

Notitie

Omdat het overeenkomt met een willekeurig teken, wordt het . taalelement vaak gebruikt met een luie kwantificator als een patroon voor reguliere expressies meerdere keren probeert overeen te komen met een willekeurig teken. Zie Kwantificatoren voor meer informatie.

Unicode-categorie of Unicode-blok: \p{}

De Unicode-standaard wijst elk teken een algemene categorie toe. Een bepaald teken kan bijvoorbeeld een hoofdletter zijn (vertegenwoordigd door de Lu categorie), een decimaalteken (de Nd categorie), een rekenkundig symbool (de Sm categorie) of een alineascheidingsteken (de Zl categorie). Specifieke tekensets in de Unicode-standaard nemen ook een specifiek bereik of blok opeenvolgende codepunten in beslag. De latijnse basistekenset wordt bijvoorbeeld gevonden uit \u0000 tot en met \u007F, terwijl de Arabische tekenset wordt gevonden van \u0600 tot en met \u06FF.

De reguliere expressie-constructie

\p{naam }

komt overeen met elk teken dat deel uitmaakt van een Unicode-algemene categorie of benoemd blok, waarbij de naam de afkorting van de categorie of de naam van het benoemde blok is. Zie de sectie Ondersteunde algemene unicode-categorieën verderop in dit onderwerp voor een lijst met categorie afkortingen. Zie de sectie Ondersteunde benoemde blokken verderop in dit onderwerp voor een lijst met benoemde blokken.

Tip

De vergelijking kan worden verbeterd als de tekenreeks voor het eerst wordt genormaliseerd door de methode aan te String.Normalize roepen.

In het volgende voorbeeld wordt de \p{naamconstructie} gebruikt om zowel een Algemene Unicode-categorie (in dit geval de Pdcategorie Of Interpunctie, Streepje) als een benoemd blok (de IsGreek en IsBasicLatin benoemde blokken) te vinden.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+";
      string input = "Κατα Μαθθαίον - The Gospel of Matthew";

      Console.WriteLine(Regex.IsMatch(input, pattern));        // Displays True.
   }
}

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+"
        Dim input As String = "Κατα Μαθθαίον - The Gospel of Matthew"

        Console.WriteLine(Regex.IsMatch(input, pattern))         ' Displays True.
    End Sub
End Module

De reguliere expressie \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ wordt gedefinieerd zoals wordt weergegeven in de volgende tabel.

Patroon Beschrijving
\b Begin bij een woordgrens.
\p{IsGreek}+ Komen overeen met een of meer Griekse tekens.
(\s)? Kom overeen met nul of één spatieteken.
(\p{IsGreek}+(\s)?)+ Komt overeen met het patroon van een of meer Griekse tekens gevolgd door nul of één spatieteken één of meer keren.
\p{Pd} Identiek aan een interpunctie, streepjeteken.
\s Overeenkomst met een spatieteken.
\p{IsBasicLatin}+ Komt overeen met een of meer eenvoudige Latijnse tekens.
(\s)? Kom overeen met nul of één spatieteken.
(\p{IsBasicLatin}+(\s)?)+ Komt overeen met het patroon van een of meer eenvoudige Latijnse tekens, gevolgd door nul of één witruimtetekens een of meer keren.

Negatieve Unicode-categorie of Unicode-blok: \P{}

De Unicode-standaard wijst elk teken een algemene categorie toe. Een bepaald teken kan bijvoorbeeld een hoofdletter zijn (vertegenwoordigd door de Lu categorie), een decimaalteken (de Nd categorie), een rekenkundig symbool (de Sm categorie) of een alineascheidingsteken (de Zl categorie). Specifieke tekensets in de Unicode-standaard nemen ook een specifiek bereik of blok opeenvolgende codepunten in beslag. De latijnse basistekenset wordt bijvoorbeeld gevonden uit \u0000 tot en met \u007F, terwijl de Arabische tekenset wordt gevonden van \u0600 tot en met \u06FF.

De reguliere expressie-constructie

\P{naam }

komt overeen met elk teken dat niet hoort bij een algemene Unicode-categorie of benoemd blok, waarbij de naam de afkorting van de categorie of de naam van het benoemde blok is. Zie de sectie Ondersteunde algemene unicode-categorieën verderop in dit onderwerp voor een lijst met categorie afkortingen. Zie de sectie Ondersteunde benoemde blokken verderop in dit onderwerp voor een lijst met benoemde blokken.

Tip

De vergelijking kan worden verbeterd als de tekenreeks voor het eerst wordt genormaliseerd door de methode aan te String.Normalize roepen.

In het volgende voorbeeld wordt de \P{naamconstructie} gebruikt om valutasymbolen (in dit geval de Sccategorie Of Symbool, Valuta) uit numerieke tekenreeksen te verwijderen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\P{Sc})+";

      string[] values = { "$164,091.78", "£1,073,142.68", "73¢", "€120" };
      foreach (string value in values)
         Console.WriteLine(Regex.Match(value, pattern).Value);
   }
}
// The example displays the following output:
//       164,091.78
//       1,073,142.68
//       73
//       120

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "(\P{Sc})+"

        Dim values() As String = {"$164,091.78", "£1,073,142.68", "73¢", "€120"}
        For Each value As String In values
            Console.WriteLine(Regex.Match(value, pattern).Value)
        Next
    End Sub
End Module
' The example displays the following output:
'       164,091.78
'       1,073,142.68
'       73
'       120

Het reguliere expressiepatroon (\P{Sc})+ komt overeen met een of meer tekens die geen valutasymbolen zijn. In feite wordt een valutasymbool uit de resultaattekenreeks verwijderd.

Woordteken: \w

\w komt overeen met elk woordteken. Een woordteken is lid van een van de Unicode-categorieën die worden vermeld in de volgende tabel.

Categorie Beschrijving
Ll Letter, kleine letter
Lu Letter, hoofdletter
Lt Letter, Titelcase
Lo Letter, Overig
Lm Letter, Modifier
Mn Markeren, niet-pacing
Nd Getal, decimaal getal
Pc Interpunctie, verbindingslijn. Deze categorie bevat tien tekens, waarvan het meest wordt gebruikt het LOWLINE-teken (_), u+005F.

Als ECMAScript-compatibel gedrag is opgegeven, \w is dit gelijk aan [a-zA-Z_0-9]. Zie de sectie ECMAScript Matching Behavior in Regular Expression Options voor meer informatie over reguliere ECMAScript-expressies.

Notitie

Omdat het overeenkomt met elk woordteken, wordt het \w taalelement vaak gebruikt met een luie kwantificator als een normaal expressiepatroon meerdere keren een woordteken probeert te vinden, gevolgd door een specifiek woordteken. Zie Kwantificatoren voor meer informatie.

In het volgende voorbeeld wordt het \w taalelement gebruikt om dubbele tekens in een woord te vinden. In het voorbeeld wordt een patroon voor reguliere expressies gedefinieerd, (\w)\1dat als volgt kan worden geïnterpreteerd.

Element Beschrijving
(\w) Komt overeen met een woordteken. Dit is de eerste opnamegroep.
\1 Komt overeen met de waarde van de eerste opname. 
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\w)\1";
      string[] words = { "trellis", "seer", "latter", "summer",
                         "hoarse", "lesser", "aardvark", "stunned" };
      foreach (string word in words)
      {
         Match match = Regex.Match(word, pattern);
         if (match.Success)
            Console.WriteLine("'{0}' found in '{1}' at position {2}.",
                              match.Value, word, match.Index);
         else
            Console.WriteLine("No double characters in '{0}'.", word);
      }
   }
}
// The example displays the following output:
//       'll' found in 'trellis' at position 3.
//       'ee' found in 'seer' at position 1.
//       'tt' found in 'latter' at position 2.
//       'mm' found in 'summer' at position 2.
//       No double characters in 'hoarse'.
//       'ss' found in 'lesser' at position 2.
//       'aa' found in 'aardvark' at position 0.
//       'nn' found in 'stunned' at position 3.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "(\w)\1"
        Dim words() As String = {"trellis", "seer", "latter", "summer", _
                                  "hoarse", "lesser", "aardvark", "stunned"}
        For Each word As String In words
            Dim match As Match = Regex.Match(word, pattern)
            If match.Success Then
                Console.WriteLine("'{0}' found in '{1}' at position {2}.", _
                                  match.Value, word, match.Index)
            Else
                Console.WriteLine("No double characters in '{0}'.", word)
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       'll' found in 'trellis' at position 3.
'       'ee' found in 'seer' at position 1.
'       'tt' found in 'latter' at position 2.
'       'mm' found in 'summer' at position 2.
'       No double characters in 'hoarse'.
'       'ss' found in 'lesser' at position 2.
'       'aa' found in 'aardvark' at position 0.
'       'nn' found in 'stunned' at position 3.

Niet-woordteken: \W

\W komt overeen met een niet-woordteken. Het taalelement \W is gelijk aan de volgende tekenklasse:

[^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]

Met andere woorden, deze komt overeen met elk teken, met uitzondering van tekens in de Unicode-categorieën die in de volgende tabel worden vermeld.

Categorie Beschrijving
Ll Letter, kleine letter
Lu Letter, hoofdletter
Lt Letter, Titelcase
Lo Letter, Overig
Lm Letter, Modifier
Mn Markeren, niet-pacing
Nd Getal, decimaal getal
Pc Interpunctie, verbindingslijn. Deze categorie bevat tien tekens, waarvan het meest wordt gebruikt het LOWLINE-teken (_), u+005F.

Als ECMAScript-compatibel gedrag is opgegeven, \W is dit gelijk aan [^a-zA-Z_0-9]. Zie de sectie ECMAScript Matching Behavior in Regular Expression Options voor meer informatie over reguliere ECMAScript-expressies.

Notitie

Omdat het overeenkomt met een niet-woordteken, wordt het \W taalelement vaak gebruikt met een luie kwantificator als een normaal expressiepatroon meerdere keren probeert overeen te komen met een niet-woordteken gevolgd door een specifiek niet-woordteken. Zie Kwantificatoren voor meer informatie.

In het volgende voorbeeld ziet u de \W tekenklasse. Het definieert een normaal expressiepatroon, \b(\w+)(\W){1,2}dat overeenkomt met een woord gevolgd door een of twee niet-woordtekens, zoals spatie of leestekens. De reguliere expressie wordt geïnterpreteerd zoals weergegeven in de volgende tabel.

Element Beschrijving
\b Begin de overeenkomst bij een woordgrens.
(\w+) Komt overeen met een of meer woordtekens. Dit is de eerste opnamegroep.
(\W){1,2} Een of twee keer overeenkomen met een niet-woordteken. Dit is de tweede vastleggende groep. 
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)(\W){1,2}";
      string input = "The old, grey mare slowly walked across the narrow, green pasture.";
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         Console.Write("   Non-word character(s):");
         CaptureCollection captures = match.Groups[2].Captures;
         for (int ctr = 0; ctr < captures.Count; ctr++)
             Console.Write(@"'{0}' (\u{1}){2}", captures[ctr].Value,
                           Convert.ToUInt16(captures[ctr].Value[0]).ToString("X4"),
                           ctr < captures.Count - 1 ? ", " : "");
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       The
//          Non-word character(s):' ' (\u0020)
//       old,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       grey
//          Non-word character(s):' ' (\u0020)
//       mare
//          Non-word character(s):' ' (\u0020)
//       slowly
//          Non-word character(s):' ' (\u0020)
//       walked
//          Non-word character(s):' ' (\u0020)
//       across
//          Non-word character(s):' ' (\u0020)
//       the
//          Non-word character(s):' ' (\u0020)
//       narrow,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       green
//          Non-word character(s):' ' (\u0020)
//       pasture.
//          Non-word character(s):'.' (\u002E)

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\w+)(\W){1,2}"
        Dim input As String = "The old, grey mare slowly walked across the narrow, green pasture."
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Value)
            Console.Write("   Non-word character(s):")
            Dim captures As CaptureCollection = match.Groups(2).Captures
            For ctr As Integer = 0 To captures.Count - 1
                Console.Write("'{0}' (\u{1}){2}", captures(ctr).Value, _
                              Convert.ToUInt16(captures(ctr).Value.Chars(0)).ToString("X4"), _
                              If(ctr < captures.Count - 1, ", ", ""))
            Next
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output:
'       The
'          Non-word character(s):' ' (\u0020)
'       old,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       grey
'          Non-word character(s):' ' (\u0020)
'       mare
'          Non-word character(s):' ' (\u0020)
'       slowly
'          Non-word character(s):' ' (\u0020)
'       walked
'          Non-word character(s):' ' (\u0020)
'       across
'          Non-word character(s):' ' (\u0020)
'       the
'          Non-word character(s):' ' (\u0020)
'       narrow,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       green
'          Non-word character(s):' ' (\u0020)
'       pasture.
'          Non-word character(s):'.' (\u002E)

Omdat het Group object voor de tweede groep vastleggen slechts één vastgelegd niet-woordteken bevat, worden in het voorbeeld alle vastgelegde niet-woordtekens opgehaald uit het CaptureCollection object dat door de Group.Captures eigenschap wordt geretourneerd.

Spatieteken: \s

\s komt overeen met een witruimteteken. Het is gelijk aan de escapereeksen en Unicode-categorieën die worden vermeld in de volgende tabel.

Categorie Beschrijving
\f Het formulierfeedteken \u000C.
\n Het teken newline, \u000A.
\r Het regelterugloopteken \u000D.
\t Het tabbladteken \u0009.
\v Het verticale tabteken \u000B.
\x85 Het teken NEXT LINE (NEL), \u0085.
\p{Z} Komt overeen met alle scheidingstekens. Dit omvat de Zs, Zlen Zp categorieën.

Als ECMAScript-compatibel gedrag is opgegeven, \s is dit gelijk aan [ \f\n\r\t\v]. Zie de sectie ECMAScript Matching Behavior in Regular Expression Options voor meer informatie over reguliere ECMAScript-expressies.

In het volgende voorbeeld ziet u de \s tekenklasse. Het definieert een normaal expressiepatroon, \b\w+(e)?s(\s|$)dat overeenkomt met een woord dat eindigt op 's' of 'es', gevolgd door een spatieteken of het einde van de invoertekenreeks. De reguliere expressie wordt geïnterpreteerd zoals weergegeven in de volgende tabel.

Element Beschrijving
\b Begin de overeenkomst bij een woordgrens.
\w+ Komt overeen met een of meer woordtekens.
(e)? Komt overeen met een 'e' nul of één keer.
s Komt overeen met een 's'.
(\s|$) Komt overeen met een spatieteken of het einde van de invoertekenreeks. 
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+(e)?s(\s|$)";
      string input = "matches stores stops leave leaves";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       matches
//       stores
//       stops
//       leaves

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b\w+(e)?s(\s|$)"
        Dim input As String = "matches stores stops leave leaves"
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Value)
        Next
    End Sub
End Module
' The example displays the following output:
'       matches
'       stores
'       stops
'       leaves

Niet-witruimteteken: \S

\S komt overeen met een niet-witruimteteken. Het is gelijk aan het [^\f\n\r\t\v\x85\p{Z}] reguliere expressiepatroon of het tegenovergestelde van het reguliere expressiepatroon dat gelijk is aan \s, die overeenkomt met spatietekens. Zie Spatieteken: \s voor meer informatie.

Als ECMAScript-compatibel gedrag is opgegeven, \S is dit gelijk aan [^ \f\n\r\t\v]. Zie de sectie ECMAScript Matching Behavior in Regular Expression Options voor meer informatie over reguliere ECMAScript-expressies.

In het volgende voorbeeld ziet u het \S taalelement. Het reguliere expressiepatroon \b(\S+)\s? komt overeen met tekenreeksen die worden gescheiden door spatietekens. Het tweede element in het object van GroupCollection de overeenkomst bevat de overeenkomende tekenreeks. De reguliere expressie kan worden geïnterpreteerd zoals wordt weergegeven in de volgende tabel.

Element Beschrijving
\b Begin de overeenkomst bij een woordgrens.
(\S+) Komt overeen met een of meer niet-witruimtetekens. Dit is de eerste opnamegroep.
\s? Kom overeen met nul of één spatieteken. 
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\S+)\s?";
      string input = "This is the first sentence of the first paragraph. " +
                            "This is the second sentence.\n" +
                            "This is the only sentence of the second paragraph.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Groups[1]);
   }
}
// The example displays the following output:
//    This
//    is
//    the
//    first
//    sentence
//    of
//    the
//    first
//    paragraph.
//    This
//    is
//    the
//    second
//    sentence.
//    This
//    is
//    the
//    only
//    sentence
//    of
//    the
//    second
//    paragraph.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\S+)\s?"
        Dim input As String = "This is the first sentence of the first paragraph. " + _
                              "This is the second sentence." + vbCrLf + _
                              "This is the only sentence of the second paragraph."
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Groups(1))
        Next
    End Sub
End Module
' The example displays the following output:
'    This
'    is
'    the
'    first
'    sentence
'    of
'    the
'    first
'    paragraph.
'    This
'    is
'    the
'    second
'    sentence.
'    This
'    is
'    the
'    only
'    sentence
'    of
'    the
'    second
'    paragraph.

Decimaalteken: \d

\d komt overeen met een decimaal getal. Het is gelijk aan het \p{Nd} reguliere expressiepatroon, dat de standaarddecimaaltekens 0-9 en de decimale cijfers van een aantal andere tekensets bevat.

Als ECMAScript-compatibel gedrag is opgegeven, \d is dit gelijk aan [0-9]. Zie de sectie ECMAScript Matching Behavior in Regular Expression Options voor meer informatie over reguliere ECMAScript-expressies.

In het volgende voorbeeld ziet u het \d taalelement. Er wordt getest of een invoertekenreeks een geldig telefoonnummer in de Verenigde Staten en Canada vertegenwoordigt. Het reguliere expressiepatroon ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ wordt gedefinieerd zoals wordt weergegeven in de volgende tabel.

Element Beschrijving
^ Begin de overeenkomst aan het begin van de invoertekenreeks.
\(? Kom overeen met nul of één letterlijk "(" teken.
\d{3} Kom overeen met drie decimalen.
\)? Kom overeen met nul of één letterlijk ")"-teken.
[\s-] Identiek aan een afbreekstreepje of een spatieteken.
(\(?\d{3}\)?[\s-])? Pas een optioneel haakje openen aan, gevolgd door drie decimalen, een optioneel haakje sluiten en een witruimteteken of een afbreekstreepje nul of één keer. Dit is de eerste opnamegroep.
\d{3}-\d{4} Kom overeen met drie decimalen, gevolgd door een afbreekstreepje en nog vier decimale cijfers.
$ Komt overeen met het einde van de invoertekenreeks. 
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$";
      string[] inputs = { "111 111-1111", "222-2222", "222 333-444",
                          "(212) 111-1111", "111-AB1-1111",
                          "212-111-1111", "01 999-9999" };

      foreach (string input in inputs)
      {
         if (Regex.IsMatch(input, pattern))
            Console.WriteLine(input + ": matched");
         else
            Console.WriteLine(input + ": match failed");
      }
   }
}
// The example displays the following output:
//       111 111-1111: matched
//       222-2222: matched
//       222 333-444: match failed
//       (212) 111-1111: matched
//       111-AB1-1111: match failed
//       212-111-1111: matched
//       01 999-9999: match failed

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$"
        Dim inputs() As String = {"111 111-1111", "222-2222", "222 333-444", _
                                   "(212) 111-1111", "111-AB1-1111", _
                                   "212-111-1111", "01 999-9999"}

        For Each input As String In inputs
            If Regex.IsMatch(input, pattern) Then
                Console.WriteLine(input + ": matched")
            Else
                Console.WriteLine(input + ": match failed")
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       111 111-1111: matched
'       222-2222: matched
'       222 333-444: match failed
'       (212) 111-1111: matched
'       111-AB1-1111: match failed
'       212-111-1111: matched
'       01 999-9999: match failed

Niet-cijferig teken: \D

\D komt overeen met een niet-cijferig teken. Het is gelijk aan het \P{Nd} reguliere expressiepatroon.

Als ECMAScript-compatibel gedrag is opgegeven, \D is dit gelijk aan [^0-9]. Zie de sectie ECMAScript Matching Behavior in Regular Expression Options voor meer informatie over reguliere ECMAScript-expressies.

In het volgende voorbeeld ziet u het \D-taalelement. Hiermee wordt getest of een tekenreeks, zoals een onderdeelnummer, bestaat uit de juiste combinatie van decimale en niet-decimale tekens. Het reguliere expressiepatroon ^\D\d{1,5}\D*$ wordt gedefinieerd zoals wordt weergegeven in de volgende tabel.

Element Beschrijving
^ Begin de overeenkomst aan het begin van de invoertekenreeks.
\D Komt overeen met een niet-cijferig teken.
\d{1,5} Kom overeen tussen één en vijf decimalen.
\D* Kom overeen met nul, één of meer niet-decimale tekens.
$ Komt overeen met het einde van de invoertekenreeks. 
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^\D\d{1,5}\D*$";
      string[] inputs = { "A1039C", "AA0001", "C18A", "Y938518" };

      foreach (string input in inputs)
      {
         if (Regex.IsMatch(input, pattern))
            Console.WriteLine(input + ": matched");
         else
            Console.WriteLine(input + ": match failed");
      }
   }
}
// The example displays the following output:
//       A1039C: matched
//       AA0001: match failed
//       C18A: matched
//       Y938518: match failed

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "^\D\d{1,5}\D*$"
        Dim inputs() As String = {"A1039C", "AA0001", "C18A", "Y938518"}

        For Each input As String In inputs
            If Regex.IsMatch(input, pattern) Then
                Console.WriteLine(input + ": matched")
            Else
                Console.WriteLine(input + ": match failed")
            End If
        Next
    End Sub
End Module
' The example displays the following output:

Ondersteunde algemene Unicode-categorieën

Unicode definieert de algemene categorieën die worden vermeld in de volgende tabel. Zie de subonderwerpen 'UCD-bestandsindeling' en 'Algemene categoriewaarden' in de Unicode-tekendatabase, sec. 5.7.1, tabel 12 voor meer informatie.

Categorie Beschrijving
Lu Letter, hoofdletter
Ll Letter, kleine letter
Lt Letter, Titelcase
Lm Letter, Modifier
Lo Letter, Overig
L Alle lettertekens. Dit omvat de Lutekens , , Llen LtLmLo tekens.
Mn Markeren, niet-pacing
Mc Markering, afstand combineren
Me Markeren, insluiten
M Alle combinatiemarkeringen. Dit omvat de Mn, Mcen Me categorieën.
Nd Getal, decimaal getal
Nl Getal, letter
No Getal, overige
N Alle getallen. Dit omvat de Nd, Nlen No categorieën.
Pc Interpunctie, verbindingslijn
Pd Interpunctie, streepje
Ps Interpunctie, Openen
Pe Interpunctie, sluiten
Pi Interpunctie, eerste aanhalingsteken (kan zich gedragen als Ps of Pe, afhankelijk van het gebruik)
Pf Interpunctie, eindcitaat (kan zich gedragen als Ps of Pe, afhankelijk van het gebruik)
Po Interpunctie, overige
P Alle interpunctietekens. Dit omvat de Pccategorieën , , Pd, PsPe, Pien PfPo .
Sm Symbool, wiskunde
Sc Symbool, valuta
Sk Symbool, modifier
So Symbool, overige
S Alle symbolen. Dit omvat de Sm, Scen SkSo categorieën.
Zs Scheidingsteken, spatie
Zl Scheidingsteken, lijn
Zp Scheidingsteken, alinea
Z Alle scheidingstekens. Dit omvat de Zs, Zlen Zp categorieën.
Cc Overig, besturingselement
Cf Overig, opmaak
Cs Overig, surrogaat
Co Ander, privégebruik
Cn Overige, niet toegewezen of niet-character
C Alle andere tekens. Dit omvat de Cc, Cf, , Csen CoCn categorieën.

U kunt de Unicode-categorie van een bepaald teken bepalen door dat teken door te geven aan de GetUnicodeCategory methode. In het volgende voorbeeld wordt de GetUnicodeCategory methode gebruikt om de categorie van elk element in een matrix te bepalen die geselecteerde Latijnse tekens bevat.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      char[] chars = { 'a', 'X', '8', ',', ' ', '\u0009', '!' };

      foreach (char ch in chars)
         Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()),
                           Char.GetUnicodeCategory(ch));
   }
}
// The example displays the following output:
//       'a': LowercaseLetter
//       'X': UppercaseLetter
//       '8': DecimalDigitNumber
//       ',': OtherPunctuation
//       '\ ': SpaceSeparator
//       '\t': Control
//       '!': OtherPunctuation

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim chars() As Char = {"a"c, "X"c, "8"c, ","c, " "c, ChrW(9), "!"c}

        For Each ch As Char In chars
            Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()), _
                              Char.GetUnicodeCategory(ch))
        Next
    End Sub
End Module
' The example displays the following output:
'       'a': LowercaseLetter
'       'X': UppercaseLetter
'       '8': DecimalDigitNumber
'       ',': OtherPunctuation
'       '\ ': SpaceSeparator
'       '\t': Control
'       '!': OtherPunctuation

Ondersteunde benoemde blokken

.NET biedt de benoemde blokken die worden vermeld in de volgende tabel. De set ondersteunde benoemde blokken is gebaseerd op Unicode 4.0 en Perl 5.6. Zie de Unicode-categorie of het Unicode-blok: \p-sectie{} voor een reguliere expressie die gebruikmaakt van benoemde blokken.

Codepuntbereik Bloknaam
0000 - 007F IsBasicLatin
0080 - 00FF IsLatin-1Supplement
0100 - 017F IsLatinExtended-A
0180 - 024F IsLatinExtended-B
0250 - 02AF IsIPAExtensions
02B0 - 02FF IsSpacingModifierLetters
0300 - 036F IsCombiningDiacriticalMarks
0370 - 03FF IsGreek

– of –

IsGreekandCoptic
0400 - 04FF IsCyrillic
0500 - 052F IsCyrillicSupplement
0530 - 058F IsArmenian
0590 - 05FF IsHebrew
0600 - 06FF IsArabic
0700 - 074F IsSyriac
0780 - 07BF IsThaana
0900 - 097F IsDevanagari
0980 - 09FF IsBengali
0A00 - 0A7F IsGurmukhi
0A80 - 0AFF IsGujarati
0B00 - 0B7F IsOriya
0B80 - 0BFF IsTamil
0C00 - 0C7F IsTelugu
0C80 - 0CFF IsKannada
0D00 - 0D7F IsMalayalam
0D80 - 0DFF IsSinhala
0E00 - 0E7F IsThai
0E80 - 0EFF IsLao
0F00 - 0FFF IsTibetan
1000 - 109F IsMyanmar
10A0 - 10FF IsGeorgian
1100 - 11FF IsHangulJamo
1200 - 137F IsEthiopic
13A0 - 13FF IsCherokee
1400 - 167F IsUnifiedCanadianAboriginalSyllabics
1680 - 169F IsOgham
16A0 - 16FF IsRunic
1700 - 171F IsTagalog
1720 - 173F IsHanunoo
1740 - 175F IsBuhid
1760 - 177F IsTagbanwa
1780 - 17FF IsKhmer
1800 - 18AF IsMongolian
1900 - 194F IsLimbu
1950 - 197F IsTaiLe
19E0 - 19FF IsKhmerSymbols
1D00 - 1D7F IsPhoneticExtensions
1E00 - 1EFF IsLatinExtendedAdditional
1F00 - 1FFF IsGreekExtended
2000 - 206F IsGeneralPunctuation
2070 - 209F IsSuperscriptsandSubscripts
20A0 - 20CF IsCurrencySymbols
20D0 - 20FF IsCombiningDiacriticalMarksforSymbols

– of –

IsCombiningMarksforSymbols
2100 - 214F IsLetterlikeSymbols
2150 - 218F IsNumberForms
2190 - 21FF IsArrows
2200 - 22FF IsMathematicalOperators
2300 - 23FF IsMiscellaneousTechnical
2400 - 243F IsControlPictures
2440 - 245F IsOpticalCharacterRecognition
2460 - 24FF IsEnclosedAlphanumerics
2500 - 257F IsBoxDrawing
2580 - 259F IsBlockElements
25A0 - 25FF IsGeometricShapes
2600 - 26FF IsMiscellaneousSymbols
2700 - 27BF IsDingbats
27C0 - 27EF IsMiscellaneousMathematicalSymbols-A
27F0 - 27FF IsSupplementalArrows-A
2800 - 28FF IsBraillePatterns
2900 - 297F IsSupplementalArrows-B
2980 - 29FF IsMiscellaneousMathematicalSymbols-B
2A00 - 2AFF IsSupplementalMathematicalOperators
2B00 - 2BFF IsMiscellaneousSymbolsandArrows
2E80 - 2EFF IsCJKRadicalsSupplement
2F00 - 2FDF IsKangxiRadicals
2FF0 - 2FFF IsIdeographicDescriptionCharacters
3000 - 303F IsCJKSymbolsandPunctuation
3040 - 309F IsHiragana
30A0 - 30FF IsKatakana
3100 - 312F IsBopomofo
3130 - 318F IsHangulCompatibilityJamo
3190 - 319F IsKanbun
31A0 - 31BF IsBopomofoExtended
31F0 - 31FF IsKatakanaPhoneticExtensions
3200 - 32FF IsEnclosedCJKLettersandMonths
3300 - 33FF IsCJKCompatibility
3400 - 4DBF IsCJKUnifiedIdeographsExtensionA
4DC0 - 4DFF IsYijingHexagramSymbols
4E00 - 9FFF IsCJKUnifiedIdeographs
A000 - A48F IsYiSyllables
A490 - A4CF IsYiRadicals
AC00 - D7AF IsHangulSyllables
D800 - DB7F IsHighSurrogates
DB80 - DBFF IsHighPrivateUseSurrogates
DC00 - DFFF IsLowSurrogates
E000 - F8FF IsPrivateUse of IsPrivateUseArea
F900 - FAFF IsCJKCompatibilityIdeographs
FB00 - FB4F IsAlphabeticPresentationForms
FB50 - FDFF IsArabicPresentationForms-A
FE00 - FE0F IsVariationSelectors
FE20 - FE2F IsCombiningHalfMarks
FE30 - FE4F IsCJKCompatibilityForms
FE50 - FE6F IsSmallFormVariants
FE70 - FEFF IsArabicPresentationForms-B
FF00 - FFEF IsHalfwidthandFullwidthForms
FFF0 - FFFF IsSpecials

Aftrekken van tekenklasse: [base_group - [excluded_group]]

Een tekenklasse definieert een set tekens. Aftrekken van tekenklasse resulteert in een reeks tekens die het resultaat is van het uitsluiten van de tekens in de ene tekenklasse van een andere tekenklasse.

Een aftrekkingsexpressie van een tekenklasse heeft het volgende formulier:

[ -[ base_group excluded_group ]]

De vierkante haken () en afbreekstreepjes ([]-) zijn verplicht. De base_group is een positieve tekengroep of een negatieve tekengroep. Het excluded_group onderdeel is een andere positieve of negatieve tekengroep, of een andere tekenklasse-aftrekkingsexpressie (u kunt tekenklasse-aftrekkingsexpressies nesten).

Stel dat u een basisgroep hebt die bestaat uit het tekenbereik van 'a' tot 'z'. Als u de set tekens wilt definiëren die uit de basisgroep bestaat, met uitzondering van het teken 'm', gebruikt u [a-z-[m]]. Als u de set tekens wilt definiëren die uit de basisgroep bestaat, met uitzondering van de set tekens 'd', 'j' en 'p', gebruikt u [a-z-[djp]]. Als u de set tekens wilt definiëren die uit de basisgroep bestaat, met uitzondering van het tekenbereik van 'm' tot 'p', gebruikt u [a-z-[m-p]].

Houd rekening met de geneste tekenklasse-aftrekkingsexpressie. [a-z-[d-w-[m-o]]] De expressie wordt geëvalueerd vanuit het binnenste tekenbereik naar buiten. Ten eerste wordt het tekenbereik van 'm' tot 'o' afgetrokken van het tekenbereik 'd' tot en met 'w', wat de reeks tekens van 'd' tot en met 'p' tot en met 'w' oplevert. Die set wordt vervolgens afgetrokken van het tekenbereik van 'a' tot 'z', wat de reeks tekens [abcmnoxyz]oplevert.

U kunt elke tekenklasse gebruiken met aftrekken van tekenklassen. Als u de reeks tekens wilt definiëren die bestaat uit alle Unicode-tekens van \u0000 tot en met \uFFFF behalve spatietekens (\s), de tekens in de algemene categorie interpunctie (\p{P}), de tekens in het IsGreek benoemde blok (\p{IsGreek}) en het Unicode NEXT LINE-besturingselement (\x85), gebruikt u [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].

Kies tekenklassen voor een aftrekkingsexpressie van een tekenklasse die nuttige resultaten oplevert. Vermijd een expressie die een lege set tekens oplevert, die niet overeenkomen met iets, of een expressie die gelijk is aan de oorspronkelijke basisgroep. De lege set is bijvoorbeeld het resultaat van de expressie [\p{IsBasicLatin}-[\x00-\x7F]], waarmee alle tekens in het IsBasicLatin tekenbereik van de IsBasicLatin algemene categorie worden afgetrokken. Op dezelfde manier is de oorspronkelijke basisgroep het resultaat van de expressie [a-z-[0-9]]. Dit komt doordat de basisgroep, het tekenbereik van letters van 'a' tot en met 'z', geen tekens in de uitgesloten groep bevat. Dit is het tekenbereik van decimalen van '0' tot en met '9'.

In het volgende voorbeeld wordt een reguliere expressie gedefinieerd die ^[0-9-[2468]]+$overeenkomt met nul en oneven cijfers in een invoertekenreeks. De reguliere expressie wordt geïnterpreteerd zoals weergegeven in de volgende tabel.

Element Beschrijving
^ Begin de overeenkomst aan het begin van de invoertekenreeks.
[0-9-[2468]]+ Komt overeen met een of meer exemplaren van een willekeurig teken van 0 tot 9, met uitzondering van 2, 4, 6 en 8. Met andere woorden, overeenkomst met een of meer exemplaren van nul of een oneven cijfer.
$ Beëindig de overeenkomst aan het einde van de invoertekenreeks. 
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "123", "13579753", "3557798", "335599901" };
      string pattern = @"^[0-9-[2468]]+$";

      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern);
         if (match.Success)
            Console.WriteLine(match.Value);
      }
   }
}
// The example displays the following output:
//       13579753
//       335599901

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim inputs() As String = {"123", "13579753", "3557798", "335599901"}
        Dim pattern As String = "^[0-9-[2468]]+$"

        For Each input As String In inputs
            Dim match As Match = Regex.Match(input, pattern)
            If match.Success Then Console.WriteLine(match.Value)
        Next
    End Sub
End Module
' The example displays the following output:
'       13579753
'       335599901

Zie ook