Tekenklassen in reguliere expressies
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 desoptie,.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{name}
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{name}
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, Lowercase |
| Lu | Letter, hoofdletter |
| Lt | Letter, Titelcase |
| Lo | Letter, Overig |
| Lm | Letter, Modifier |
| Mn | Markeren, niet-pacing |
| Nd | Getal, decimaal getal |
| Pc | Interpunctie, Verbinding maken or. 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, Lowercase |
| Lu | Letter, hoofdletter |
| Lt | Letter, Titelcase |
| Lo | Letter, Overig |
| Lm | Letter, Modifier |
| Mn | Markeren, niet-pacing |
| Nd | Getal, decimaal getal |
| Pc | Interpunctie, Verbinding maken or. 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, Lowercase |
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, Verbinding maken or |
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
Feedback
Binnenkort beschikbaar: In de loop van 2024 zullen we GitHub-problemen geleidelijk uitfaseren als het feedbackmechanisme voor inhoud en deze vervangen door een nieuw feedbacksysteem. Zie voor meer informatie: https://aka.ms/ContentUserFeedback.
Feedback verzenden en weergeven voor