Klasy znaków w wyrażeniach regularnychCharacter classes in regular expressions

Klasa znaków definiuje zestaw znaków, z którego każdy jeden znak może wystąpić w ciągu wejściowym, aby dopasowanie zakończyło się sukcesem.A character class defines a set of characters, any one of which can occur in an input string for a match to succeed. Język wyrażeń regularnych w programie .NET obsługuje następujące klasy znaków:The regular expression language in .NET supports the following character classes:

  • Grupy znaków pozytywnych.Positive character groups. Znak w ciągu wejściowym musi odpowiadać jednemu ze znaków z określonego zestawu znaków.A character in the input string must match one of a specified set of characters. Aby uzyskać więcej informacji, zobacz Grupa znaków pozytywnych.For more information, see Positive Character Group.

  • Grupy znaków negatywnych.Negative character groups. Znak w ciągu wejściowym nie może odpowiadać żadnemu ze znaków z określonego zestawu znaków.A character in the input string must not match one of a specified set of characters. Aby uzyskać więcej informacji, zobacz Grupa znaków negatywnych.For more information, see Negative Character Group.

  • Dowolny znak.Any character. Znak (kropka lub kropka) w wyrażeniu regularnym jest symbolem wieloznacznym, który pasuje do dowolnego znaku z wyjątkiem \n. .The . (dot or period) character in a regular expression is a wildcard character that matches any character except \n. Aby uzyskać więcej informacji, zobacz dowolny znak.For more information, see Any Character.

  • Ogólna kategoria Unicode lub blok nazwany.A general Unicode category or named block. Aby dopasowanie zakończyło się sukcesem, znak w ciągu wejściowym musi być elementem członkowskim określonej kategorii Unicode lub musi należeć do ciągłego zakresu znaków Unicode.A character in the input string must be a member of a particular Unicode category or must fall within a contiguous range of Unicode characters for a match to succeed. Aby uzyskać więcej informacji, zobacz Kategoria Unicode lub blok Unicode.For more information, see Unicode Category or Unicode Block.

  • Negatywna ogólna kategoria Unicode lub blok nazwany.A negative general Unicode category or named block. Aby dopasowanie zakończyło się sukcesem, znak w ciągu wejściowym nie może być elementem członkowskim określonej kategorii Unicode, ani nie może należeć do ciągłego zakresu znaków Unicode.A character in the input string must not be a member of a particular Unicode category or must not fall within a contiguous range of Unicode characters for a match to succeed. Aby uzyskać więcej informacji, zobacz negatywna kategoria Unicode lub blok Unicode.For more information, see Negative Unicode Category or Unicode Block.

  • Znak słowa.A word character. Znak w ciągu wejściowym może należeć do dowolnej kategorii Unicode, która jest odpowiednia dla znaków w wyrazach.A character in the input string can belong to any of the Unicode categories that are appropriate for characters in words. Aby uzyskać więcej informacji, zobacz znak słowa.For more information, see Word Character.

  • Znak niebędący znakiem słowa.A non-word character. Znak w ciągu wejściowym może należeć do dowolnej kategorii Unicode, która nie jest znakiem słowa.A character in the input string can belong to any Unicode category that is not a word character. Aby uzyskać więcej informacji, zobacz znakniebędący słowem.For more information, see Non-Word Character.

  • Znak odstępu.A white-space character. Znak w ciągu wejściowym może być dowolnym znakiem separatora Unicode, a także dowolnym ze znaków kontrolnych.A character in the input string can be any Unicode separator character, as well as any one of a number of control characters. Aby uzyskać więcej informacji, zobacz znakodstępu.For more information, see White-Space Character.

  • Znak niebędący odstępem.A non-white-space character. Znak w ciągu wejściowym może być dowolnym znakiem, który nie jest znakiem odstępu.A character in the input string can be any character that is not a white-space character. Aby uzyskać więcej informacji, zobacz znakniebędący odstępem.For more information, see Non-White-Space Character.

  • Cyfra dziesiętna.A decimal digit. Znak w ciągu wejściowym może być dowolnym ze znaków klasyfikowanych jako cyfry dziesiętne Unicode.A character in the input string can be any of a number of characters classified as Unicode decimal digits. Aby uzyskać więcej informacji, zobacz znak cyfr dziesiętnych.For more information, see Decimal Digit Character.

  • Cyfra niebędąca cyfrą dziesiętną.A non-decimal digit. Znak w ciągu wejściowym może być dowolnym znakiem innym niż cyfra dziesiętna Unicode.A character in the input string can be anything other than a Unicode decimal digit. Aby uzyskać więcej informacji, zobacz znak cyfr dziesiętnych.For more information, see Decimal Digit Character.

Platforma .NET obsługuje wyrażenia odejmowania klas znaków, które umożliwiają zdefiniowanie zestawu znaków jako wyniku wykluczenia jednej klasy znaków z innej klasy znaków..NET supports character class subtraction expressions, which enables you to define a set of characters as the result of excluding one character class from another character class. Aby uzyskać więcej informacji, zobacz odejmowanie klasy znaków.For more information, see Character Class Subtraction.

Uwaga

Klasy znaków, które pasują do znaków według kategorii, takich jak \w , aby dopasować znaki wyrazu lub \p{} w celu dopasowania do CharUnicodeInfo kategorii Unicode, polegają na klasie w celu podania informacji o kategoriach znaków.Character classes that match characters by category, such as \w to match word characters or \p{} to match a Unicode category, rely on the CharUnicodeInfo class to provide information about character categories. Począwszy od .NET Framework 4.6.2, kategorie znaków są oparte na standardzie Unicode w wersji 8.0.0.Starting with the .NET Framework 4.6.2, character categories are based on The Unicode Standard, Version 8.0.0. W .NET Framework 4 za pośrednictwem .NET Framework 4.6.1 są one oparte na standardzie Unicode w wersji 6.3.0.In the .NET Framework 4 through the .NET Framework 4.6.1, they are based on The Unicode Standard, Version 6.3.0.

Grupa znaków pozytywnych: []Positive character group: [ ]

Grupa znaków pozytywnych określa listę znaków, z których każdy może wystąpić w ciągu wejściowym, aby wystąpiło dopasowanie.A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. Ta lista znaków może być określona indywidualnie, jako zakres lub na oba te sposoby.This list of characters may be specified individually, as a range, or both.

Składnia służąca do określenia listy indywidualnych znaków jest następująca:The syntax for specifying a list of individual characters is as follows:

[*character_group*]  

gdzie character_group jest listą pojedynczych znaków, które mogą być wyświetlane w ciągu wejściowym, aby dopasowanie zakończyło się pomyślnie.where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group może składać się z dowolnej kombinacji jednego lub większej liczby znaków literału, znaków ucieczkilub klasy znaków.character_group can consist of any combination of one or more literal characters, escape characters, or character classes.

Składnia służąca do określania zakresu znaków jest następująca:The syntax for specifying a range of characters is as follows:

[firstCharacter-lastCharacter]  

gdzie firstCharacter jest znakiem, który rozpoczyna zakres, a lastCharacter jest znakiem kończącym zakres.where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. Zakres znaków jest ciągłą serią znaków definiowaną przez określenie pierwszego znaku w serii, łącznika (-), a następnie ostatniego znaku w serii.A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Dwa znaki są ciągłe, jeśli mają sąsiadujące punkty kodowe Unicode.Two characters are contiguous if they have adjacent Unicode code points. firstCharacter musi być znakiem z dolnym punktem kodu, a lastCharacter musi być znakiem z wyższym punktem kodu.firstCharacter must be the character with the lower code point, and lastCharacter must be the character with the higher code point.

