Sdílet prostřednictvím

Třídy znaků

  • Článek

Třída znaků definuje množinu znaků, které se mohou objevit ve vstupním řetězci pro úspěšné porovnání. Jazyk regulárních výrazů v rozhraní .NET Framework podporuje následující třídy znaků:

  • Skupiny pozitivních znaků. Znak ve vstupním řetězci musí odpovídat některé určité množině znaků. Další informace naleznete v tématu Skupina pozitivních znaků.

  • Skupiny negativních znaků. Znak ve vstupním řetězci nesmí odpovídat některé určité množině znaků. Další informace naleznete v tématu Skupina negativních znaků.

  • Jakýkoli znak. Znak . (tečka) je v regulárním výrazu zástupným znakem, který odpovídá libovolnému znaku kromě \n. Další informace naleznete v tématu Jakýkoli znak.

  • Obecná kategorie nebo pojmenovaný blok sady Unicode. Pro úspěšné porovnání 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 Kategorie sady Unicode nebo blok sady Unicode.

  • Negativní obecná kategorie nebo pojmenovaný blok sady Unicode. Pro úspěšné porovnání nesmí být znak ve vstupním řetězci členem určité kategorie sady Unicode, nebo nesmí spadat do souvislého rozsahu znaků sady Unicode. Další informace naleznete v tématu Negativní kategorie sady Unicode nebo blok sady 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 tématu Slovní znak.

  • Mimoslovní znak. Znak ve vstupním řetězci může patřit do jakékoli kategorie sady Unicode, která není slovním znakem. Další informace naleznete v tématu Mimoslovní znak.

  • Prázdný znak. Znak ve vstupním řetězci může být jakýkoli oddělovací znak sady Unicode nebo některý z řídicích znaků. Další informace naleznete v tématu Prázdný znak.

  • Neprázdný znak. Znak ve vstupní řetězci může být libovolný znak, který není prázdným znakem. Další informace naleznete v tématu Neprázdný znak.

  • Desítková číslice. Znak ve vstupním řetězci může být kterýkoli ze znaků, které jsou klasifikovány jako desítková číslice sady Unicode. Další informace naleznete v tématu Znak desítkové číslice.

  • Nedesítková číslice. Znak 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 desítkové číslice.

Rozhraní .NET Framework podporuje výrazy odčítání tříd znaků, které umožňují definovat množinu znaků jakožto výsledek vyloučení jedné třídy znaků vůči jiné třídě znaků. Další informace naleznete v tématu Odčítání tříd znaků.

Skupina pozitivních znaků. [ ]

Pozitivní skupina znaků určuje seznam znaků, které se mohou objevit ve vstupním řetězci, aby nastala shoda. Tento seznam znaků může být zadán jako jednotlivé znaky, jako rozsah nebo obojí.

Syntaxe pro určení seznamu jednotlivých znaků je následující:

character_group

kde character_group je seznam jednotlivých znaků, které se mohou objevit ve vstupním řetězci pro úspěšnou shodu. character_group se může skládat z jakékoli kombinace jednoho nebo více literálních znaků, uvozovacích znaků nebo tříd znaků.

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

[firstCharacter-lastCharacter]

kde firstCharacter je znak, který je na začátku rozsahu a lastCharacter je znak, který je na konci rozsahu. Rozsah znaků je souvislá řada znaků definovaná zadáním prvního znaku v řadě, pomlčky (-) a posledního znaku v řadě. Dva znaky jsou souvislé, pokud mají sousedící kódové body sady Unicode.

Některé běžné vzory regulárních výrazů, které obsahují pozitivní třídy znaků jsou uvedeny v následující tabulce.

Maska

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á se všemi prázdnými znaky a znaky interpunkce.

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ě.

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.

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.

Vzor regulárního výrazu gr[ae]y\s\S+?[\s|\p{P}] je definován následujícím způsobem:

Maska

Popis

gr

Porovná s literálními znaky "gr".

[ae]

Porovná buď s "a" nebo s "e".

y\s

Porovná s literálním znakem "y" následovaný prázdným znakem.

\S+?

