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 ve skupině 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 Negativní skupina znaků.
Libovolný znak. Znak . ("tečka" nebo "období") v regulárním výrazu je zástupný znak (wildcard), který odpovídá jakémukoli znaku kromě \n. Pro více informací si přečtěte 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 Negativní kategorie Unicode nebo blok Unicode.
Slovní znak. 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 znak Word.
Mimoslovní znak. Znak ve vstupním řetězci může patřit do libovolné kategorie Unicode, která není znakem slova. Další informace naleznete v tématu Neznakový znak.
Prázdný znak. Znak ve vstupním řetězci může být libovolný znak oddělovače Unicode a libovolný z mnoha řídicích znaků. Další informace najdete v tématu Prázdný znak.
Neprázdný znak. Znak ve vstupním řetězci může být libovolný znak, který není prázdným znakem. Pro více informací viz Neprázdné znaky.
Desítková číslice. Znak ve vstupním řetězci může být libovolný znak klasifikovaný jako desítková číslice Unicode. Další informace naleznete 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 naleznete v tématu Znak desetinné číslice.

.NET podporuje výrazy odčítání tříd znaků, které umožňují definovat sadu znaků jako výsledek vyloučení jedné třídy znaků z jiné třídy znaků. Další informace naleznete 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 znakům slova nebo {}, aby odpovídaly kategorii Unicode, spoléhají na CharUnicodeInfo třídu, která poskytuje informace o kategoriích znaků. V .NET Framework 4.6.2 a novějších verzích jsou kategorie znaků založené na Soubor standardu Unicode verze 8.0.0.

Skupina kladných znaků: [ ]

Skupina kladných znaků určuje seznam znaků, z nichž každý se může objevit ve vstupním řetězci, aby se shodovaly. Tento seznam znaků může být zadán jednotlivě, jako rozsah, nebo oběma způsoby.

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 objevit ve vstupním řetězci, aby shoda uspěla. character_group se mohou skládat z jakékoli kombinace jednoho nebo více literální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.

Aby byl spojovník zahrnut jako neperiferní člen skupiny znaků, escapujte 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]`	Porovnejte všechny samohlásky.
`[\p{P}\d]`	Zachyťte všechny interpunkční 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ě.

static void PositiveCharacterGroup()
{
    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.'

Sub PositiveCharacterGroup()
    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
' 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`	Shoda s literálními znaky „gr“.
`[ae]`	Porovná buď se znakem „a“, nebo s „e“.
`y\s`	Porovnej literální znak „y“ následovaný mezerou.
`\S+?`	Zachytí jeden nebo více znaků, které nejsou mezerami, ale 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 se shodují slova začínající jakýmkoli velkým písmenem. Pomocí dílčího výrazu [A-Z] představuje rozsah velkých písmen od A do Z.