Uwaga

Ponieważ Grupa znaków pozytywnych może zawierać zarówno zestaw znaków, jak i zakres znaków, znak łącznika (-) jest zawsze interpretowany jako separator zakresu, chyba że jest to pierwszy lub ostatni znak grupy.Because a positive character group can include both a set of characters and a character range, a hyphen character (-) is always interpreted as the range separator unless it is the first or last character of the group.

W poniższej tabeli wymieniono niektóre typowe wzorce wyrażeń regularnych zawierających klasy znaków pozytywnych.Some common regular expression patterns that contain positive character classes are listed in the following table.

WzorzecPattern OpisDescription
[aeiou] Dopasowuje wszystkie samogłoski.Match all vowels.
[\p{P}\d] Dopasowuje wszystkie znaki interpunkcyjne oraz znaki cyfr dziesiętnych.Match all punctuation and decimal digit characters.
[\s\p{P}] Dopasowuje cały biały znak i znaki interpunkcyjne.Match all white space and punctuation.

W poniższym przykładzie zdefiniowano grupę znaków pozytywnych, która zawiera znaki „a” i „e”, tak aby ciąg wejściowy musiał zawierać słowa „grey” lub „gray”, a następnie inne słowo, aby wystąpiło dopasowanie.The following example defines a positive character group that contains the characters "a" and "e" so that the input string must contain the words "grey" or "gray" followed by another word for a match to occur.

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

Wyrażenie gr[ae]y\s\S+?[\s|\p{P}] regularne jest zdefiniowane w następujący sposób:The regular expression gr[ae]y\s\S+?[\s|\p{P}] is defined as follows:

WzorzecPattern OpisDescription
gr Dopasowuje znaki literału „gr”.Match the literal characters "gr".
[ae] Dopasowuje znak „a” lub „e”.Match either an "a" or an "e".
y\s Dopasowuje znak literału „y”, po którym następuje znak odstępu.Match the literal character "y" followed by a white-space character.
\S+? Dopasowuje jeden lub więcej znaków, które nie są znakami odstępu, jednak możliwie najmniej.Match one or more non-white-space characters, but as few as possible.
[\s\p{P}] Dopasowuje znak odstępu lub znak interpunkcyjny.Match either a white-space character or a punctuation mark.

W poniższym przykładzie dopasowywane są wyrazy zaczynające się od wielkiej litery.The following example matches words that begin with any capital letter. Używa podwyrażenia [A-Z] do reprezentowania zakresu wielkich liter od A do z.It uses the subexpression [A-Z] to represent the range of capital letters from A to 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

Wyrażenie \b[A-Z]\w*\b regularne jest zdefiniowane, jak pokazano w poniższej tabeli.The regular expression \b[A-Z]\w*\b is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna na granicy wyrazu.Start at a word boundary.
[A-Z] Dopasowuje dowolny znak wielkiej litery z zakresu od A do Z.Match any uppercase character from A to Z.
\w* Dopasowuje zero lub więcej znaków słowa.Match zero or more word characters.
\b Dopasowuje granicę wyrazu.Match a word boundary.

Ujemna Grupa znaków: [^]Negative character group: [^]

Grupa znaków negatywnych określa listę znaków, z których żaden nie może wystąpić w ciągu wejściowym, aby wystąpiło dopasowanie.A negative character group specifies a list of characters that must not appear in an input string for a match to occur. Ta lista znaków może być określona indywidualnie, jako zakres lub na oba te sposoby.The list of characters may be specified individually, as a range, or both.

Składnia służąca do określenia listy indywidualnych znaków jest następująca:The syntax for specifying a list of individual characters is as follows:

[*^character_group*]  

gdzie character_group jest listą pojedynczych znaków, które nie mogą być wyświetlane w ciągu wejściowym, aby dopasowanie zakończyło się pomyślnie.where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group może składać się z dowolnej kombinacji jednego lub większej liczby znaków literału, znaków ucieczkilub klasy znaków.character_group can consist of any combination of one or more literal characters, escape characters, or character classes.

Składnia służąca do określania zakresu znaków jest następująca:The syntax for specifying a range of characters is as follows:

[^*firstCharacter*-*lastCharacter*]  

gdzie firstCharacter jest znakiem, który rozpoczyna zakres, a lastCharacter jest znakiem kończącym zakres.where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. Zakres znaków jest ciągłą serią znaków definiowaną przez określenie pierwszego znaku w serii, łącznika (-), a następnie ostatniego znaku w serii.A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Dwa znaki są ciągłe, jeśli mają sąsiadujące punkty kodowe Unicode.Two characters are contiguous if they have adjacent Unicode code points. firstCharacter musi być znakiem z dolnym punktem kodu, a lastCharacter musi być znakiem z wyższym punktem kodu.firstCharacter must be the character with the lower code point, and lastCharacter must be the character with the higher code point.

Uwaga

Ponieważ Grupa znaków negatywnych może zawierać zarówno zestaw znaków, jak i zakres znaków, znak łącznika (-) jest zawsze interpretowany jako separator zakresu, chyba że jest to pierwszy lub ostatni znak grupy.Because a negative character group can include both a set of characters and a character range, a hyphen character (-) is always interpreted as the range separator unless it is the first or last character of the group.

Można połączyć co najmniej dwa zakresy znaków.Two or more character ranges can be concatenated. Na przykład, aby określić zakres cyfr dziesiętnych od "0" do "9", zakres małych liter od "a" do "f" oraz zakres wielkich liter od "A" do "F", użyj [0-9a-fA-F].For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].

Wiodący znak daszka^() w grupie znaków negatywnych jest obowiązkowy i wskazuje, że Grupa znaków jest grupą znaków negatywnych zamiast grupy znaków pozytywnych.The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.

Ważne

Grupa znaków negatywnych w większym wzorcu wyrażenia regularnego nie jest asercją o zerowej szerokości.A negative character group in a larger regular expression pattern is not a zero-width assertion. Czyli po dokonaniu oceny grupy znaków negatywnych aparat wyrażeń regularnych postępuje o jeden znak do przodu w ciągu wejściowym.That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.

W poniższej tabeli wymieniono niektóre typowe wzorce wyrażeń regularnych zawierających grupy znaków negatywnych.Some common regular expression patterns that contain negative character groups are listed in the following table.

WzorzecPattern OpisDescription
[^aeiou] Dopasowuje wszystkie znaki z wyjątkiem samogłosek.Match all characters except vowels.
[^\p{P}\d] Dopasowuje wszystkie znaki z wyjątkiem znaków interpunkcyjnych oraz znaków cyfr dziesiętnych.Match all characters except punctuation and decimal digit characters.

W poniższym przykładzie jest dopasowywany dowolny wyraz rozpoczynający się od znaków „th”, po których nie występuje znak „o”.The following example matches any word that begins with the characters "th" and is not followed by an "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

Wyrażenie \bth[^o]\w+\b regularne jest zdefiniowane, jak pokazano w poniższej tabeli.The regular expression \bth[^o]\w+\b is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna na granicy wyrazu.Start at a word boundary.
th Dopasowuje znaki literału „th”.Match the literal characters "th".
[^o] Dopasowuje dowolny znak inny niż „o”.Match any character that is not an "o".
\w+ Dopasowuje co najmniej jeden znak słowa.Match one or more word characters.
\b Kończy na granicy wyrazu.End at a word boundary.