Porovná s jedním nebo více neprázdnými znaky, ale co s 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í jakýmkoli velkým písmenem. Je použit podvýraz [A-Z] k reprezentaci rozsahu velkých písmen od A až do Z.

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

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

Regulární výraz \b[A-Z]\w*\b je definován podle následující tabulky.

Maska

Popis

\b

Začne na hranici slova.

[A-Z]

Porovná s libovolným znakem velkého písmena od A až do Z.

\w*

Porovná žádný nebo více znaků slova.

\b

Porovná hranici slova.

Zpět na začátek

Skupina negativních znaků: [^]

Skupina negativních znaků určuje seznam znaků, které se nesmí objevit ve vstupním řetězci, aby došlo ke shodě. seznam znaků může být zadán jako jednotlivé znaky, jako rozsah nebo obojí.

Syntaxe pro určení seznamu jednotlivých znaků je následující:

^ character_group

kde character_group je seznam jednotlivých znaků, které se nesmí objevit ve vstupním řetězci pro úspěšnou shodu. character_group se může skládat z jakékoli kombinace jednoho nebo více literálních znaků, uvozovacích znaků nebo tříd znaků.

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

^firstCharacter-lastCharacter

kde firstCharacter je znak, který je na začátku rozsahu a lastCharacter je znak, který je na konci rozsahu. Rozsah znaků je souvislá řada znaků definovaná zadáním prvního znaku v řadě, pomlčky (-) a posledního znaku v řadě. Dva znaky jsou souvislé, pokud mají sousedící kódové body sady Unicode.

Mohou být spojeny dva nebo více rozsahů znaků. Například, chcete-li určit rozsah desítkových číslic "0" až "9", rozsah malých písmen "a" až "f" a rozsah velkých písmen od "A" až po "F" použijte [0-9a-fA-F].

Uvozovací znak stříšky (^) u skupiny negativních znaků je povinný a označuje, že je daná skupina znaků skupinou negativních znaků, nikoli skupinou pozitivních znaků.

Důležitá poznámkaDůležité

Skupina negativních znaků ve větším vzoru regulárního výrazu není 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.

Maska

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".

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

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

Regulární výraz \bth[^o]\w+\b je definován podle následující tabulky.

Maska

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 slovních znaků.

\b

Skončí na hranici slova.

Zpět na začátek

Jakýkoli znak: .

Znak tečky (.) odpovídá libovolnému znaku kromě \n (znak nového řádku, \u000A), se dvěma následujícími kvalifikacemi:

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

    Následující příklad ukazuje různé chování třídy znaků . ve výchozím nastavení a s možností RegexOptions.Singleline. Regulární výraz ^.+ začíná na začátku řetězce a porovnává s každým znakem. Standardně je porovnávání ukončeno na konci prvního řádku. Vzorek regulárního výrazu porovnává znak pro návrat na začátek řádku, \r nebo \u000D, ale ten neodpovídá \n. Protože možnost RegexOptions.Singleline interpretuje celý vstupní řetězec jako jediný řádek, porovnává každý znak ve vstupním řetězci včetně \n.

    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\.

    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\.
PoznámkaPoznámka

Protože odpovídá libovolnému znaku kromě \n, třída znaků . se shoduje také s \r (zpětný znak, \u000D).

  • 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 dřívějších oddílech tohoto tématu Skupina pozitivních znaků a Skupina negativních znaků. Následující příklad ilustruje definování regulárního výrazu, který obsahuje znak tečky (.) jako třídu znaků i jako člena skupiny pozitivních znaků. Regulární výraz \b.*[.?!;:](\s|\z) začíná na hranici slova, porovnává libovolné znaky dokud nenarazí na jedno ze čtyř interpunkčních znamének, včetně tečky a potom porovnává prázdné znaky nebo konec řetězce.

    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.

    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.
PoznámkaPoznámka

Protože odpovídá libovolnému znaku, prvek jazyka . se často používá s líným kvantifikátorem, pokud se vzor regulárního výrazu pokusí vícekrát porovnávat jakýkoli znak.Další informace naleznete v tématu Kvantifikátory.

Zpět na začátek

Kategorie sady Unicode nebo blok sady Unicode: \p{}