static void CharacterRange()
{
    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

Sub CharacterRange()
    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
' The example displays the following output:
'       A
'       Albany
'       Zulu
'       Marseilles

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čněte na hranici slova.
`[A-Z]`	Odpovídá libovolnému velkému písmenu od A do Z.
`\w*`	Porovná nulu nebo více znaků slova.
`\b`	Zachyťte okraj 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ů lze zadat jednotlivě, 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é nesmějí být ve vstupním řetězci, aby byla shoda úspěšná. character_group se mohou skládat z jakékoli kombinace jednoho nebo více literálních znaků, řídicích znaků nebo tříd znaků.

Syntaxe pro zadání rozsahu znaků je následující:

[^*firstCharacter*-*lastCharacter*]

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.

Dva nebo více rozsahů znaků lze spojit. 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é

Záporná skupina znaků ve větším vzoru regulárního výrazu není kontrolní výraz s nulovou šířkou. 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]`	Srovnej všechny znaky kromě samohlásek.
`[^\p{P}\d]`	Najdi všechny znaky kromě interpunkčních znaků a číslic.

Následující příklad odpovídá jakémukoli slovu, které začíná znaky "th" a není následované znakem "o".

static void NegativeCharacterGroup()
{
    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

Sub NegativeCharacterGroup()
    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
' 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čněte na hranici slova.
`th`	Porovnávejte doslovné znaky „th“.
`[^o]`	Odpovídá jakémukoli znaku, který není "o".
`\w+`	Porovná jeden nebo více znaků slova.
`\b`	Konec na hranici slova.

Libovolný znak: .

Znak tečky (.) odpovídá jakémukoli znaku kromě znaku nového řádku \n s následujícími dvěma podmínkami:

Pokud je vzor regulárního výrazu RegexOptions.Singleline upraven možností nebo pokud část vzoru, který obsahuje . třídu znaků, je upravena s možností, . odpovídá libovolnému znaku. Další informace naleznete v tématu Možnosti regulárních výrazů.

Počínaje .NET 11, pokud je zadána možnost RegexOptions.AnyNewLine, . vyloučí všechny běžné nové řádky namísto pouze \n. Pokud jsou zadány obě Singleline a AnyNewLine, Singleline má přednost a . odpovídá každému znaku. Další informace naleznete v režimu AnyNewLine.

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á znaku návratu na začátek řá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.

static void AnyCharacterMultiline()
{
    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\.

Sub AnyCharacterMultiline()
    Dim pattern As String = "^.+"
    Dim input As String = "This is one line and" + Environment.NewLine + "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
' 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 (návratový znak řádku). S RegexOptions.AnyNewLine. vylučuje \r a také další sekvence nového řádku.

Ve skupině pozitivních nebo negativních znaků se s tečkou zachází jako s doslovným znakem tečky, nikoli jako s třídou znaků. Další informace naleznete v části Skupina kladných znaků a Skupina záporných znaků dříve v tomto článku. 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.
```
static void AnyCharacterSingleline()
{
    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.
```
```
Sub AnyCharacterSingleline()
    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
' The example displays the following output:
'       this. what: is? go, thing.
```

Poznámka:

Vzhledem k tomu, že odpovídá jakémukoli znaku ., jazykový prvek se často používá s lenivým kvantifikátorem, pokud se regulární výraz pokusí spárovat libovolný znak vícekrá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 článku. Seznam pojmenovaných bloků najdete v části Podporované pojmenované bloky dále v tomto článku.

Tip

Porovnávání lze zlepšit, pokud je řetězec nejprve normalizován voláním String.Normalize metody.

Následující příklad používá \p{konstrukci na jméno}, který odpovídá obecné kategorii Unicode (v tomto případě, Pd Interpunkce, kategorie Pomlčka) a pojmenované bloky ( IsGreek a IsBasicLatin pojmenované bloky).

static void UnicodeCategory()
{
    string pattern = @"\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+";
    string input = "Ελληνική Γλώσσα - Greek Language";

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

Sub UnicodeCategory()
    Dim pattern As String = "\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+"
    Dim input As String = "Ελληνική Γλώσσα - Greek Language"

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

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čněte 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á vzor jednoho nebo více znaků řecké abecedy, následovaný žádným nebo jedním prázdným znakem, který se vyskytuje jednou nebo vícekrát.
`\p{Pd}`	Porovnejte znak interpunkce, pomlčku.
`\s`	Porovná prázdný znak.
`\p{IsBasicLatin}+`	Odpovídá jednomu nebo více latinským znakům.
`(\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{}

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 bloku. Seznam zkratek kategorií najdete v části Podporované obecné kategorie unicode dále v tomto článku. Seznam pojmenovaných bloků najdete v části Podporované pojmenované bloky dále v tomto článku.

Tip

Porovnávání lze zlepšit, pokud je řetězec nejprve normalizován voláním String.Normalize metody.

Následující příklad používá \P{název} ke odstranění všech symbolů měny (v tomto případě kategorie Sc, Symbol, Měna) z číselných řetězců.

static void NegativeUnicodeCategory()
{
    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

Sub NegativeUnicodeCategory()
    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
' 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é
Lu	Velké písmeno
Lt	znak, Velké písmeno
Lo	Jiný znak, písmeno
Lm	písmeno, modifikátor
Mn	značka, neodsazovací
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 Možnosti regulárního výrazu.

Poznámka:

Vzhledem k tomu, že prvek jazyka \w odpovídá libovolnému slovnímu znaku, je často používán s opožděným kvantifikátorem, pokud se vzor regulárního výrazu pokouší několikrát spárovat libovolný slovní znak, následovaný konkrétním slovním znakem. 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	Porovnejte hodnotu prvního záchytu.

static void WordCharacter()
{
    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($"'{match.Value}' found in '{word}' at position {match.Index}.");
        else
            Console.WriteLine($"No double characters in '{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.

Sub WordCharacter()
    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($"'{match.Value}' found in '{word}' at position {match.Index}.")
        Else
            Console.WriteLine($"No double characters in '{word}'.")
        End If
    Next
End Sub
' 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{Lm}\p{Mn}\p{Nd}\p{Pc}]

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é
Lu	Velké písmeno
Lt	znak, Velké písmeno
Lo	Jiný znak, písmeno
Lm	písmeno, modifikátor
Mn	značka, neodsazovací
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 Možnosti regulárního výrazu.

Poznámka:

Jelikož odpovídá libovolnému neslovnímu znaku, se prvek jazyka \W často používá 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 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čněte shodu na hranici slova.
(\w+)	Porovná jeden nebo více znaků slova. Toto je první zachytávající skupina.
(\W){1,2}	Odpovídá mimoslovnímu znaku jednou nebo dvakrát. Toto je druhá zachytávající skupina.

static void NonWordCharacter()
{
    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)

Sub NonWordCharacter()
    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
' 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 bílého místa: \s

\s odpovídá jakémukoli prázdnému znaku. Odpovídá únikovým sekvencím a kategoriím Unicode uvedeným v následující tabulce.

Kategorie	Popis
`\f`	Znak přeřazení formátu 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 oddělovacím znakům. To zahrnuje kategorie `Zs`, `Zl` a `Zp`.

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 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čněte shodu na hranici slova.
\w+	Porovná jeden nebo více znaků slova.
(e)?	Odpovídá „e“ nula nebo jednou.
s	Najít „s“.
(\s\|$)	Porovná buď prázdný znak, nebo konec vstupního řetězce.

static void WhitespaceCharacter()
{
    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

Sub WhitespaceCharacter()
    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
' The example displays the following output:
'       matches
'       stores
'       stops
'       leaves

Neprázdný znak: \S

\S odpovídá jakémukoli znaku, který není bílým znakem. Je ekvivalentní k vzoru regulárního výrazu [^\f\n\r\t\v\x85\p{Z}] nebo opaku vzoru, který odpovídá regulárnímu výrazu ekvivalentnímu k \s, jež odpovídá prázdným znakům. Další informace naleznete v tématu Znak bílého místa: \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 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čněte shodu na hranici slova.
`(\S+)`	Odpovídá jednomu nebo více neprázdným znakům. Toto je první zachytávající skupina.
`\s?`	Porovná žádný nebo jeden prázdný znak.

static void NonWhitespaceCharacter()
{
    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.

Sub NonWhitespaceCharacter()
    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." + Environment.NewLine +
                          "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
' 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. Odpovídá vzoru regulárního výrazu \p{Nd} , který zahrnuje standardní desetinné číslice 0–9 a desítkové číslice mnoha 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 Možnosti regulárního výrazu.

Následující příklad znázorňuje \d prvek jazyka. Testuje, zda vstupní řetězec představuje platné telefonní číslo v USA 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
`^`	Začněte porovnání na začátku vstupního řetězce.
`\(?`	Odpovídá nula nebo jednomu literálnímu znaku "(".
`\d{3}`	Porovná tři desítkové číslice.
`\)?`	Odpovídá jednomu nebo žádnému literálnímu znaku ")".
`[\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.
`$`	Odpovídá konci vstupního řetězce.

static void DigitCharacter()
{
    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

Sub DigitCharacter()
    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
' 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. Odpovídá 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 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
`^`	Začněte porovnání na začátku vstupního řetězce.
`\D`	Vyhledej znak, který není číslice.
`\d{1,5}`	Porovná jednu až pět desítkových číslic.
`\D*`	Zjistěte výskyt nuly, jednoho nebo více ne-desetinných znaků.
`$`	Odpovídá konci vstupního řetězce.

static void NonDigitCharacter()
{
    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

Sub NonDigitCharacter()
    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
' The example displays the following output:
'       A1039C: matched
'       AA0001: match failed
'       C18A: matched
'       Y938518: match failed

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`	Velké písmeno
`Ll`	písmeno, malé
`Lt`	znak, Velké písmeno
`Lm`	písmeno, modifikátor
`Lo`	Jiný znak, písmeno
`L`	Všechny písmena. To zahrnuje znak `Lu`, `Ll`, `LtLm`, a `Lo` znaky.
`Mn`	značka, neodsazovací
`Mc`	značka, kombinování mezer
`Me`	značka, uzávěr
`M`	Všechny kombinační značky. To zahrnuje kategorie `Mn`, `Mc` a `Me`.
`Nd`	číslo, desítková číslice
`Nl`	číslo, písmeno
`No`	číslo, ostatní
`N`	Všechna čísla. To zahrnuje kategorie `Nd`, `Nl` a `No`.
`Pc`	Interpunkce, spojovník
`Pd`	interpunkce, pomlčka
`Ps`	interpunkce, otevřená
`Pe`	interpunkce, uzavřená
`Pi`	Interpunkce, počáteční uvozovka (může se v závislosti na využití chovat jako Ps nebo Pe)
`Pf`	Interpunkce, konečná uvozovka (v závislosti na využití se může chovat jako Ps nebo Pe)
`Po`	interpunkce, jiné
`P`	Všechny znaky interpunkce. To zahrnuje kategorie `Pc`, `Pd`, `Ps`, `Pe`, `Pi`, `Pf` a `Po`.
`Sm`	symbol, matematický
`Sc`	symbol, měna
`Sk`	Symbol, Modifikátor
`So`	Symbol, Ostatní
`S`	Všechny symboly. To zahrnuje kategorie `Sm`, `Sc`, `Sk`a `So` kategorie.
`Zs`	oddělovač, mezera
`Zl`	oddělovač, čára
`Zp`	oddělovač, odstavec
`Z`	Všechny znaky oddělovačů. To zahrnuje kategorie `Zs`, `Zl` a `Zp`.
`Cc`	jiný, Ovládání
`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`, `Cf`, `Cs`, `Co` a `Cn`.

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.

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

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

Sub GetUnicodeCategory()
    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
' 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. Sada podporovaných pojmenovaných bloků je založena na systému Unicode verze 4.0 a na Perl 5.6. Regulární výraz, který používá pojmenované bloky, naleznete v sekci kategorie Unicode nebo bloku 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`
Rozsah Unicode znaků: 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ů směrem 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].

Můžete použít libovolnou třídu znaků s odčítáním tříd 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ý poskytuje užitečné výsledky. Vyhněte se výrazu, který poskytuje prázdnou sadu znaků, která nemůže odpovídat ničemu nebo výrazu, který je ekvivalentní 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 od obecné kategorie IsBasicLatin. Podobně původní základní skupina je výsledkem výrazu [a-z-[0-9]]. Důvodem je to, že základní skupina, což je oblast znaků písmen od "a" do "z", neobsahuje žádné znaky ve vyloučené skupině, což je oblast znaků desetinných číslic od "0" do "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čněte 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.

static void CharacterClassSubtraction()
{
    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

Sub CharacterClassSubtraction()
    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
' The example displays the following output:
'       13579753
'       335599901

Viz také

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-03-31

Třídy znaků v regulárních výrazech

Skupina kladných znaků: [ ]

Záporná skupina znaků: [^]

Libovolný znak: .

Kategorie unicode nebo blok Unicode: \p{}

Negativní kategorie Unicode nebo blok Unicode: \P{}

znak slova: \w

Neslovný znak: \W

Znak bílého místa: \s

Neprázdný znak: \S

Znak desetinné číslice: \d

Neciferný znak: \D

Podporované obecné kategorie Unicode

Podporované pojmenované bloky

Odčítání třídy znaků: [base_group - [excluded_group]]

Viz také

Váš názor

Další materiály