Dowolny znak:.Any character: .

Znak kropki (.) dopasowuje dowolny znak \n z wyjątkiem (znak nowego wiersza, \u000A), z następującymi dwoma kwalifikacjami:The period character (.) matches any character except \n (the newline character, \u000A), with the following two qualifications:

  • Jeśli wzorzec wyrażenia regularnego jest modyfikowany przez RegexOptions.Singleline opcję lub część wzorca, która . zawiera s klasę znaku, jest modyfikowana przez opcję, . dopasowuje dowolny znak.If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the s option, . matches any character. Aby uzyskać więcej informacji, zobacz Opcje wyrażeń regularnych.For more information, see Regular Expression Options.

    Poniższy przykład ilustruje różne zachowanie . klasy znaku domyślnie i RegexOptions.Singleline z opcją.The following example illustrates the different behavior of the . character class by default and with the RegexOptions.Singleline option. Wyrażenie ^.+ regularne rozpoczyna się od początku ciągu i dopasowuje każdy znak.The regular expression ^.+ starts at the beginning of the string and matches every character. Domyślnie dopasowanie kończy się na końcu pierwszego wiersza; wzorzec wyrażenia regularnego dopasowuje znak \r powrotu karetki lub \u000D, ale nie jest zgodny. \nBy default, the match ends at the end of the first line; the regular expression pattern matches the carriage return character, \r or \u000D, but it does not match \n. Ponieważ opcja interpretuje cały ciąg wejściowy jako pojedynczy wiersz, dopasowuje każdy znak w ciągu wejściowym, w tym \n. RegexOptions.SinglelineBecause the RegexOptions.Singleline option interprets the entire input string as a single line, it matches every character in the input string, including \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\.
    

Uwaga

Ponieważ dopasowuje dowolny znak z \nwyjątkiem . , Klasa znaku również dopasowuje \r (znak powrotu karetki, \u000D).Because it matches any character except \n, the . character class also matches \r (the carriage return character, \u000D).

  • W grupie znaków pozytywnych lub negatywnych kropka jest traktowana jako znak kropki literału, a nie jako klasa znaków.In a positive or negative character group, a period is treated as a literal period character, and not as a character class. Aby uzyskać więcej informacji, zobacz Grupa znaków pozytywnych i Grupa znaków negatywnych wcześniej w tym temacie.For more information, see Positive Character Group and Negative Character Group earlier in this topic. Poniższy przykład przedstawia ilustrację definiując wyrażenie regularne, które zawiera znak kropki (.) zarówno jako klasę znaku, jak i jako element członkowski grupy znaków pozytywnych.The following example provides an illustration by defining a regular expression that includes the period character (.) both as a character class and as a member of a positive character group. Wyrażenie \b.*[.?!;:](\s|\z) regularne rozpoczyna się od granicy słowa, dopasowuje dowolny znak, dopóki nie napotka jeden z pięciu znaków interpunkcyjnych, łącznie z kropką, a następnie dopasowuje znak odstępu lub koniec ciągu.The regular expression \b.*[.?!;:](\s|\z) begins at a word boundary, matches any character until it encounters one of five punctuation marks, including a period, and then matches either a white-space character or the end of the string.

    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.
    

Uwaga

Ponieważ dopasowuje dowolny znak, element . Language jest często używany z kwantyfikatorem z opóźnieniem, Jeśli wzorzec wyrażenia regularnego próbuje dopasować dowolny znak wielokrotnie.Because it matches any character, the . language element is often used with a lazy quantifier if a regular expression pattern attempts to match any character multiple times. Aby uzyskać więcej informacji, zobacz Kwantyfikatory.For more information, see Quantifiers.

Kategoria Unicode lub blok Unicode: \p{}Unicode category or Unicode block: \p{}

W standardzie Unicode każdemu znakowi przypisuje się kategorię ogólną.The Unicode standard assigns each character a general category. Na przykład konkretny znak może Lu być wielką literą (reprezentowana przez kategorię), cyfrą dziesiętną Nd (kategorią), symbolem matematycznym ( Sm kategorią Zl ) lub separatorem akapitu (kategorii).For example, a particular character can be an uppercase letter (represented by the Lu category), a decimal digit (the Nd category), a math symbol (the Sm category), or a paragraph separator (the Zl category). Określone zestawy znaków w standardzie Unicode zajmują również określony zakres lub blok kolejnych kodów znaku.Specific character sets in the Unicode standard also occupy a specific range or block of consecutive code points. Na przykład podstawowy zestaw znaków łacińskich można znaleźć w zakresie od \u0000 do \u007F, podczas gdy zestaw znaków arabskich znajduje się w zakresie od \u0600 do \u06FF.For example, the basic Latin character set is found from \u0000 through \u007F, while the Arabic character set is found from \u0600 through \u06FF.

Konstrukcja wyrażenia regularnegoThe regular expression construct

\p{Nazwa}\p{ name }

Dopasowuje dowolny znak, który należy do ogólnej kategorii Unicode lub bloku nazwanego, gdzie name jest skrótem kategorii lub nazwą bloku nazwanego.matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. Aby zapoznać się z listą skrótów kategorii, zobacz sekcję obsługiwane ogólne kategorie Unicode w dalszej części tego tematu.For a list of category abbreviations, see the Supported Unicode General Categories section later in this topic. Aby uzyskać listę nazwanych bloków, zobacz sekcję obsługiwane bloki nazwane w dalszej części tego tematu.For a list of named blocks, see the Supported Named Blocks section later in this topic.

Poniższy \p{przykład używa konstrukcji name } , aby dopasować do ogólnej Pdkategorii Unicode (w tym przypadku, lub interpunkcji IsGreek , kreski) i nazwanego bloku (i IsBasicLatin nazwanego bloki).The following example uses the \p{name} construct to match both a Unicode general category (in this case, the Pd, or Punctuation, Dash category) and a named block (the IsGreek and IsBasicLatin named blocks).

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

Wyrażenie \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ regularne jest zdefiniowane, jak pokazano w poniższej tabeli.The regular expression \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna na granicy wyrazu.Start at a word boundary.
\p{IsGreek}+ Dopasowuje jeden lub więcej znaków greckich.Match one or more Greek characters.
(\s)? Dopasowuje zero lub jeden znak odstępu.Match zero or one white-space character.
(\p{IsGreek}+(\s)?)+ Dopasowuje wzorzec jednego lub więcej znaków greckich, po których co najmniej raz następuje zero lub jeden znak odstępu.Match the pattern of one or more Greek characters followed by zero or one white-space characters one or more times.
\p{Pd} Dopasowuje znak interpunkcyjny kreskę.Match a Punctuation, Dash character.
\s Dopasowuje znak odstępu.Match a white-space character.
\p{IsBasicLatin}+ Dopasowuje jeden lub więcej znaków łacińskich.Match one or more basic Latin characters.
(\s)? Dopasowuje zero lub jeden znak odstępu.Match zero or one white-space character.
(\p{IsBasicLatin}+(\s)?)+ Dopasowuje wzorzec jednego lub większej liczby podstawowych znaków łacińskich, po których co najmniej raz następuje zero lub jeden znak odstępu.Match the pattern of one or more basic Latin characters followed by zero or one white-space characters one or more times.

Ujemna kategoria Unicode lub blok Unicode: \p{}Negative Unicode category or Unicode block: \P{}