Standard Unicode přiřadí každému znaku obecnou kategorii. Například může být určitý znak velké písmeno (představované kategorií Lu), desítková číslice (kategorie Nd), matematický symbol (kategorie Sm), nebo oddělovač odstavců (kategorie Zl). Určité množiny znaků sady Unicode zabírají také určité oblasti nebo bloky po sobě následujících kódových bodů. 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{název}

porovnává s libovolným znakem, který patří do obecné kategorie sady Unicode nebo pojmenovaného blok, kde název je zkratka pro kategorii nebo název pojmenované bloku. Seznam zkratek kategorií naleznete v pozdějším oddílu tohoto tématu Podporované obecné kategorie sady Unicode. Seznam pojmenovaných bloků naleznete v pozdějším oddílu tohoto tématu Podporované pojmenované bloky.

V následujícím příkladu je použita konstrukce \p{název} tak, aby porovnávala jak obecnou kategorii sady Unicode (v tomto případě Pd, nebo kategorii interpunkčního znaménka či pomlčky), tak i pojmenovaný blok (pojmenované bloky IsGreek a IsBasicLatin).

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

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.
   }
}

Regulární výraz \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ je definován podle následující tabulky.

Maska

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á vzorek jednoho nebo více znaků základní latinky následovaný žádným nebo jedním prázdným znakem jednou nebo vícekrát.

Zpět na začátek

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

Standard Unicode přiřadí každému znaku obecnou kategorii. Například může být určitý znak velké písmeno (představované kategorií Lu), desítková číslice (kategorie Nd), matematický symbol (kategorie Sm), nebo oddělovač odstavců (kategorie Zl). Určité množiny znaků sady Unicode zabírají také určité oblasti nebo bloky po sobě následujících kódových bodů. 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{název}

porovnává s libovolným znakem, který nepatří do obecné kategorie sady Unicode nebo pojmenovaného blok, kde název je zkratka pro kategorii nebo název pojmenované bloku. Seznam zkratek kategorií naleznete v pozdějším oddílu tohoto tématu Podporované obecné kategorie sady Unicode. Seznam pojmenovaných bloků naleznete v pozdějším oddílu tohoto tématu Podporované pojmenované bloky.

V následujícím příkladu je použita konstrukce \P{název} pro odebrání jakýchkoli symbolů měny (v tomto případě Sc nebo kategorie symbolu, měny) z číselných řetězců.

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

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

Vzor regulárního výrazu (\P{Sc})+ porovnává jeden nebo více znaků, které nejsou symboly měny; efektivně odděluje libovolný symbol měny z výsledného řetězce.

Zpět na začátek

Slovní znak. \w

\w odpovídá libovolnému slovnímu znaku. Slovní znak 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, nadpisové písmeno

Lo

písmeno, jiné

Lm

písmeno, modifikátor

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 specifikováno chování standardu ECMAScript, \w je ekvivalentní s [a-zA-Z_0-9]. Informace o regulárních výrazech jazyka ECMAScript naleznete v oddílu "ECMAScript chování porovnávání" v tématu Možnosti regulárních výrazů.

PoznámkaPoznámka

Protože odpovídá libovolnému slovnímu znaku, prvek jazyka \w se často používá s líný kvantifikátor, pokud se vzor regulárního výrazu pokusí porovnat libovolný slovní znak několikrát, následovaný určitým slovním znakem.Další informace naleznete v tématu Kvantifikátory.

V následujícím příkladu je použit prvek jazyka \w tak, aby porovnával duplicitní slovní znaky. V příkladu je definován vzor regulárního výrazu (\w)\1, který lze interpretovat následujícím způsobem.

Prvek

Popis

(\w)

Porovnává slovní znak. Toto je první zachytávající skupina.

\1

Porovnává hodnotu prvního zachycení.

 
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.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\w)\1";
      string[] words = { "trellis", "seer", "latter", "summer", 
                         "hoarse", "lesser", "aardvark", "stunned" };
      foreach (string word in words)
      {
         Match match = Regex.Match(word, pattern);
         if (match.Success)
            Console.WriteLine("'{0}' found in '{1}' at position {2}.", 
                              match.Value, word, match.Index);
         else
            Console.WriteLine("No double characters in '{0}'.", word);
      }                                                  
   }
}
// The example displays the following output:
//       'll' found in 'trellis' at position 3.
//       'ee' found in 'seer' at position 1.
//       'tt' found in 'latter' at position 2.
//       'mm' found in 'summer' at position 2.
//       No double characters in 'hoarse'.
//       'ss' found in 'lesser' at position 2.
//       'aa' found in 'aardvark' at position 0.
//       'nn' found in 'stunned' at position 3.

