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 upravena s mož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($"'{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.

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($"'{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	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_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

Viz také

• GetUnicodeCategory
• Jazyk regulárních výrazů – stručná referenční dokumentace
• Možnosti regulárních výrazů