W standardzie Unicode każdemu znakowi przypisuje się kategorię ogólną.The Unicode standard assigns each character a general category. Na przykład konkretny znak może Lu być wielką literą (reprezentowana przez kategorię), cyfrą dziesiętną Nd (kategorią), symbolem matematycznym ( Sm kategorią Zl ) lub separatorem akapitu (kategorii).For example, a particular character can be an uppercase letter (represented by the Lu category), a decimal digit (the Nd category), a math symbol (the Sm category), or a paragraph separator (the Zl category). Określone zestawy znaków w standardzie Unicode zajmują również określony zakres lub blok kolejnych kodów znaku.Specific character sets in the Unicode standard also occupy a specific range or block of consecutive code points. Na przykład podstawowy zestaw znaków łacińskich można znaleźć w zakresie od \u0000 do \u007F, podczas gdy zestaw znaków arabskich znajduje się w zakresie od \u0600 do \u06FF.For example, the basic Latin character set is found from \u0000 through \u007F, while the Arabic character set is found from \u0600 through \u06FF.

Konstrukcja wyrażenia regularnegoThe regular expression construct

\P{Nazwa}\P{ name }

Dopasowuje dowolny znak, który nie należy do ogólnej kategorii Unicode lub bloku nazwanego, gdzie name jest skrótem kategorii lub nazwą bloku nazwanego.matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. Aby zapoznać się z listą skrótów kategorii, zobacz sekcję obsługiwane ogólne kategorie Unicode w dalszej części tego tematu.For a list of category abbreviations, see the Supported Unicode General Categories section later in this topic. Aby uzyskać listę nazwanych bloków, zobacz sekcję obsługiwane bloki nazwane w dalszej części tego tematu.For a list of named blocks, see the Supported Named Blocks section later in this topic.

Poniższy przykład używa konstrukcji \P{ nazwy } , aby usunąć wszelkie Scsymbole walut (w tym przypadku, symbol, kategorię waluty) z ciągów liczbowych.The following example uses the \P{name} construct to remove any currency symbols (in this case, the Sc, or Symbol, Currency category) from numeric strings.

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

Wzorzec (\P{Sc})+ wyrażenia regularnego dopasowuje co najmniej jeden znak, który nie jest symbolem waluty; efektywnie przyciąga dowolny symbol waluty z ciągu wynikowego.The regular expression pattern (\P{Sc})+ matches one or more characters that are not currency symbols; it effectively strips any currency symbol from the result string.

Znak wyrazu: \wWord character: \w

\wDopasowuje dowolny znak słowa.\w matches any word character. Znak słowa jest elementem członkowskim każdej z kategorii Unicode wymienionej w poniższej tabeli.A word character is a member of any of the Unicode categories listed in the following table.

KategoriaCategory OpisDescription
LlLl Litera, Małe literyLetter, Lowercase
LuLu Litera, Wielkie literyLetter, Uppercase
LtLt Litera, Duże litery na początku wyrazuLetter, Titlecase
LoLo Litera, InneLetter, Other
LmLm Litera, ModyfikatorLetter, Modifier
MnMn Znak, Brak odstępówMark, Nonspacing
NdNd Liczba, Cyfra dziesiętnaNumber, Decimal Digit
PcPc Znak interpunkcyjny, Łącznik.Punctuation, Connector. Ta kategoria obejmuje dziesięć znaków, z których najczęściej używany jest znak LOWLINE (), u+005F.This category includes ten characters, the most commonly used of which is the LOWLINE character (), u+005F.

Jeśli określono zachowanie zgodne ze standardem ECMAScript \w , jest [a-zA-Z_0-9]równoważne.If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9]. Aby uzyskać informacje na temat wyrażeń regularnych języka ECMAScript, zobacz sekcję "zachowanie zgodne z językiem ECMAScript" w opcjach wyrażeń regularnych.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

Uwaga

Ponieważ dopasowuje dowolny znak słowa, element \w języka jest często używany z kwantyfikatorem z opóźnieniem, Jeśli wzorzec wyrażenia regularnego próbuje dopasować dowolny znak wyrazu wielokrotnie, po którym następują znaki określonego wyrazu.Because it matches any word character, the \w language element is often used with a lazy quantifier if a regular expression pattern attempts to match any word character multiple times, followed by a specific word character. Aby uzyskać więcej informacji, zobacz Kwantyfikatory.For more information, see Quantifiers.

W poniższym przykładzie użyto elementu \w języka, aby dopasować zduplikowane znaki w wyrazie.The following example uses the \w language element to match duplicate characters in a word. W przykładzie zdefiniowano wzorzec (\w)\1wyrażenia regularnego, który może być interpretowany w następujący sposób.The example defines a regular expression pattern, (\w)\1, which can be interpreted as follows.

ElementElement OpisDescription
(\w)(\w) Dopasowuje znak słowa.Match a word character. Jest to pierwsza grupa przechwytywania.This is the first capturing group.
\1\1 Dopasowuje wartość pierwszego przechwycenia.Match the value of the first capture.
using System;
using System.Text.RegularExpressions;

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

Module Example
   Public Sub Main()
      Dim pattern As String = "(\w)\1"
      Dim words() As String = { "trellis", "seer", "latter", "summer", _
                                "hoarse", "lesser", "aardvark", "stunned" }
      For Each word As String In words
         Dim match As Match = Regex.Match(word, pattern)
         If match.Success Then
            Console.WriteLine("'{0}' found in '{1}' at position {2}.", _
                              match.Value, word, match.Index)
         Else
            Console.WriteLine("No double characters in '{0}'.", word)
         End If
      Next                                                  
   End Sub
End Module
' The example displays the following output:
'       'll' found in 'trellis' at position 3.
'       'ee' found in 'seer' at position 1.
'       'tt' found in 'latter' at position 2.
'       'mm' found in 'summer' at position 2.
'       No double characters in 'hoarse'.
'       'ss' found in 'lesser' at position 2.
'       'aa' found in 'aardvark' at position 0.
'       'nn' found in 'stunned' at position 3.

Znak niebędący słowem: \wNon-word character: \W

\WDopasowuje dowolny znak niebędący słowem.\W matches any non-word character. Element języka \W jest równoważny z następującą klasą znaków:The \W language element is equivalent to the following character class:

[^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]  

Innymi słowy, dopasowuje dowolny znak z wyjątkiem tych w kategoriach Unicode wymienionych w poniższej tabeli.In other words, it matches any character except for those in the Unicode categories listed in the following table.

KategoriaCategory OpisDescription
LlLl Litera, Małe literyLetter, Lowercase
LuLu Litera, Wielkie literyLetter, Uppercase
LtLt Litera, Duże litery na początku wyrazuLetter, Titlecase
LoLo Litera, InneLetter, Other
LmLm Litera, ModyfikatorLetter, Modifier
MnMn Znak, Brak odstępówMark, Nonspacing
NdNd Liczba, Cyfra dziesiętnaNumber, Decimal Digit
PcPc Znak interpunkcyjny, Łącznik.Punctuation, Connector. Ta kategoria obejmuje dziesięć znaków, z których najczęściej używany jest znak LOWLINE (), u+005F.This category includes ten characters, the most commonly used of which is the LOWLINE character (), u+005F.

Jeśli określono zachowanie zgodne ze standardem ECMAScript \W , jest [^a-zA-Z_0-9]równoważne.If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9]. Aby uzyskać informacje na temat wyrażeń regularnych języka ECMAScript, zobacz sekcję "zachowanie zgodne z językiem ECMAScript" w opcjach wyrażeń regularnych.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

Uwaga