Zpět na začátek

Mimoslovní znak: \W

\W odpovídá libovolnému mimoslovní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, porovnává libovolný znak kromě těch, které jsou uvedeny v následující tabulce.

Kategorie

Popis

Ll

písmeno, malé písmeno

Lu

písmeno, velké písmeno

Lt

písmeno, nadpisové písmeno

Lo

písmeno, jiné

Lm

písmeno, modifikátor

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 specifikováno chování standardu ECMAScript, \W je ekvivalentní s [^a-zA-Z_0-9]. Informace o regulárních výrazech jazyka ECMAScript naleznete v oddílu "ECMAScript chování porovnávání" v tématu Možnosti regulárních výrazů.

PoznámkaPoznámka

Protože odpovídá libovolnému mimoslovnímu znaku, prvek jazyka \W se často používá s líným kvantifikátor, pokud se vzor regulárního výrazu pokusí porovnat libovolný mimoslovní znak několikrát, následovaný určitým mimoslovním znakem.Další informace naleznete v tématu Kvantifikátory.

Následující příklad ukazuje třídu znaků \w. Je definován vzor regulárního výrazu, \b(\w+)(\W){1,2}, který porovnává slovo následované jedním nebo více mimoslovními znaky, jako například prázdný znak či interpunkční znaménko. Regulární výraz je interpretován tak, jak je uvedeno v následující tabulce.

Prvek

Popis

\b

Začne porovnání na hranici slova.

(\w+)

Porovná jeden nebo více slovních znaků. 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.

 
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)

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)

Protože objekt Group pro druhou zachytávající skupinu obsahuje pouze jediný zachycený mimoslovní znak, příklad načte všechny zachycené mimoslovní znaky z objektu CaptureCollection, který je vrácen vlastností Group.Captures.

Zpět na začátek

Prázdný znak: \s

\s odpovídá jakémukoli prázdnému znaku. Je ekvivalentní s uvozovacími sekvencemi a kategoriemi sady Unicode, které jsou uvedeny v následující tabulka.

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 tři tečky nebo znak NEXT LINE (NEL) (…), \u0085.

\p{Z}

Porovnává s jakýmkoli znakem oddělovače.

Pokud je zadán chování standardu ECMAScript, \s je ekvivalentem [\f\n\r\t\v]. Informace o regulárních výrazech jazyka ECMAScript naleznete v oddílu "ECMAScript chování porovnávání" v tématu Možnosti regulárních výrazů.

Následující příklad ukazuje třídu znaků \s. Definuje vzor regulárního výrazu \b\w+(e)*s(\s|$), který porovnává slova končící 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.

Prvek

Popis

\b

Začne porovnání na hranici slova.

\w+

Porovná jeden nebo více slovních znaků.

(e)*

Porovnává s "e" jednou nebo vůbec.

s

Porovnává s "s".

(\s|$)

Porovnává buď s prázdným znakem nebo s koncem vstupního řetězce.

 
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

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

Zpět na začátek

Neprázdný znak. \S

\S odpovídá jakémukoli neprázdnému znaku. Je ekvivalentní vzoru regulárního výrazu [^\f\n\r\t\v\x85\p{Z}], nebo je opakem vzoru regulárního výrazu ekvivalentního s \s, který porovnává prázdné znaky. Další informace naleznete v tématu Prázdný znak: \s.

Pokud je specifikováno chování standardu ECMAScript, \S je ekvivalentní s [^ \f\n\r\t\v]. Informace o regulárních výrazech jazyka ECMAScript naleznete v oddílu "ECMAScript chování porovnávání" v tématu Možnosti regulárních výrazů.

Následující příklad ukazuje prvek jazyka \S. Vzor regulárního výrazu \b(\S+)\s* porovnává řetězce, které jsou odděleny prázdnými znaky. Druhý prvek v objektu GroupCollection shody 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.

