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ích výrazů 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 najdete v tématu Kladná skupina znaků.
Skupiny negativních znaků. Znak ve vstupním řetězci nesmí odpovídat jedné ze zadaných množin znaků. Další informace najdete 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á libovolnému znaku kromě\n. Další informace najdete 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 najdete v tématu Kategorie sady Unicode nebo Blok unicode.
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 najdete v tématech Negative Unicode Category nebo 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 najdete v tématu Word Znak.
Mimoslovní znak. Znak ve vstupním řetězci může patřit do jakékoli kategorie sady Unicode, která není znakem slova. Další informace najdete v tématu Bez Word znaku.
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 najdete v tématu Znak bez prázdných 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 najdete v tématu Znak desetinné číslice.
Nedesetinné číslo. Znakem ve vstupním řetězci může být jakýkoli jiný znak než desítková číslice sady Unicode. Další informace najdete v tématu Znak desetinné číslice.
.NET podporuje výrazy pro odčítání tříd znaků, které umožňují definovat sadu znaků v důsledku vyloučení jedné třídy znaků z jiné třídy znaků. Další informace najdete v tématu Odčítání tříd znaků.
Poznámka
Třídy znaků, které odpovídají znakům podle kategorie, například \w , aby odpovídaly znaky slov 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é se můžou zobrazit ve vstupním řetězci, aby byla shoda úspěšná. character_group se může skládat z libovolné 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]
where firstCharacter je znak, který začíná oblast, 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 nižším znakovým bodem a lastCharacter musí být znak s vyšším bodem kódu.
Poznámka
Vzhledem k tomu, že kladná skupina znaků může obsahovat sadu znaků i rozsah znaků, je znak spojovníku (-) vždy interpretován jako oddělovač rozsahu, pokud se nejedná o první nebo poslední znak skupiny.
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. Používá podvýraz k reprezentaci [A-Z] rozsahu 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 tak, 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. |
Skupina záporných 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é se nemohou zobrazit ve vstupním řetězci, aby byla shoda úspěšná. character_group se může skládat z libovolné 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*]
where firstCharacter je znak, který začíná oblast, 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 nižším znakovým bodem a lastCharacter musí být znak s vyšším bodem kódu.
Poznámka
Vzhledem k tomu, že záporná skupina znaků může obsahovat sadu znaků i rozsah znaků, je znak spojovníku (-) vždy interpretován jako oddělovač rozsahu, pokud se nejedná o první nebo poslední znak skupiny.
Mohou být spojeny dva nebo více rozsahů znaků. Pokud chcete například zadat rozsah desetinných číslic od "0" do "9", rozsah malých písmen od "a" do "f" a rozsah velkých písmen od "A" do "F", použijte [0-9a-fA-F].
Počáteční znak kurzoru (^) ve skupině záporných znaků je povinný a označuje, že skupina znaků je skupina záporných 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 tak, 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á libovolnému znaku s výjimkou \n (znak nového řádku) s následujícími dvěma kvalifikacemi:
Pokud je vzor regulárního výrazu RegexOptions.Singleline změněn možností nebo pokud je část vzoru obsahující
.třídu znaků upravenasmožností,.odpovídá libovolnému znaku. Další informace najdete v tématu Možnosti regulárního výrazu.Následující příklad znázorňuje odlišné 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í shoda končí na konci prvního řádku; vzor regulárního výrazu odpovídá znaku návratu řá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, odpovídá \r i třída znaků (znak vrátí znak).
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 najdete v části Kladná skupina znaků a Skupina záporných znaků dříve v tomto tématu. Následující příklad poskytuje ilustraci definování 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 jeden z pěti interpunkčních znamének, 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á libovolnému znaku . , je prvek jazyka často používán s opožděným kvantifikátorem, pokud se vzor regulárního výrazu pokusí spárovat libovolný znak vícekrát. Další informace najdete v tématu Kvantifikátory.
Kategorie unicode nebo blok Unicode: \p{}
Standard Unicode přiřadí každému znaku obecnou kategorii. Konkrétní 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á jakémukoli znaku, který patří do obecné kategorie unicode nebo pojmenovaného bloku, kde název je zkratka kategorie nebo název 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
Shoda může být vylepšena, pokud je řetězec nejprve normalizován voláním String.Normalize metody.
Následující příklad používá \p{ konstruktor názvu} tak, Pdaby odpovídal obecné kategorii Unicode (v tomto případě , nebo Interpunkční znaména, kategorie Dash) a pojmenovaný blok (IsGreekpojmenované bloky aIsBasicLatin).
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 tak, 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. Konkrétní 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á jakémukoli znaku, který nepatří do obecné kategorie unicode nebo pojmenovaného bloku, kde název je zkratka kategorie nebo název 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
Shoda může být vylepšena, pokud je řetězec nejprve normalizován voláním String.Normalize metody.
Následující příklad používá \P{ konstruktor name} k odebrání všech symbolů měny (v tomto případě Sckategorie , nebo Symbol, Měna) 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 (\P{Sc})+ regulárního výrazu odpovídá jednomu nebo více znakům, které nejsou symboly měny. Ve skutečnosti z výsledného řetězce odebere jakýkoli symbol měny.
Word znak: \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, Lowercase |
| 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 zadané chování kompatibilní s ECMAScriptem, \w je ekvivalentní k [a-zA-Z_0-9]. Informace o regulárních výrazech ECMAScript najdete v části "Chování při porovnávání jazyka ECMAScript" v tématu Možnosti regulárních výrazů.
Poznámka
Vzhledem k tomu, že odpovídá libovolnému znaku slova, \w je prvek jazyka často používán s opožděným kvantifikátorem, pokud se vzor regulárního výrazu pokusí spárovat libovolný znak slova vícekrát, následovaný určitým znakem slova. Další informace najdete v tématu Kvantifikátory.
Následující příklad používá \w element language ke spárování 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 | 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á jakémukoli jinému než slovu. 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á všem znakům s výjimkou znaků v kategoriích Unicode uvedených v následující tabulce.
| Kategorie | Popis |
|---|---|
| Ll | Letter, Lowercase |
| 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 zadané chování kompatibilní s ECMAScriptem, \W je ekvivalentní k [^a-zA-Z_0-9]. Informace o regulárních výrazech ECMAScript najdete v části "Chování při porovnávání v jazyce ECMAScript" v tématu Možnosti regulárních výrazů.
Poznámka
Vzhledem k tomu, že odpovídá jakémukoli neslovnímu znaku, \W je prvek jazyka často používán s opožděným kvantifikátorem, 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 najdete 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, jako jsou prázdné znaky nebo interpunkce. Regulární výraz je interpretován tak, jak je uvedeno v následující tabulce.
| Element | 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, načte příklad všechny zachycené neslovné znaky z objektu CaptureCollection , který je vrácen Group.Captures vlastností .
Prázdný znak: \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. Patří sem Zskategorie , Zla Zp . |
Pokud je zadané chování kompatibilní s ECMAScriptem, \s je ekvivalentní k [ \f\n\r\t\v]. Informace o regulárních výrazech ECMAScript najdete v části "Chování při porovnávání v jazyce ECMAScript" v tématu Možnosti regulárních výrazů.
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", za kterým následuje prázdný znak nebo konec vstupního řetězce. Regulární výraz je interpretován tak, jak je uvedeno v následující tabulce.
| Element | 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á 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 jinému než prázdnému znaku. Je ekvivalentní vzoru regulárního [^\f\n\r\t\v\x85\p{Z}] výrazu nebo je opakem vzoru regulárního výrazu, který je ekvivalentní k \s, který odpovídá prázdným znakům. Další informace najdete v tématu Prázdný znak: \s.
Pokud je zadané chování kompatibilní s ECMAScriptem, \S je ekvivalentní k [^ \f\n\r\t\v]. Informace o regulárních výrazech ECMAScript najdete v části "Chování při porovnávání v jazyce ECMAScript" v tématu Možnosti regulárních výrazů.
Následující příklad znázorňuje \S element language. Vzor \b(\S+)\s? regulárního výrazu odpovídá řetězcům odděleným prázdnými znaky. Druhý prvek v objektu match 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 | 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.
Znak desetinné číslice: \d
\d odpovídá libovolné desítkové číslici. Je ekvivalentní vzoru regulárního \p{Nd} výrazu, který zahrnuje standardní desetinné číslice 0–9 a také desetinné číslice řady dalších znakových sad.
Pokud je zadané chování kompatibilní s ECMAScriptem, \d je ekvivalentní k [0-9]. Informace o regulárních výrazech ECMAScript najdete v části "Chování při porovnávání v jazyce ECMAScript" v tématu Možnosti regulárních výrazů.
Následující příklad znázorňuje \d element language. Ověřuje, zda vstupní řetězec představuje platné telefonní číslo ve Spojených státech a Kanadě. Vzor ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ regulárního výrazu je definovaný tak, jak je znázorněno v následující tabulce.
| Element | 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á jakémukoli necifernému znaku. Je ekvivalentní vzoru regulárního výrazu \P{Nd} .
Pokud je zadané chování kompatibilní s ECMAScriptem, \D je ekvivalentní k [^0-9]. Informace o regulárních výrazech ECMAScript najdete v části "Chování při porovnávání v jazyce ECMAScript" v tématu Možnosti regulárních výrazů.
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 ^\D\d{1,5}\D*$ regulárního výrazu je definovaný tak, jak je znázorněno v následující tabulce.
| Element | 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á nula, jeden 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 podtémech 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 |
Letter, Lowercase |
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 Luznaky , Ll, Lt, Lma Lo . |
Mn |
značka, bez mezer |
Mc |
značka, kombinování mezer |
Me |
značka, uzavření |
M |
Všechny značky kombinování. Patří sem Mnkategorie , Mca Me . |
Nd |
číslo, desítková číslice |
Nl |
číslo, písmeno |
No |
číslo, jiné |
N |
Všechna čísla. Patří sem Ndkategorie , Nla No . |
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 Pckategorie , , Pd, PePs, Pi, Pf, a Po . |
Sm |
symbol, matematický |
Sc |
symbol, měna |
Sk |
symbol, modifikátor |
So |
symbol, jiný |
S |
Všechny symboly. Patří sem Smkategorie , Sc, Ska So . |
Zs |
oddělovač, mezera |
Zl |
oddělovač, řádek |
Zp |
oddělovač, odstavec |
Z |
Všechny znaky oddělovačů. Patří sem Zskategorie , Zla Zp . |
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 nezvyklé |
C |
Všechny ostatní znaky. To zahrnuje Cckategorie , Cf, Cs, Coa Cn . |
Kategorii unicode libovolného konkrétního znaku můžete určit předáním tohoto znaku GetUnicodeCategory metodě . 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, najdete v části Kategorie unicode nebo Blok Unicode: \p{} .
| 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 | IsGreek-nebo- 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-nebo- 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_groupexcluded_group]]
Hranaté závorky ([]) a spojovník (-) jsou povinné. base_group je kladná nebozáporná skupina 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“. Pokud chcete definovat sadu znaků, která se skládá ze základní skupiny s výjimkou znaku "m", použijte [a-z-[m]]. Pokud chcete definovat sadu znaků, která se skládá ze základní skupiny s výjimkou sady znaků "d", "j" a "p", použijte [a-z-[djp]]. Pokud chcete definovat sadu znaků, která se skládá ze základní skupiny s výjimkou rozsahu znaků od "m" do "p", použijte [a-z-[m-p]].
Představte si vnořený výraz [a-z-[d-w-[m-o]]]odčítání třídy znaků . 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" do "z", což dává množinu znaků [abcmnoxyz].
Při odčítání třídy znaků můžete použít libovolnou třídu znaků. Pokud chcete definovat sadu znaků, která se skládá ze všech znaků Unicode od \u0000 do \uFFFF s výjimkou prázdných znaků (\s), znaků v kategorii interpunkce obecné (\p{P}), znaků v IsGreek pojmenovaném bloku (\p{IsGreek}) a řídicího znaku Unicode NEXT LINE (\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ě. Například prázdná sada je výsledkem výrazu [\p{IsBasicLatin}-[\x00-\x7F]], který odečte všechny znaky v rozsahu IsBasicLatin znaků od IsBasicLatin 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 | 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
Viz také
.NET feedback
The .NET documentation is open source. Provide feedback here.
Váš názor
Odeslat a zobrazit názory pro