Ponieważ dopasowuje dowolny znak niebędący słowem \W , element Language jest często używany z kwantyfikatorem z opóźnieniem, Jeśli wzorzec wyrażenia regularnego próbuje dopasować dowolny znak nienależący do słowa, po którym następuje określony znak niebędący słowem.Because it matches any non-word character, the \W language element is often used with a lazy quantifier if a regular expression pattern attempts to match any non-word character multiple times followed by a specific non-word character. Aby uzyskać więcej informacji, zobacz Kwantyfikatory.For more information, see Quantifiers.

Poniższy przykład ilustruje \W klasę Character.The following example illustrates the \W character class. Definiuje wzorzec \b(\w+)(\W){1,2}wyrażenia regularnego, który pasuje do wyrazu, po którym następuje jeden lub dwa znaki niebędące znakami słowa, takie jak odstępy czy interpunkcja.It defines a regular expression pattern, \b(\w+)(\W){1,2}, that matches a word followed by one or two non-word characters, such as white space or punctuation. Wyrażenie regularne jest interpretowane tak jak pokazano w poniższej tabeli.The regular expression is interpreted as shown in the following table.

ElementElement OpisDescription
\b\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match at a word boundary.
(\w+)(\w+) Dopasowuje co najmniej jeden znak słowa.Match one or more word characters. Jest to pierwsza grupa przechwytywania.This is the first capturing group.
\W{1,2}(\W){1,2} Dopasowuje znak niebędący znakiem słowa jeden lub dwa razy.Match a non-word character either one or two times. Jest to druga grupa przechwytywania.This is the second capturing group.
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)

Ponieważ obiekt dla drugiej grupy przechwytywania zawiera tylko jeden przechwycony znak niebędący słowem, w przykładzie pobiera wszystkie przechwycone znaki niebędące słowami CaptureCollection z obiektu, Group.Captures który jest zwracany przez właściwość. GroupBecause the Group object for the second capturing group contains only a single captured non-word character, the example retrieves all captured non-word characters from the CaptureCollection object that is returned by the Group.Captures property.

Znak odstępu: \sWhitespace character: \s

\sDopasowuje dowolny znak odstępu.\s matches any whitespace character. Jest to równoważne z sekwencjami ucieczki oraz kategoriami Unicode wymienionymi w poniższej tabeli.It is equivalent to the escape sequences and Unicode categories listed in the following table.

KategoriaCategory OpisDescription
\f Znak wysuwu strony, \u000C.The form feed character, \u000C.
\n Znak nowego wiersza, \u000A.The newline character, \u000A.
\r Znaku powrotu karetki, \u000D.The carriage return character, \u000D.
\t Znak tabulacji, \u0009.The tab character, \u0009.
\v Znak tabulacji pionowej, \u000B.The vertical tab character, \u000B.
\x85 Wielokropek lub znak NEXT LINE (NEL) (...), \u0085.The ellipsis or NEXT LINE (NEL) character (…), \u0085.
\p{Z} Dopasowuje dowolny znak separatora.Matches any separator character.

Jeśli określono zachowanie zgodne ze standardem ECMAScript \s , jest [ \f\n\r\t\v]równoważne.If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v]. Aby uzyskać informacje na temat wyrażeń regularnych języka ECMAScript, zobacz sekcję "zachowanie zgodne z językiem ECMAScript" w opcjach wyrażeń regularnych.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

Poniższy przykład ilustruje \s klasę Character.The following example illustrates the \s character class. Definiuje wzorzec wyrażenia regularnego, który \b\w+(e)?s(\s|$)pasuje do wyrazu kończącego się na "s" lub "es", po którym następuje znak odstępu lub koniec ciągu wejściowego.It defines a regular expression pattern, \b\w+(e)?s(\s|$), that matches a word ending in either "s" or "es" followed by either a white-space character or the end of the input string. Wyrażenie regularne jest interpretowane tak jak pokazano w poniższej tabeli.The regular expression is interpreted as shown in the following table.

ElementElement OpisDescription
\b\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match at a word boundary.
\w+\w+ Dopasowuje co najmniej jeden znak słowa.Match one or more word characters.
(e)?(e)? Dopasowuje znak „e” zero lub jeden raz.Match an "e" either zero or one time.
ss Dopasowuje znak „s”.Match an "s".
(\s|$)(\s|$) Dopasowuje znak odstępu lub koniec ciągu wejściowego.Match either a white-space character or the end of the input string.
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

Znak niebędący odstępem: \sNon-whitespace character: \S

\SDopasowuje dowolny znak niebędący odstępem.\S matches any non-white-space character. Jest odpowiednikiem [^\f\n\r\t\v\x85\p{Z}] wzorca wyrażenia regularnego lub przeciwieństwem wzorca wyrażenia regularnego, który jest odpowiednikiem, który \sjest zgodny ze znakami odstępu.It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. Aby uzyskać więcej informacji, zobacz znak odstępu : \s.For more information, see White-Space Character: \s.

Jeśli określono zachowanie zgodne ze standardem ECMAScript \S , jest [^ \f\n\r\t\v]równoważne.If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v]. Aby uzyskać informacje na temat wyrażeń regularnych języka ECMAScript, zobacz sekcję "zachowanie zgodne z językiem ECMAScript" w opcjach wyrażeń regularnych.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

Poniższy przykład ilustruje \S element języka.The following example illustrates the \S language element. Wzorzec \b(\S+)\s? wyrażenia regularnego dopasowuje ciągi, które są rozdzielane znakami odstępu.The regular expression pattern \b(\S+)\s? matches strings that are delimited by white-space characters. Drugi element w GroupCollection obiekcie Matcher zawiera dopasowany ciąg.The second element in the match's GroupCollection object contains the matched string. Wyrażenie regularne może być interpretowane tak jak pokazano w poniższej tabeli.The regular expression can be interpreted as shown in the following table.

ElementElement OpisDescription
\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match at a word boundary.
(\S+) Dopasowuje jeden lub więcej znaków niebędących znakami odstępu.Match one or more non-white-space characters. Jest to pierwsza grupa przechwytywania.This is the first capturing group.
\s? Dopasowuje zero lub jeden znak odstępu.Match zero or one white-space character.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\S+)\s?";
      string input = "This is the first sentence of the first paragraph. " + 
                            "This is the second sentence.\n" + 
                            "This is the only sentence of the second paragraph.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Groups[1]);
   }
}
// The example displays the following output:
//    This
//    is
//    the
//    first
//    sentence
//    of
//    the
//    first
//    paragraph.
//    This
//    is
//    the
//    second
//    sentence.
//    This
//    is
//    the
//    only
//    sentence
//    of
//    the
//    second
//    paragraph.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\S+)\s?"
      Dim input As String = "This is the first sentence of the first paragraph. " + _
                            "This is the second sentence." + vbCrLf + _
                            "This is the only sentence of the second paragraph."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Groups(1))
      Next
   End Sub
End Module
' The example displays the following output:
'    This
'    is
'    the
'    first
'    sentence
'    of
'    the
'    first
'    paragraph.
'    This
'    is
'    the
'    second
'    sentence.
'    This
'    is
'    the
'    only
'    sentence
'    of
'    the
'    second
'    paragraph.

Znak cyfry dziesiętnej: \dDecimal digit character: \d

\dDopasowuje dowolną cyfrę dziesiętną.\d matches any decimal digit. Jest to odpowiednik \p{Nd} wzorca wyrażenia regularnego, który zawiera standardowe cyfry dziesiętne 0-9, a także cyfry dziesiętne wielu innych zestawów znaków.It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets.