Prvek

Popis

\b

Začne porovnání na hranici slova.

(\S+)

Porovnává jeden nebo více prázdných znaků. Toto je první zachytávající skupina.

\s*

Porovná žádný nebo jeden prázdný znak.

 
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.

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.

Zpět na začátek

Znak desítkové číslice: \d

\d odpovídá jakékoli desítkové číslici. Je ekvivalentní se vzorem regulárního výrazu \p{Nd}, který obsahuje standardní desítkové číslice 0-9 a desítkové číslice čísel několika jiných množin znaků.

Pokud je specifikováno chování standardu ECMAScript, \d je ekvivalentní s [0-9]. Informace o regulárních výrazech jazyka ECMAScript naleznete v oddílu "ECMAScript chování porovnávání" v tématu Možnosti regulárních výrazů.

Následující příklad ukazuje prvek jazyka \d. Testuje zda vstupní řetězec představuje platné telefonní číslo ve Spojených státech a Kanadě. Vzorce regulárního výrazu ^(\(*\d{3}\)*[\s-])*\d{3}-\d{4}$ je definován podle následující tabulky.

Prvek

Popis

^

Zahájí porovnávání na začátku vstupního řetězce.

\(*

Porovnává jeden nebo žádný literální znak "(".

\d{3}

Porovná tři desítkové číslice.

\)*

Porovnává jeden nebo žádný literální znak ")".

[\s-]

Porovnává pomlčku 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 pomlčku, jednou nebo vůbec. Toto je první zachytávající skupina.

\d{3}=\d{4}

Porovnává tři desítkové číslice následované pomlčkou a čtyřmi dalšími desítkovými číslicemi.

$

Porovná konec vstupního řetězce.

 
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

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

Zpět na začátek

Nečíslicový znak: \D

\D tomuto řetězci odpovídá libovolný nečíslicový znak. Je ekvivalentní vzoru regulárního výrazu \p{Nd}.

Pokud je specifikováno chování standardu ECMAScript, \D je ekvivalentní s [^0-9]. Informace o regulárních výrazech jazyka ECMAScript naleznete v oddílu "ECMAScript chování porovnávání" v tématu Možnosti regulárních výrazů.

Následující příklad ukazuje prvek jazyka \D. Ověřuje se, zda se řetězec jako součást čísla skládá z vhodné kombinace desítkových znaků a znaků nedesítkových. Vzorce regulárního výrazu ^\D\d{1,5}\D*$ je definován podle následující tabulky.

Prvek

Popis

^

Zahájí porovnávání na začátku vstupního řetězce.

\D

Porovná nečíslicový znak.

\d{1,5}

Porovná jedno až pět desítkových číslic.

\D*

Porovná jeden nebo žádný nedesítkový znak.

$

Porovná konec vstupního řetězce.

 
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:

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

Zpět na začátek

Podporované obecné kategorie sady Unicode

Sada Unicode definuje obecné kategorie uvedené v následující tabulce. Další informace naleznete v tématu "Soubor formátu UCD" a "Obecné kategorie hodnoty" témata na Databáze znak Unicode.

Kategorie

Popis

Lu

písmeno, velké písmeno

Ll

písmeno, malé písmeno

Lt

písmeno, nadpisové písmeno

Lm

písmeno, modifikátor

Lo

písmeno, jiné

L

Všechny znaky písmena. To zahrnuje znaky Lu, Ll, Lt, Lma Lo.

Mn

značka, bez mezer

Mc

značka, kombinování mezer

Me

značka, uzavření

M

Všechny značky diakritických znamének. To zahrnuje Mn, Mc, a Me kategorie.

Nd

číslo, desítková číslice

Nl

číslo, písmeno

No

číslo, jiné

N

Všechna čísla. To zahrnuje Nd, Nl, a 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, Ps, Pe, Pi, Pf a Po.

Sm

symbol, matematický

Sc

symbol, měny

Sk

symbol, modifikátor

So

symbol, jiný

S

Všechny symboly. To zahrnuje kategorie Sm, Sc, Sk a So.

Zs

oddělovač, mezera

Zl

oddělovač, řádku

