Třídy znaků v regulárních výrazech
Třída znaků definuje množinu znaků, přičemž kterýkoli z nich se může vyskytovat ve vstupním řetězci tak, aby došlo ke shodě. Jazyk regulárního výrazu v .NET podporuje následující třídy znaků:
Skupiny pozitivních znaků. Znak ve vstupním řetězci musí odpovídat jedné ze zadaných množin znaků. Další informace naleznete v tématu Skupina kladných znaků.
Skupiny negativních znaků. Znak ve vstupním řetězci nesmí odpovídat jedné ze zadaných množin znaků. Další informace naleznete v tématu Skupina záporných znaků.
Libovolný znak. Znak
.(tečka nebo tečka) v regulárním výrazu je zástupný znak, který odpovídá jakémukoli znaku kromě\n. Další informace naleznete v tématu Libovolný znak.Obecná kategorie nebo pojmenovaný blok sady Unicode. Pro úspěšné vyhledání shody musí být znak ve vstupním řetězci členem určité kategorie sady Unicode nebo musí spadat do souvislého rozsahu znaků sady Unicode. Další informace naleznete v tématu Unicode Category or Unicode Block.
Negativní obecná kategorie nebo pojmenovaný blok sady Unicode. Pro úspěšné vyhledání shody nesmí být znak ve vstupním řetězci členem určité kategorie sady Unicode ani nesmí spadat do souvislého rozsahu znaků sady Unicode. Další informace naleznete v tématu Negative Unicode Category or Unicode Block.
Znak slova. Znak ve vstupním řetězci může patřit do kterékoli kategorie sady Unicode, která je vhodná pro znaky ve slovech. Další informace naleznete v tématu Znak aplikace Word.
Mimoslovní znak. Znak ve vstupním řetězci může patřit do jakékoli kategorie sady Unicode, která není znakem slova. Další informace naleznete v tématu Znak jiného než Wordu.
Prázdný znak. Znakem ve vstupním řetězci může být jakýkoli oddělovací znak sady Unicode nebo některý z mnoha řídicích znaků. Další informace najdete v tématu Prázdný znak.
Neprázdný znak. Znakem ve vstupním řetězci může být libovolný znak, který není prázdným znakem. Další informace naleznete v tématu Bez prázdný znak.
Desítková číslice. Znakem ve vstupním řetězci může být kterýkoli ze znaků, který je klasifikován jako desítková číslice sady Unicode. Další informace naleznete v tématu Desetinná číslice znak.
Nedesetinné číslo. Znakem ve vstupním řetězci může být jakýkoli jiný znak než desítková číslice sady Unicode. Další informace naleznete v tématu Desetinná číslice znak.
.NET podporuje výrazy odčítání třídy znaků, které umožňují definovat sadu znaků v důsledku vyloučení jedné třídy znaků z jiné třídy znaků. Další informace naleznete v tématu Odčítání třídy znaků.
Poznámka:
Třídy znaků, které odpovídají znakům podle kategorie, například \w, aby odpovídaly znakům slova nebo \p{}, aby odpovídaly kategorii Unicode, spoléhají na CharUnicodeInfo třídu, která poskytuje informace o kategoriích znaků. V rozhraní .NET Framework 4.6.2 a novějších verzích jsou kategorie znaků založené na standardu Unicode verze 8.0.0.
Skupina kladných znaků: [ ]
Skupina pozitivních znaků určuje seznam znaků, které se mohou objevit ve vstupním řetězci, aby nastala shoda. Tento seznam znaků může být zadán jako jednotlivé znaky, jako rozsah nebo obojí.
Syntaxe pro určení seznamu jednotlivých znaků je následující:
[*character_group*]
kde character_group je seznam jednotlivých znaků, které mohou být zobrazeny ve vstupním řetězci, aby shoda byla úspěšná. character_group se můžou skládat z jakékoli kombinace jednoho nebo více literálových znaků, řídicích znaků nebo tříd znaků.
Syntaxe pro zadání rozsahu znaků je následující:
[firstCharacter-lastCharacter]
kde firstCharacter je znak, který začíná rozsah a lastCharacter je znak, který končí oblast. Rozsah znaků je souvislá řada znaků definovaná zadáním prvního znaku v řadě, spojovníku (-) a posledního znaku v řadě. Dva znaky jsou souvislé, pokud mají sousedící kódové body sady Unicode. firstCharacter musí být znak s dolním bodem kódu a lastCharacter musí být znak s vyšším bodem kódu.
Poznámka:
Vzhledem k tomu, že skupina kladných znaků může obsahovat sadu znaků i oblast znaků, je znak spojovníku (-) vždy interpretován jako oddělovač oblastí, pokud se nejedná o první nebo poslední znak skupiny.
Pokud chcete zahrnout spojovník jako nešifrový člen skupiny znaků, uchytáte ho. Chcete-li například vytvořit skupinu znaků pro znak a a znaky od - do /, je správná syntaxe [a\--/].
Některé běžné vzory regulárních výrazů, které obsahují pozitivní třídy znaků, jsou uvedeny v následující tabulce.
| Vzor | Popis |
|---|---|
[aeiou] |
Porovná se všemi samohláskami. |
[\p{P}\d] |
Porovná se všemi interpunkčními znaky a znaky desítkových číslic. |
[\s\p{P}] |
Porovná všechny prázdné znaky a interpunkci. |
V následujícím příkladu je definována skupina pozitivních znaků obsahující znaky „a“ a „e“ tak, že vstupní řetězec musí obsahovat slovo „grey“ nebo „gray“ následované jiným slovem, aby došlo ke shodě.
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.'
Regulární výraz gr[ae]y\s\S+?[\s|\p{P}] je definován takto:
| Vzor | Popis |
|---|---|
gr |
Porovná s literálními znaky „gr“. |
[ae] |
Porovná buď se znakem „a“, nebo s „e“. |
y\s |
Porovná s literálním znakem „y“ následovaným prázdným znakem. |
\S+? |
Porovná s jedním nebo několika neprázdnými znaky, avšak s co nejmenším počtem. |
[\s\p{P}] |
Porovná s prázdným znakem nebo se znakem interpunkčního znaménka. |
V následujícím příkladu jsou vyhledána slova začínající kterýmkoli velkým písmenem. Pomocí dílčího výrazu [A-Z] představuje rozsah velkých písmen od A do Z.
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
Regulární výraz \b[A-Z]\w*\b je definován, jak je znázorněno v následující tabulce.
| Vzor | Popis |
|---|---|
\b |
Začne na hranici slova. |
[A-Z] |
Porovná s libovolným znakem velkého písmene od A až do Z. |
\w* |
Porovná žádný nebo více znaků slova. |
\b |
Porovná hranici slova. |
Záporná skupina znaků: [^]
Skupina negativních znaků určuje seznam znaků, které se nesmí objevit ve vstupním řetězci, aby došlo ke shodě. Seznam znaků může být zadán jako jednotlivé znaky, jako rozsah nebo obojí.
Syntaxe pro určení seznamu jednotlivých znaků je následující:
[*^character_group*]
kde character_group je seznam jednotlivých znaků, které nelze zobrazit ve vstupním řetězci, aby shoda nebylo úspěšné. character_group se můžou skládat z jakékoli kombinace jednoho nebo více literálových znaků, řídicích znaků nebo tříd znaků.
Syntaxe pro zadání rozsahu znaků je následující:
[^*firstCharacter*-*lastCharacter*]
kde firstCharacter je znak, který začíná rozsah a lastCharacter je znak, který končí oblast. Rozsah znaků je souvislá řada znaků definovaná zadáním prvního znaku v řadě, spojovníku (-) a posledního znaku v řadě. Dva znaky jsou souvislé, pokud mají sousedící kódové body sady Unicode. firstCharacter musí být znak s dolním bodem kódu a lastCharacter musí být znak s vyšším bodem kódu.
Poznámka:
Vzhledem k tomu, že skupina záporných znaků může obsahovat sadu znaků i oblast znaků, je znak spojovníku (-) vždy interpretován jako oddělovač oblastí, pokud se nejedná o první nebo poslední znak skupiny.
Mohou být spojeny dva nebo více rozsahů znaků. Chcete-li například zadat rozsah desetinných číslic od "0" do "9", oblast malých písmen od "a" do "f" a oblast velkých písmen od "A" do "F", použijte [0-9a-fA-F].
Úvodní znak stříšky (^) ve skupině záporných znaků je povinný a označuje, že skupina znaků je záporná skupina znaků místo skupiny kladných znaků.
Důležité
Skupina negativních znaků ve větším vzoru regulárního výrazu není kontrolní výraz nulové šířky. To znamená, že po vyhodnocení skupiny negativních znaků modul regulárních výrazů postoupí o jeden znak ve vstupním řetězci.
Některé běžné vzory regulárních výrazů, které obsahují skupiny negativních znaků, jsou uvedeny v následující tabulce.
| Vzor | Popis |
|---|---|
[^aeiou] |
Porovná se všemi znaky kromě samohlásek. |
[^\p{P}\d] |
Porovná se všemi znaky kromě interpunkčních znaků a znaků desítkových číslic. |
Následující příklad porovná libovolné slovo, které začíná znaky „th“ a nenásleduje je „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
Regulární výraz \bth[^o]\w+\b je definován, jak je znázorněno v následující tabulce.
| Vzor | Popis |
|---|---|
\b |
Začne na hranici slova. |
th |
Porovná s literálními znaky „th“. |
[^o] |
Porovná s libovolným znakem, který není „o“. |
\w+ |
Porovná jeden nebo více znaků slova. |
\b |
Skončí na hranici slova. |
Libovolný znak: .
Znak tečky (.) odpovídá jakémukoli znaku kromě \n znaku nového řádku s následujícími dvěma kvalifikacemi:
Pokud je vzor regulárního výrazu RegexOptions.Singleline upraven možností nebo pokud část vzoru, který obsahuje
.třídu znaků, je upravenasmožností,.odpovídá libovolnému znaku. Další informace naleznete v tématu Možnosti regulárního výrazu.Následující příklad znázorňuje různé chování
.třídy znaků ve výchozím nastavení a s RegexOptions.Singleline možností. Regulární výraz^.+začíná na začátku řetězce a odpovídá každému znaku. Ve výchozím nastavení končí shoda na konci prvního řádku; vzor regulárního výrazu odpovídá návratovém znaku řádku,\rale neodpovídá\n. Vzhledem k tomu, že RegexOptions.Singleline možnost interpretuje celý vstupní řetězec jako jeden řádek, odpovídá každému znaku ve vstupním řetězci, včetně\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\.
Poznámka:
Vzhledem k tomu, že odpovídá libovolnému znaku kromě \n, . třída znaků také odpovídá \r (znak návratu na začátek řádku).
Ve skupině pozitivních nebo negativních znaků je tečka považována za literální znak tečky a nikoli za třídu znaků. Další informace naleznete v části Skupina kladných znaků a Skupina záporných znaků dříve v tomto tématu. Následující příklad poskytuje ilustraci definováním regulárního výrazu, který obsahuje znak tečky (
.) jak jako třídu znaků, tak jako člen skupiny kladných znaků. Regulární výraz\b.*[.?!;:](\s|\z)začíná na hranici slova, odpovídá libovolnému znaku, dokud nenarazí na jednu z pěti interpunkčních značek, včetně tečky, a pak odpovídá prázdnému znaku nebo konci řetězce.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.
Poznámka:
Vzhledem k tomu, že odpovídá jakémukoli znaku . , element jazyka se často používá s opožděným kvantifikátorem, pokud se vzor regulárního výrazu pokusí spárovat libovolný znak několikrát. Další informace naleznete v tématu Kvantifikátory.
Kategorie unicode nebo blok Unicode: \p{}
Standard Unicode přiřadí každému znaku obecnou kategorii. Určitý znak může být například velké písmeno (reprezentované Lu kategorií), desetinná číslice ( Nd kategorie), matematický symbol ( Sm kategorie) nebo oddělovač odstavců ( Zl kategorie). Určité množiny znaků sady Unicode zabírají také určité oblasti nebo bloky po sobě následujících bodů kódu. Například množina znaků základní Latinky se nalézá od \u0000 až do \u007F, zatímco množina znaků Arabštiny se nalézá od \u0600 až do \u06FF.
Konstrukce regulárního výrazu
\p{Jméno }
odpovídá libovolnému znaku, který patří do obecné kategorie unicode nebo pojmenovaného bloku, kde název je zkratka kategorie nebo název pojmenovaného bloku. Seznam zkratek kategorií najdete v části Podporované obecné kategorie unicode dále v tomto tématu. Seznam pojmenovaných bloků najdete v části Podporované pojmenované bloky dále v tomto tématu.
Tip
Porovnávání může být vylepšeno, pokud je řetězec nejprve normalizován voláním String.Normalize metody.
Následující příklad používá \p{konstruktor názvu} , který odpovídá obecné kategorii Unicode (v tomto případě , Pdinterpunkci, dash kategorie) a pojmenovaný blok ( IsGreek a IsBasicLatin pojmenované bloky).
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
Regulární výraz \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ je definován, jak je znázorněno v následující tabulce.
| Vzor | Popis |
|---|---|
\b |
Začne na hranici slova. |
\p{IsGreek}+ |
Porovná jeden nebo více znaků řecké abecedy. |
(\s)? |
Porovná žádný nebo jeden prázdný znak. |
(\p{IsGreek}+(\s)?)+ |
Porovná vzorek jednoho nebo více znaků řecké abecedy následovaný žádným nebo jedním prázdným znakem jednou nebo vícekrát. |
\p{Pd} |
Porovná se znakem interpunkce, svislé čáry. |
\s |
Porovná prázdný znak. |
\p{IsBasicLatin}+ |
Porovná s jedním nebo více znaky základní Latinky. |
(\s)? |
Porovná žádný nebo jeden prázdný znak. |
(\p{IsBasicLatin}+(\s)?)+ |
Porovná vzor jednoho nebo více znaků základní Latinky následovaný žádným nebo jedním prázdným znakem jednou nebo vícekrát. |
Negativní kategorie unicode nebo blok Unicode: \P{}
Standard Unicode přiřadí každému znaku obecnou kategorii. Určitý znak může být například velké písmeno (reprezentované Lu kategorií), desetinná číslice ( Nd kategorie), matematický symbol ( Sm kategorie) nebo oddělovač odstavců ( Zl kategorie). Určité množiny znaků sady Unicode zabírají také určité oblasti nebo bloky po sobě následujících bodů kódu. Například množina znaků základní Latinky se nalézá od \u0000 až do \u007F, zatímco množina znaků Arabštiny se nalézá od \u0600 až do \u06FF.
Konstrukce regulárního výrazu
\P{Jméno }
odpovídá libovolnému znaku, který nepatří do obecné kategorie unicode nebo pojmenovaného bloku, kde název je zkratka kategorie nebo název pojmenovaného bloku. Seznam zkratek kategorií najdete v části Podporované obecné kategorie unicode dále v tomto tématu. Seznam pojmenovaných bloků najdete v části Podporované pojmenované bloky dále v tomto tématu.
Tip
Porovnávání může být vylepšeno, pokud je řetězec nejprve normalizován voláním String.Normalize metody.
Následující příklad používá \P{konstruktor názvu} k odebrání všech symbolů měny (v tomto případě Sc, symbol nebo Symbol, Měna kategorie) z číselných řetězců.
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
Vzor regulárního výrazu (\P{Sc})+ odpovídá jednomu nebo více znakům, které nejsou symboly měny. V podstatě z výsledného řetězce odstraní jakýkoli symbol měny.
Znak slova: \w
\w odpovídá libovolnému znaku slova. Znak slova je členem každé kategorie sady Unicode uvedených v následující tabulce.
| Kategorie | Popis |
|---|---|
| Ll | písmeno, malé písmeno |
| Lu | písmeno, velké písmeno |
| Lt | písmeno, velké počáteční písmeno |
| Lo | písmeno, jiné |
| Lm | písmeno, modifikátor |
| Mn | značka, bez mezer |
| Nd | číslo, desítková číslice |
| Pc | interpunkce, spojka. Tato kategorie zahrnuje deset znaků, z nichž nejčastěji používaný je LOWLINE znak (_), u+005F. |
Pokud je zadáno chování kompatibilní s ECMAScriptem, \w je ekvivalentní [a-zA-Z_0-9]. Informace o regulárních výrazech ECMAScript naleznete v části "ECMAScript Matching Behavior" v části Možnosti regulárního výrazu.
Poznámka:
Vzhledem k tomu, že odpovídá libovolnému znaku slova, je prvek jazyka často používán s opožděným kvantifikátorem, \w pokud se vzor regulárního výrazu několikrát pokusí spárovat libovolný znak slova, následovaný konkrétním znakem slova. Další informace naleznete v tématu Kvantifikátory.
Následující příklad používá prvek jazyka \w ke shodě duplicitních znaků ve slově. Příklad definuje vzor regulárního výrazu, (\w)\1který lze interpretovat následujícím způsobem.
| Element (Prvek) | Popis |
|---|---|
| (\w) | Porovnává znak slova. Toto je první zachytávající skupina. |
| \1 | Porovnává hodnotu prvního zachycení. |
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.
Neslovný znak: \W
\W odpovídá libovolnému neslovně danému znaku. Prvek jazyka \W je ekvivalentní s následující třídou znaků:
[^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]
Jinými slovy, odpovídá libovolnému znaku s výjimkou znaků v kategoriích Unicode uvedených v následující tabulce.
| Kategorie | Popis |
|---|---|
| Ll | písmeno, malé písmeno |
| Lu | písmeno, velké písmeno |
| Lt | písmeno, velké počáteční písmeno |
| Lo | písmeno, jiné |
| Lm | písmeno, modifikátor |
| Mn | značka, bez mezer |
| Nd | číslo, desítková číslice |
| Pc | interpunkce, spojka. Tato kategorie zahrnuje deset znaků, z nichž nejčastěji používaný je LOWLINE znak (_), u+005F. |
Pokud je zadáno chování kompatibilní s ECMAScriptem, \W je ekvivalentní [^a-zA-Z_0-9]. Informace o regulárních výrazech ECMAScript naleznete v části "ECMAScript Matching Behavior" v části Možnosti regulárního výrazu.
Poznámka:
Vzhledem k tomu, že odpovídá libovolnému neslovnímu znaku, je prvek jazyka často používán s opožděným kvantifikátorem, \W pokud se vzor regulárního výrazu pokusí spárovat libovolný neslovný znak několikrát následovaný konkrétním neslovným znakem. Další informace naleznete v tématu Kvantifikátory.
Následující příklad znázorňuje \W třídu znaků. Definuje vzor regulárního výrazu, \b(\w+)(\W){1,2}který odpovídá slovu, za kterým následuje jeden nebo dva neslovné znaky, například prázdné znaky nebo interpunkce. Regulární výraz je interpretován tak, jak je uvedeno v následující tabulce.
| Element (Prvek) | Popis |
|---|---|
| \b | Začne porovnání na hranici slova. |
| (\w+) | Porovná jeden nebo více znaků slova. Toto je první zachytávající skupina. |
| (\W){1,2} | Porovnává s mimoslovním znakem jednou nebo dvakrát. Toto je druhá zachytávající skupina. |
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)
Vzhledem k tomu, že Group objekt druhé skupiny zachycení obsahuje pouze jeden zachycený neslovný znak, příklad načte všechny zachycené neslovné znaky z objektu CaptureCollection , který je vrácen Group.Captures vlastností.
Znak prázdného znaku: \s
\s odpovídá jakémukoli prázdnému znaku. Je ekvivalentní s uvozovacími sekvencemi a kategoriemi sady Unicode, které jsou uvedeny v následující tabulce.
| Kategorie | Popis |
|---|---|
\f |
Znak nové stránky, \u000C. |
\n |
Znak nového řádku, \u000A. |
\r |
Návratový znak, \u000D. |
\t |
Znak tabulátoru, \u0009. |
\v |
Znak svislého tabulátoru, \u000B. |
\x85 |
Znak DALŠÍHO ŘÁDKU (NEL) \u0085. |
\p{Z} |
Odpovídá všem znakům oddělovače. To zahrnuje kategorie Zs, Zla Zp kategorie. |
Pokud je zadáno chování kompatibilní s ECMAScriptem, \s je ekvivalentní [ \f\n\r\t\v]. Informace o regulárních výrazech ECMAScript naleznete v části "ECMAScript Matching Behavior" v části Možnosti regulárního výrazu.
Následující příklad znázorňuje \s třídu znaků. Definuje vzor regulárního výrazu, \b\w+(e)?s(\s|$)který odpovídá slovu končícímu na "s" nebo "es" následované prázdným znakem nebo koncem vstupního řetězce. Regulární výraz je interpretován tak, jak je uvedeno v následující tabulce.
| Element (Prvek) | Popis |
|---|---|
| \b | Začne porovnání na hranici slova. |
| \w+ | Porovná jeden nebo více znaků slova. |
| (e)? | Porovnává s „e“ jednou nebo vůbec. |
| s | Porovnává s „s“. |
| (\s|$) | Porovná buď prázdný znak, nebo konec vstupního řetězce. |
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
Jiný než prázdný znak: \S
\S odpovídá jakémukoli prázdnému znaku. Je ekvivalentní vzoru regulárního výrazu [^\f\n\r\t\v\x85\p{Z}] nebo opaku vzoru regulárního výrazu, který odpovídá \sznakům prázdných znaků. Další informace naleznete v tématu Prázdný znak: \s.
Pokud je zadáno chování kompatibilní s ECMAScriptem, \S je ekvivalentní [^ \f\n\r\t\v]. Informace o regulárních výrazech ECMAScript naleznete v části "ECMAScript Matching Behavior" v části Možnosti regulárního výrazu.
Následující příklad znázorňuje \S prvek jazyka. Vzor regulárního výrazu \b(\S+)\s? odpovídá řetězcům, které jsou oddělené prázdnými znaky. Druhý prvek v objektu shody GroupCollection obsahuje odpovídající řetězec. Vzor regulárního výrazu může být interpretován tak, jak je uvedeno v následující tabulce.
| Element (Prvek) | Popis |
|---|---|
\b |
Začne porovnání na hranici slova. |
(\S+) |
Porovnává s jedním nebo více prázdnými znaky. Toto je první zachytávající skupina. |
\s? |
Porovná žádný nebo jeden prázdný znak. |
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.
Desetinná číslice znak: \d
\d odpovídá libovolné desítkové číslici. Je ekvivalentní vzoru regulárního výrazu \p{Nd} , který zahrnuje standardní desetinné číslice 0–9 a desítkové číslice počtu dalších znakových sad.
Pokud je zadáno chování kompatibilní s ECMAScriptem, \d je ekvivalentní [0-9]. Informace o regulárních výrazech ECMAScript naleznete v části "ECMAScript Matching Behavior" v části Možnosti regulárního výrazu.
Následující příklad znázorňuje \d prvek jazyka. Ověřuje, zda vstupní řetězec představuje platné telefonní číslo ve Spojených státech a Kanadě. Vzor regulárního výrazu ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ je definován, jak je znázorněno v následující tabulce.
| Element (Prvek) | Popis |
|---|---|
^ |
Zahájí porovnávání na začátku vstupního řetězce. |
\(? |
Porovnává s jedním nebo žádným literálním znakem "(". |
\d{3} |
Porovná tři desítkové číslice. |
\)? |
Porovnává s jedním nebo žádným literálním znakem ")". |
[\s-] |
Porovnává spojovník nebo prázdný znak. |
(\(?\d{3}\)?[\s-])? |
Porovnává volitelnou levou závorku následovanou třemi desítkovými číslicemi, volitelnou pravou závorku a prázdný znak nebo spojovník, jednou nebo vůbec. Toto je první zachytávající skupina. |
\d{3}-\d{4} |
Porovnává tři desítkové číslice následované spojovníkem a čtyřmi dalšími desítkovými číslicemi. |
$ |
Porovná konec vstupního řetězce. |
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
Neciferný znak: \D
\D odpovídá libovolnému necifernému znaku. Je ekvivalentní vzoru regulárního výrazu \P{Nd} .
Pokud je zadáno chování kompatibilní s ECMAScriptem, \D je ekvivalentní [^0-9]. Informace o regulárních výrazech ECMAScript naleznete v části "ECMAScript Matching Behavior" v části Možnosti regulárního výrazu.
Následující příklad ukazuje prvek jazyka \D. Ověřuje, zda se řetězec jako součást čísla skládá z vhodné kombinace desítkových a nedesítkových znaků. Vzor regulárního výrazu ^\D\d{1,5}\D*$ je definován, jak je znázorněno v následující tabulce.
| Element (Prvek) | Popis |
|---|---|
^ |
Zahájí porovnávání na začátku vstupního řetězce. |
\D |
Porovná nečíslicový znak. |
\d{1,5} |
Porovná jednu až pět desítkových číslic. |
\D* |
Porovná nulu, jednu nebo více ne desetinných znaků. |
$ |
Porovná konec vstupního řetězce. |
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:
Podporované obecné kategorie Unicode
Sada Unicode definuje obecné kategorie uvedené v následující tabulce. Další informace najdete v dílčích tématech "Formát souboru UCD" a "Obecné hodnoty kategorií" v databázi znaků Unicode, s. 5.7.1, tabulka 12.
| Kategorie | Popis |
|---|---|
Lu |
písmeno, velké písmeno |
Ll |
písmeno, malé písmeno |
Lt |
písmeno, velké počáteční písmeno |
Lm |
písmeno, modifikátor |
Lo |
písmeno, jiné |
L |
Všechny znaky písmena. To zahrnuje znak Lu, Ll, LtLm, a Lo znaky. |
Mn |
značka, bez mezer |
Mc |
značka, kombinování mezer |
Me |
značka, uzavření |
M |
Všechny zkombinující značky. To zahrnuje kategorie Mn, Mca Me kategorie. |
Nd |
číslo, desítková číslice |
Nl |
číslo, písmeno |
No |
číslo, jiné |
N |
Všechna čísla. To zahrnuje kategorie Nd, Nla No kategorie. |
Pc |
interpunkce, spojka |
Pd |
interpunkce, pomlčka |
Ps |
interpunkce, otevřená |
Pe |
interpunkce, uzavřená |
Pi |
interpunkce, počáteční uvozovka (může se chovat jako Ps nebo Pe v závislosti na použití) |
Pf |
interpunkce, koncová uvozovka (může se chovat jako Ps nebo Pe v závislosti na použití) |
Po |
interpunkce, jiné |
P |
Všechny znaky interpunkce. To zahrnuje kategorie Pc, , Pd, PePsPi, Pfa Po kategorie. |
Sm |
symbol, matematický |
Sc |
symbol, měna |
Sk |
symbol, modifikátor |
So |
symbol, jiný |
S |
Všechny symboly. To zahrnuje kategorie Sm, Sc, Ska So kategorie. |
Zs |
oddělovač, mezera |
Zl |
oddělovač, řádek |
Zp |
oddělovač, odstavec |
Z |
Všechny znaky oddělovačů. To zahrnuje kategorie Zs, Zla Zp kategorie. |
Cc |
jiný, ovládací prvek |
Cf |
jiný, formát |
Cs |
jiný, náhradník |
Co |
jiný, soukromé použití |
Cn |
Jiné, Nepřiřazené nebo Noncharacter |
C |
Všechny ostatní znaky. To zahrnuje kategorie Cc, , CsCf, Coa Cn kategorie. |
Kategorii Unicode libovolného konkrétního znaku můžete určit předáním tohoto znaku metodě GetUnicodeCategory . Následující příklad používá metodu GetUnicodeCategory k určení kategorie každého prvku v matici, která obsahuje vybrané znaky latinky.
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
Podporované pojmenované bloky
.NET poskytuje pojmenované bloky uvedené v následující tabulce. Množina podporovaných pojmenovaných bloků je založena na sadě Unicode 4.0 a Perl 5.6. Regulární výraz, který používá pojmenované bloky, naleznete v kategorii Unicode nebo bloku Unicode: \p{} oddíl.
| Rozsah bodu kódu | Název bloku |
|---|---|
| 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 | IsGreeknebo 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 | IsCombiningDiacriticalMarksforSymbolsnebo 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 nebo 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 |
Odčítání třídy znaků: [base_group - [excluded_group]]
Třída znaků definuje množinu znaků. Odčítání třídy znaků získává množinu znaků, která je výsledkem vyloučení znaků jedné třídy znaků, které jsou obsaženy v jiné třídě znaků.
Výraz odčítání třídy znaků má následující tvar:
[ -[ base_group excluded_group ]]
Hranaté závorky () a pomlčky ([]-) jsou povinné. Base_group je skupina kladných znaků nebo skupina záporných znaků. Komponenta excluded_group je jiná kladná nebo záporná skupina znaků nebo jiný výraz odčítání třídy znaků (to znamená, že můžete vnořit výrazy odčítání třídy znaků).
Předpokládejme například, že máte základní skupinu, která se skládá z rozsahu znaků od „a“ až do „z“. Chcete-li definovat sadu znaků, která se skládá ze základní skupiny s výjimkou znaku "m", použijte [a-z-[m]]. Chcete-li definovat sadu znaků, které se skládají ze základní skupiny s výjimkou sady znaků "d", "j" a "p", použijte [a-z-[djp]]. Chcete-li definovat sadu znaků, která se skládá ze základní skupiny s výjimkou rozsahu znaků od "m" až "p", použijte [a-z-[m-p]].
Zvažte výraz odčítání vnořené třídy znaků, [a-z-[d-w-[m-o]]]. Výraz je vyhodnocen od nejvnitřnějšího rozsahu znaků ven. Nejdříve se rozsah znaků od „m“ do „o“ odečte od rozsahu znaků „d“ až „w“, který dává množinu znaků od „d“ až „l“ a „p“ až „w“. Tato sada se pak odečte od rozsahu znaků od "a" až "z", která dává množinu znaků [abcmnoxyz].
Při odčítání třídy znaků můžete použít libovolnou třídu znaků. Chcete-li definovat sadu znaků, které se skládají ze všech znaků Unicode z \u0000 až \uFFFFFF s výjimkou prázdných znaků (\s), znaků v kategorii obecné interpunkce (\p{P}), znaků v IsGreek pojmenovaném bloku (\p{IsGreek}) a znaku ovládacího prvku Další řádek Unicode (\x85), použijte [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].
Zvolte třídy znaků pro výraz odčítání třídy znaků, které budou poskytovat užitečné výsledky. Vyhněte se výrazu, jehož výsledkem jsou prázdné množiny znaků, které nemohou odpovídat ničemu, nebo výrazu, který odpovídá původní základní skupině. Prázdná sada je například výsledkem výrazu [\p{IsBasicLatin}-[\x00-\x7F]], který odečte všechny znaky v rozsahu IsBasicLatin IsBasicLatin znaků od obecné kategorie. Podobně původní základní skupina je výsledkem výrazu [a-z-[0-9]]. Důvodem je skutečnost, že základní skupina, která je rozsahem znaků písmen od „a“ až do „z“, neobsahuje žádné znaky ve vyloučené skupině, která je rozsahem znaků desítkových číslic od „0“ až po „9“.
Následující příklad definuje regulární výraz, ^[0-9-[2468]]+$který odpovídá nule a liché číslice ve vstupním řetězci. Regulární výraz je interpretován tak, jak je uvedeno v následující tabulce.
| Element (Prvek) | Popis |
|---|---|
| ^ | Začne porovnávání na začátku vstupního řetězce. |
[0-9-[2468]]+ |
Porovnává jeden nebo více výskytů libovolného znaku od 0 do 9 s výjimkou 2, 4, 6 a 8. Jinými slovy, porovnává jeden nebo více výskytů nuly nebo liché číslice. |
| $ | Ukončí porovnávání na konci vstupního řetězce. |
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