Jeśli określono zachowanie zgodne ze standardem ECMAScript \d , jest [0-9]równoważne.If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9]. Aby uzyskać informacje na temat wyrażeń regularnych języka ECMAScript, zobacz sekcję "zachowanie zgodne z językiem ECMAScript" w opcjach wyrażeń regularnych.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

Poniższy przykład ilustruje \d element języka.The following example illustrates the \d language element. Sprawdza, czy ciąg wejściowy reprezentuje prawidłowy numeru telefonu w Stanach Zjednoczonych i Kanadzie.It tests whether an input string represents a valid telephone number in the United States and Canada. Wzorzec ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.The regular expression pattern ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ is defined as shown in the following table.

ElementElement OpisDescription
^ Rozpoczyna dopasowanie na początku ciągu wejściowego.Begin the match at the beginning of the input string.
\(? Dopasowuje zero lub jeden literał znakowy „(”.Match zero or one literal "(" character.
\d{3} Dopasowuje trzy cyfry dziesiętne.Match three decimal digits.
\)? Dopasowuje zero lub jeden literał znakowy „)”.Match zero or one literal ")" character.
[\s-] Dopasowuje łącznik lub znak odstępu.Match a hyphen or a white-space character.
(\(?\d{3}\)?[\s-])? Dopasowuje opcjonalny nawias otwierający, po którym zero lub jeden raz następują trzy cyfry dziesiętne, opcjonalny nawias zamykający i znak odstępu lub łącznik.Match an optional opening parenthesis followed by three decimal digits, an optional closing parenthesis, and either a white-space character or a hyphen zero or one time. Jest to pierwsza grupa przechwytywania.This is the first capturing group.
\d{3}-\d{4} Dopasowuje trzy cyfry dziesiętne, po których następuje łącznik i cztery następne cyfry dziesiętne.Match three decimal digits followed by a hyphen and four more decimal digits.
$ Dopasowuje koniec ciągu wejściowego.Match the end of the input string.
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

Znak niebędący cyfrą: \dNon-digit character: \D

\DDopasowuje dowolny znak niebędący cyfrą.\D matches any non-digit character. Jest to odpowiednik \P{Nd} wzorca wyrażenia regularnego.It is equivalent to the \P{Nd} regular expression pattern.

Jeśli określono zachowanie zgodne ze standardem ECMAScript \D , jest [^0-9]równoważne.If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9]. Aby uzyskać informacje na temat wyrażeń regularnych języka ECMAScript, zobacz sekcję "zachowanie zgodne z językiem ECMAScript" w opcjach wyrażeń regularnych.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

W poniższym przykładzie pokazano element języka \D.The following example illustrates the \D language element. Sprawdza, czy ciąg, taki jak numer części, zawiera odpowiednią kombinację znaków dziesiętnych oraz niebędących dziesiętnymi.It tests whether a string such as a part number consists of the appropriate combination of decimal and non-decimal characters. Wzorzec ^\D\d{1,5}\D*$ wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.The regular expression pattern ^\D\d{1,5}\D*$ is defined as shown in the following table.

ElementElement OpisDescription
^ Rozpoczyna dopasowanie na początku ciągu wejściowego.Begin the match at the beginning of the input string.
\D Dopasowuje znak niebędący cyfrą.Match a non-digit character.
\d{1,5} Dopasowuje od jednej do pięciu cyfr dziesiętnych.Match from one to five decimal digits.
\D* Dopasowuje zero, jeden lub więcej znaków niebędących cyframi dziesiętnymi.Match zero, one, or more non-decimal characters.
$ Dopasowuje koniec ciągu wejściowego.Match the end of the input string.
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:

Obsługiwane kategorie ogólne UnicodeSupported Unicode general categories

Standard Unicode określa ogólne kategorie wymienione w poniższej tabeli.Unicode defines the general categories listed in the following table. Aby uzyskać więcej informacji, zobacz temat "UCD File Format" i "ogólne wartości kategorii" w bazie danych znaków Unicode.For more information, see the "UCD File Format" and "General Category Values" subtopics at the Unicode Character Database.

KategoriaCategory OpisDescription
Lu Litera, Wielkie literyLetter, Uppercase
Ll Litera, Małe literyLetter, Lowercase
Lt Litera, Duże litery na początku wyrazuLetter, Titlecase
Lm Litera, ModyfikatorLetter, Modifier
Lo Litera, InneLetter, Other
L Wszystkie znaki liter.All letter characters. Zawiera Luznaki, Ll, Lt ,iLo . LmThis includes the Lu, Ll, Lt, Lm, and Lo characters.
Mn Znak, Brak odstępówMark, Nonspacing
Mc Znak, Odstępy mieszaneMark, Spacing Combining
Me Znak, DołączenieMark, Enclosing
M Wszystkie znaki diakrytyczne.All diacritic marks. Obejmuje Mnto kategorie, Mci Me .This includes the Mn, Mc, and Me categories.
Nd Liczba, Cyfra dziesiętnaNumber, Decimal Digit
Nl Liczba, LiteraNumber, Letter
No Liczba, InneNumber, Other
N Wszystkie liczby.All numbers. Obejmuje Ndto kategorie, Nli No .This includes the Nd, Nl, and No categories.
Pc Znak interpunkcyjny, ŁącznikPunctuation, Connector
Pd Znak interpunkcyjny, KreskaPunctuation, Dash
Ps Znak interpunkcyjny, OtwarciePunctuation, Open
Pe Znak interpunkcyjny, ZamknięciePunctuation, Close
Pi Znak interpunkcyjny, Cudzysłów początkowy (może zachowywać się jak Ps i Pe w zależności od użycia)Punctuation, Initial quote (may behave like Ps or Pe depending on usage)
Pf Znak interpunkcyjny, Cudzysłów końcowy (może zachowywać się jak Ps i Pe w zależności od użycia)Punctuation, Final quote (may behave like Ps or Pe depending on usage)
Po Znak interpunkcyjny, InnePunctuation, Other
P Wszystkie znaki interpunkcyjne.All punctuation characters. Obejmuje Pcto kategorie, Pd, Ps ,,Pe, i .Po Pi PfThis includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories.
Sm Symbol, MatematyczneSymbol, Math
Sc Symbol, WalutaSymbol, Currency
Sk Symbol, ModyfikatorSymbol, Modifier
So Symbol, InneSymbol, Other
S Wszystkie symbole.All symbols. Obejmuje Smto kategorie, Sc, Ski. SoThis includes the Sm, Sc, Sk, and So categories.
Zs Separator, SpacjaSeparator, Space
Zl Separator, WierszSeparator, Line
Zp Separator, AkapitSeparator, Paragraph
Z Wszystkie znaki separatora.All separator characters. Obejmuje Zsto kategorie, Zli Zp .This includes the Zs, Zl, and Zp categories.
Cc Inne, SterowanieOther, Control
Cf Inne, FormatOther, Format
Cs Inne, ZastępczeOther, Surrogate
Co Inne, Do użytku prywatnegoOther, Private Use
Cn Inne, Nieprzypisane (żadne znaki nie mają tej właściwości)Other, Not Assigned (no characters have this property)
C Wszystkie znaki kontrolne.All control characters. Obejmuje Ccto kategorie, Cf, Cs,i. Co CnThis includes the Cc, Cf, Cs, Co, and Cn categories.