Zp

oddělovač, odstavce

Z

Všechny znaky oddělovačů. To zahrnuje Zs, Zl, a 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é (žádné znaky nemají tuto vlastnost)

C

Všechny znaky ovládacích prvků. To zahrnuje kategorie Cc, Cf, Cs, Co a Cn.

Můžete určit kategorii sady Unicode z jakéhokoli určitého znaku předáním tohoto znaku metodě GetUnicodeCategory. V následujícím příkladu je použita metoda GetUnicodeCategory k určení kategorie každého prvku pole, které obsahuje vybrané znaky latinky.

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

using System;
using System.Text.RegularExpressions;

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

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

Zpět na začátek

Podporované pojmenované bloky

Rozhraní .NET Framework poskytuje pojmenované bloky uvedeny v následující tabulce. Množina podporovaných pojmenovaných bloků je založena na sadě Unicode 4.0 a Perl 5.6.

Rozsah kódového bodu

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

0 C 00 - 0C7F

IsTelugu

0 C 80 - 0CFF

IsKannada

0 D 00 - 0D7F

IsMalayalam

0 D 80 - 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

1 D 00 - 1D7F

IsPhoneticExtensions

1E00 - 1EFF

IsLatinExtendedAdditional

1F00 - 1FFF

IsGreekExtended

2000 - 206F

IsGeneralPunctuation

2070 - 209F

IsSuperscriptsandSubscripts

20A0 - 20CF

IsCurrencySymbols

20 D 0 - 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

27 C 0 - 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

BYLO - F8FF

IsPrivateUseneboIsPrivateUseArea

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

Zpět na začátek

Odčítání tříd znaků

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ím 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čka ()-) jsou povinné. base_group je skupina pozitivních nebo negativních znaků, tak jak jsou popsány v tabulce Syntaxe třídy znaků. Komponenta excluded_group je jiná skupina pozitivních nebo negativních znaků nebo jiný výraz odčítání třídy znaků (to znamená, že můžete vnořovat 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 množinu znaků, která se skládá ze základní skupiny kromě znaku "m", použijte [a-z-[m]]. Chcete-li definovat množinu znaků, která se skládá ze základní skupiny s výjimkou množiny znaků "d", "j" a "p", použijte [a-z-[djp]]. Chcete-li definovat množinu znaků, která se skládá ze základní skupiny s výjimkou rozsahu znaků od "m" až do "p", použijte [a-z-[m-p]].

Zvažte vnořený výraz odčítání třídy znaků [a-z-[d-w-[m-o]]]. Výraz je vyhodnocen od nejvnitřnějšího rozsahu znaků ven. První 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 množina je poté odečtena 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 množinu znaků, která obsahuje všechny znaky sady Unicode od \u0000 do \uFFFF s výjimkou prázdných znaků (\s), znaků v obecné kategorii interpunkčních znamének (\p{P}), znaků v pojmenovaném bloku IsGreek (\p{IsGreek}) a řídicího znaku sady Unicode NEXT LINE (\x85), použijte [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].

Zvolte třídy znaků pro výraz odčítání třídy znaků, které budou poskytovat užitečné výsledky. Vyhněte se výrazu, jehož výsledkem jsou prázdné množiny znaků, které nemohou odpovídat ničemu nebo výrazu, který odpovídá původní základní skupině. Prázdná množina je například výsledkem výrazu [\p{IsBasicLatin}-[\x00-\x7F]], který odečte všechny znaky v rozsahu znaků IsBasicLatin od obecné kategorie IsBasicLatin. Podobně původní základní skupina je výsledkem výrazu [a-z-[0-9]]. Důvodem je, ž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".

Například následující regulární výraz definuje ^[0-9-[2468]]+$, který odpovídá nula a lichých číslic ve vstupní řetězec. Regulární výraz je interpretován tak, jak je uvedeno v následující tabulce.

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 odpovídat jedné nebo více výskytů nula nebo liché číslice.

$

Ukončí porovnávání na konci vstupního řetězce.

 
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

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

Zpět na začátek

Viz také

Odkaz

GetUnicodeCategory

Možnosti regulárních výrazů

Koncepty

Prvky jazyka regulárních výrazů