Możesz określić kategorię Unicode dowolnego określonego znaku, przekazując ten znak do GetUnicodeCategory metody.You can determine the Unicode category of any particular character by passing that character to the GetUnicodeCategory method. W poniższym przykładzie zastosowano GetUnicodeCategory metodę, aby określić kategorię każdego elementu w tablicy, która zawiera wybrane znaki łacińskie.The following example uses the GetUnicodeCategory method to determine the category of each element in an array that contains selected Latin characters.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      char[] chars = { 'a', 'X', '8', ',', ' ', '\u0009', '!' };
      
      foreach (char ch in chars)
         Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()), 
                           Char.GetUnicodeCategory(ch));
   }
}
// The example displays the following output:
//       'a': LowercaseLetter
//       'X': UppercaseLetter
//       '8': DecimalDigitNumber
//       ',': OtherPunctuation
//       '\ ': SpaceSeparator
//       '\t': Control
//       '!': OtherPunctuation
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim chars() As Char = { "a"c, "X"c, "8"c, ","c, " "c, ChrW(9), "!"c }
      
      For Each ch As Char In chars
         Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()), _
                           Char.GetUnicodeCategory(ch))
      Next         
   End Sub
End Module
' The example displays the following output:
'       'a': LowercaseLetter
'       'X': UppercaseLetter
'       '8': DecimalDigitNumber
'       ',': OtherPunctuation
'       '\ ': SpaceSeparator
'       '\t': Control
'       '!': OtherPunctuation

Obsługiwane nazwane blokiSupported named blocks

Platforma .NET udostępnia nazwane bloki wymienione w poniższej tabeli..NET provides the named blocks listed in the following table. Zestaw obsługiwanych bloków nazwanych jest oparty na standardach Unicode 4.0 i Perl 5.6.The set of supported named blocks is based on Unicode 4.0 and Perl 5.6. W przypadku wyrażenia regularnego, które używa nazwanych bloków, zobacz sekcję Kategoria Unicode lub \blok{} Unicode: p .For a regular expression that uses named blocks, see the Unicode category or Unicode block: \p{} section.

Zakres kodów znakówCode point range Nazwa blokuBlock name
0000–007F0000 - 007F IsBasicLatin
0080–00FF0080 - 00FF IsLatin-1Supplement
0100–017F0100 - 017F IsLatinExtended-A
0180–024F0180 - 024F IsLatinExtended-B
0250–02AF0250 - 02AF IsIPAExtensions
02B0–02FF02B0 - 02FF IsSpacingModifierLetters
0300–036F0300 - 036F IsCombiningDiacriticalMarks
0370–03FF0370 - 03FF IsGreek

—lub—-or-

IsGreekandCoptic
0400–04FF0400 - 04FF IsCyrillic
0500–052F0500 - 052F IsCyrillicSupplement
0530–058F0530 - 058F IsArmenian
0590–05FF0590 - 05FF IsHebrew
0600–06FF0600 - 06FF IsArabic
0700–074F0700 - 074F IsSyriac
0780–07BF0780 - 07BF IsThaana
0900–097F0900 - 097F IsDevanagari
0980–09FF0980 - 09FF IsBengali
0A00–0A7F0A00 - 0A7F IsGurmukhi
0A80–0AFF0A80 - 0AFF IsGujarati
0B00–0B7F0B00 - 0B7F IsOriya
0B80–0BFF0B80 - 0BFF IsTamil
0C00–0C7F0C00 - 0C7F IsTelugu
0C80–0CFF0C80 - 0CFF IsKannada
0D00–0D7F0D00 - 0D7F IsMalayalam
0D80–0DFF0D80 - 0DFF IsSinhala
0E00–0E7F0E00 - 0E7F IsThai
0E80–0EFF0E80 - 0EFF IsLao
0F00–0FFF0F00 - 0FFF IsTibetan
1000–109F1000 - 109F IsMyanmar
10A0–10FF10A0 - 10FF IsGeorgian
1100–11FF1100 - 11FF IsHangulJamo
1200–137F1200 - 137F IsEthiopic
13A0–13FF13A0 - 13FF IsCherokee
1400–167F1400 - 167F IsUnifiedCanadianAboriginalSyllabics
1680–169F1680 - 169F IsOgham
16A0–16FF16A0 - 16FF IsRunic
1700–171F1700 - 171F IsTagalog
1720–173F1720 - 173F IsHanunoo
1740–175F1740 - 175F IsBuhid
1760–177F1760 - 177F IsTagbanwa
1780–17FF1780 - 17FF IsKhmer
1800–18AF1800 - 18AF IsMongolian
1900–194F1900 - 194F IsLimbu
1950–197F1950 - 197F IsTaiLe
19E0–19FF19E0 - 19FF IsKhmerSymbols
1D00–1D7F1D00 - 1D7F IsPhoneticExtensions
1E00–1EFF1E00 - 1EFF IsLatinExtendedAdditional
1F00–1FFF1F00 - 1FFF IsGreekExtended
2000–206F2000 - 206F IsGeneralPunctuation
2070–209F2070 - 209F IsSuperscriptsandSubscripts
20A0–20CF20A0 - 20CF IsCurrencySymbols
20D0–20FF20D0 - 20FF IsCombiningDiacriticalMarksforSymbols

—lub—-or-

IsCombiningMarksforSymbols
2100–214F2100 - 214F IsLetterlikeSymbols
2150–218F2150 - 218F IsNumberForms
2190–21FF2190 - 21FF IsArrows
2200–22FF2200 - 22FF IsMathematicalOperators
2300–23FF2300 - 23FF IsMiscellaneousTechnical
2400–243F2400 - 243F IsControlPictures
2440–245F2440 - 245F IsOpticalCharacterRecognition
2460–24FF2460 - 24FF IsEnclosedAlphanumerics
2500–257F2500 - 257F IsBoxDrawing
2580–259F2580 - 259F IsBlockElements
25A0–25FF25A0 - 25FF IsGeometricShapes
2600–26FF2600 - 26FF IsMiscellaneousSymbols
2700–27BF2700 - 27BF IsDingbats
27C0–27EF27C0 - 27EF IsMiscellaneousMathematicalSymbols-A
27F0–27FF27F0 - 27FF IsSupplementalArrows-A
2800–28FF2800 - 28FF IsBraillePatterns
2900–297F2900 - 297F IsSupplementalArrows-B
2980–29FF2980 - 29FF IsMiscellaneousMathematicalSymbols-B
2A00–2AFF2A00 - 2AFF IsSupplementalMathematicalOperators
2B00–2BFF2B00 - 2BFF IsMiscellaneousSymbolsandArrows
2E80–2EFF2E80 - 2EFF IsCJKRadicalsSupplement
2F00–2FDF2F00 - 2FDF IsKangxiRadicals
2FF0–2FFF2FF0 - 2FFF IsIdeographicDescriptionCharacters
3000–303F3000 - 303F IsCJKSymbolsandPunctuation
3040–309F3040 - 309F IsHiragana
30A0–30FF30A0 - 30FF IsKatakana
3100–312F3100 - 312F IsBopomofo
3130–318F3130 - 318F IsHangulCompatibilityJamo
3190–319F3190 - 319F IsKanbun
31A0–31BF31A0 - 31BF IsBopomofoExtended
31F0–31FF31F0 - 31FF IsKatakanaPhoneticExtensions
3200–32FF3200 - 32FF IsEnclosedCJKLettersandMonths
3300–33FF3300 - 33FF IsCJKCompatibility
3400–4DBF3400 - 4DBF IsCJKUnifiedIdeographsExtensionA
4DC0–4DFF4DC0 - 4DFF IsYijingHexagramSymbols
4E00–9FFF4E00 - 9FFF IsCJKUnifiedIdeographs
A000–A48FA000 - A48F IsYiSyllables
A490–A4CFA490 - A4CF IsYiRadicals
AC00–D7AFAC00 - D7AF IsHangulSyllables
D800–DB7FD800 - DB7F IsHighSurrogates
DB80–DBFFDB80 - DBFF IsHighPrivateUseSurrogates
DC00–DFFFDC00 - DFFF IsLowSurrogates
E000–F8FFE000 - F8FF IsPrivateUse lub IsPrivateUseAreaIsPrivateUse or IsPrivateUseArea
F900–FAFFF900 - FAFF IsCJKCompatibilityIdeographs
FB00–FB4FFB00 - FB4F IsAlphabeticPresentationForms
FB50–FDFFFB50 - FDFF IsArabicPresentationForms-A
FE00–FE0FFE00 - FE0F IsVariationSelectors
FE20–FE2FFE20 - FE2F IsCombiningHalfMarks
FE30–FE4FFE30 - FE4F IsCJKCompatibilityForms
FE50–FE6FFE50 - FE6F IsSmallFormVariants
FE70–FEFFFE70 - FEFF IsArabicPresentationForms-B
FF00–FFEFFF00 - FFEF IsHalfwidthandFullwidthForms
FFF0–FFFFFFF0 - FFFF IsSpecials

Odejmowanie klasy znaków: [Base_group-[Excluded_group]]Character class subtraction: [base_group - [excluded_group]]

Klasy znaków definiuje zestaw znaków.A character class defines a set of characters. Wynikiem odejmowania klas znaków jest zestaw znaków będący wynikiem wykluczenia znaków jednej klasy znaków z innej klasy znaków.Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class.

Wyrażenie odejmowania klas znaków ma następującą formę:A character class subtraction expression has the following form:

[Base_group -[ Excluded_group]][ base_group -[ excluded_group ]]

Nawiasy kwadratowe[]() i łącznik-() są obowiązkowe.The square brackets ([]) and hyphen (-) are mandatory. Base_group jest grupą znaków pozytywnych lub grupą znaków negatywnych.The base_group is a positive character group or a negative character group. Składnik Excluded_group jest kolejną dodatnią lub ujemną grupą znaków lub innym wyrażeniem odejmowania klasy znaków (to oznacza, że można zagnieżdżać wyrażenia odejmowania klas znaków).The excluded_group component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions).

Na przykład załóżmy że grupa podstawowa składa się z zakresu znaków od „a” do „z”.For example, suppose you have a base group that consists of the character range from "a" through "z". Aby zdefiniować zestaw znaków, który składa się z grupy podstawowej z wyjątkiem znaku "m", użyj [a-z-[m]].To define the set of characters that consists of the base group except for the character "m", use [a-z-[m]]. Aby zdefiniować zestaw znaków, który składa się z grupy podstawowej, z wyjątkiem zestawu znaków "d", "j" i "p", użyj [a-z-[djp]].To define the set of characters that consists of the base group except for the set of characters "d", "j", and "p", use [a-z-[djp]]. Aby zdefiniować zestaw znaków, który składa się z grupy podstawowej z wyjątkiem zakresu znaków od "m" do "p", użyj [a-z-[m-p]].To define the set of characters that consists of the base group except for the character range from "m" through "p", use [a-z-[m-p]].

Rozważ wyrażenie odejmowania klasy znaków zagnieżdżonych, [a-z-[d-w-[m-o]]].Consider the nested character class subtraction expression, [a-z-[d-w-[m-o]]]. To wyrażenie jest wykonywane począwszy od najbardziej wewnętrznego zakresu znaków na zewnątrz.The expression is evaluated from the innermost character range outward. Najpierw zakres znaków od „m” do „o” jest odejmowany od zakresu znaków od „d” do „w”, wynikiem czego jest zestaw znaków od „d” do „l” oraz od „p” do „w”.First, the character range from "m" through "o" is subtracted from the character range "d" through "w", which yields the set of characters from "d" through "l" and "p" through "w". Ten zestaw jest następnie odejmowany od zakresu znaków od "a" do "z", który daje zestaw znaków [abcmnoxyz].That set is then subtracted from the character range from "a" through "z", which yields the set of characters [abcmnoxyz].

Można odejmować dowolne klasy znaków.You can use any character class with character class subtraction. Aby zdefiniować zestaw znaków, który składa się ze wszystkich znaków Unicode od \u0000 do \uFFFF, z wyjątkiem białych znaków\s(), znaków w ogólnej kategorii (\p{P}) IsGreek , znaków w nazwie Block (\p{IsGreek}) i znak kontrolny następnej linii Unicode (\x85), użyj [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].To define the set of characters that consists of all Unicode characters from \u0000 through \uFFFF except white-space characters (\s), the characters in the punctuation general category (\p{P}), the characters in the IsGreek named block (\p{IsGreek}), and the Unicode NEXT LINE control character (\x85), use [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].

W wyrażeniach odejmowania klas znaków należy używać klas znaków umożliwiających zwrócenie przydatnych wyników.Choose character classes for a character class subtraction expression that will yield useful results. Należy unikać wyrażeń, które zwracają puste zestawy znaków, które nie mogą nic dopasować, oraz wyrażeń, które są równoważne oryginalnej grupie podstawowej.Avoid an expression that yields an empty set of characters, which cannot match anything, or an expression that is equivalent to the original base group. Na przykład pusty zestaw jest wynikiem wyrażenia [\p{IsBasicLatin}-[\x00-\x7F]], które odejmuje wszystkie znaki IsBasicLatin w zakresie znaków od IsBasicLatin kategorii Ogólne.For example, the empty set is the result of the expression [\p{IsBasicLatin}-[\x00-\x7F]], which subtracts all characters in the IsBasicLatin character range from the IsBasicLatin general category. Analogicznie, oryginalna Grupa podstawowa jest wynikiem wyrażenia [a-z-[0-9]].Similarly, the original base group is the result of the expression [a-z-[0-9]]. Dzieje się tak, ponieważ grupa podstawowa, czyli zakres znaków od „a” do „z”, nie zawiera żadnych znaków z grupy wykluczanej, która jest zakresem cyfr dziesiętnych od „0” do „9”.This is because the base group, which is the character range of letters from "a" through "z", does not contain any characters in the excluded group, which is the character range of decimal digits from "0" through "9".

Poniższy przykład definiuje wyrażenie regularne, ^[0-9-[2468]]+$które dopasowuje zero i nieparzystą cyfr w ciągu wejściowym.The following example defines a regular expression, ^[0-9-[2468]]+$, that matches zero and odd digits in an input string. Wyrażenie regularne jest interpretowane tak jak pokazano w poniższej tabeli.The regular expression is interpreted as shown in the following table.

ElementElement OpisDescription
^ Dopasowywanie rozpoczyna się początku ciągu wejściowego.Begin the match at the start of the input string.
[0-9-[2468]]+ Dopasowuje jedno lub więcej wystąpień dowolnego znaku z zakresu od 0 do 9 z wyjątkiem 2, 4, 6 i 8.Match one or more occurrences of any character from 0 to 9 except for 2, 4, 6, and 8. Innymi słowy, dopasowuje co najmniej jedno wystąpienie zera lub cyfry nieparzystej.In other words, match one or more occurrences of zero or an odd digit.
$ Dopasowywanie kończy się na końcu ciągu wejściowego.End the match at the end of the input string.
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

Zobacz takżeSee also