Klasy znaków w wyrażeniach regularnych
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. Język wyrażeń regularnych na platformie .NET obsługuje następujące klasy znaków:
Grupy znaków pozytywnych. Znak w ciągu wejściowym musi odpowiadać jednemu ze znaków z określonego zestawu znaków. Aby uzyskać więcej informacji, zobacz Pozytywna grupa znaków.
Grupy znaków negatywnych. Znak w ciągu wejściowym nie może odpowiadać żadnemu ze znaków z określonego zestawu znaków. Aby uzyskać więcej informacji, zobacz Negatywna grupa znaków.
Dowolny znak. Znak (kropka lub kropka
.) w wyrażeniu regularnym jest symbolem wieloznacznym, który pasuje do dowolnego znaku z wyjątkiem\n. Aby uzyskać więcej informacji, zobacz Dowolny znak.Ogólna kategoria Unicode lub blok nazwany. 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. Aby uzyskać więcej informacji, zobacz Kategoria Unicode lub Blok Unicode.
Negatywna ogólna kategoria Unicode lub blok nazwany. 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. Aby uzyskać więcej informacji, zobacz Ujemna kategoria Unicode lub blok Unicode.
Znak słowa. Znak w ciągu wejściowym może należeć do dowolnej kategorii Unicode, która jest odpowiednia dla znaków w wyrazach. Aby uzyskać więcej informacji, zobacz Znak programu Word.
Znak niebędący znakiem słowa. Znak w ciągu wejściowym może należeć do dowolnej kategorii Unicode, która nie jest znakiem słowa. Aby uzyskać więcej informacji, zobacz Znak inny niż word.
Znak odstępu. Znak w ciągu wejściowym może być dowolnym znakiem separatora Unicode, a także dowolnym ze znaków kontrolnych. Aby uzyskać więcej informacji, zobacz Znak odstępu.
Znak niebędący odstępem. Znak w ciągu wejściowym może być dowolnym znakiem, który nie jest znakiem odstępu. Aby uzyskać więcej informacji, zobacz Znak inny niż biały.
Cyfra dziesiętna. Znak w ciągu wejściowym może być dowolnym ze znaków klasyfikowanych jako cyfry dziesiętne Unicode. Aby uzyskać więcej informacji, zobacz Znak cyfry dziesiętnej.
Cyfra niebędąca cyfrą dziesiętną. Znak w ciągu wejściowym może być dowolnym znakiem innym niż cyfra dziesiętna Unicode. Aby uzyskać więcej informacji, zobacz Znak cyfry dziesiętnej.
Platforma .NET obsługuje wyrażenia odejmowania klas znaków, co umożliwia zdefiniowanie zestawu znaków w wyniku wykluczenia jednej klasy znaków z innej klasy znaków. Aby uzyskać więcej informacji, zobacz Odejmowanie klasy znaków.
Uwaga
Klasy znaków pasujące do znaków według kategorii, takie jak \w, aby dopasować znaki słów lub \p{}, aby dopasować kategorię Unicode, polegają na CharUnicodeInfo klasie, aby podać informacje o kategoriach znaków. W programie .NET Framework 4.6.2 i nowszych wersjach kategorie znaków są oparte na standardzie Unicode w wersji 8.0.0.
Grupa znaków dodatnich: [ ]
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. Ta lista znaków może być określona indywidualnie, jako zakres lub na oba te sposoby.
Składnia służąca do określenia listy indywidualnych znaków jest następująca:
[*character_group*]
gdzie character_group jest listą poszczególnych znaków, które mogą pojawić się w ciągu wejściowym, aby dopasowanie powiodło się. character_group może składać się z dowolnej kombinacji co najmniej jednego znaku literału, znaków ucieczki lub klas znaków.
Składnia służąca do określania zakresu znaków jest następująca:
[firstCharacter-lastCharacter]
gdzie firstCharacter jest znakiem rozpoczynającym zakres, a ostatniCharacter jest znakiem kończącym zakres. 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. Dwa znaki są ciągłe, jeśli mają sąsiadujące punkty kodowe Unicode. firstCharacter musi być znakiem o niższym punkcie kodu, a lastCharacter musi być znakiem o wyższym punkcie kodu.
Uwaga
Ponieważ grupa znaków dodatnich 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.
Aby dołączyć łącznik jako element członkowski nieperyferalny grupy znaków, należy go uniknić. Na przykład aby utworzyć grupę znaków dla znaku a i znaków z - do /, poprawna składnia to [a\--/].
W poniższej tabeli wymieniono niektóre typowe wzorce wyrażeń regularnych zawierających klasy znaków pozytywnych.
| Wzorzec | opis |
|---|---|
[aeiou] |
Dopasowuje wszystkie samogłoski. |
[\p{P}\d] |
Dopasowuje wszystkie znaki interpunkcyjne oraz znaki cyfr dziesiętnych. |
[\s\p{P}] |
Dopasuj wszystkie białe znaki i znaki interpunkcyjne. |
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.
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 definiowane w następujący sposób:
| Wzorzec | opis |
|---|---|
gr |
Dopasowuje znaki literału „gr”. |
[ae] |
Dopasowuje znak „a” lub „e”. |
y\s |
Dopasowuje znak literału „y”, po którym następuje znak odstępu. |
\S+? |
Dopasowuje jeden lub więcej znaków, które nie są znakami odstępu, jednak możliwie najmniej. |
[\s\p{P}] |
Dopasowuje znak odstępu lub znak interpunkcyjny. |
W poniższym przykładzie dopasowywane są wyrazy zaczynające się od wielkiej litery. Używa wyrażenia podrzędnego [A-Z] do reprezentowania zakresu liter wielkich z A do Z.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b[A-Z]\w*\b";
string input = "A city Albany Zulu maritime Marseilles";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(match.Value);
}
}
// The example displays the following output:
// A
// Albany
// Zulu
// Marseilles
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b[A-Z]\w*\b"
Dim input As String = "A city Albany Zulu maritime Marseilles"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(match.Value)
Next
End Sub
End Module
Wyrażenie \b[A-Z]\w*\b regularne jest definiowane, jak pokazano w poniższej tabeli.
| Wzorzec | opis |
|---|---|
\b |
Rozpoczyna na granicy wyrazu. |
[A-Z] |
Dopasowuje dowolny znak wielkiej litery z zakresu od A do Z. |
\w* |
Dopasowuje zero lub więcej znaków słowa. |
\b |
Dopasowuje granicę wyrazu. |
Grupa znaków ujemnych: [^]
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. Ta lista znaków może być określona indywidualnie, jako zakres lub na oba te sposoby.
Składnia służąca do określenia listy indywidualnych znaków jest następująca:
[*^character_group*]
gdzie character_group jest listą poszczególnych znaków, których nie można wyświetlić w ciągu wejściowym, aby dopasowanie powiodło się. character_group może składać się z dowolnej kombinacji co najmniej jednego znaku literału, znaków ucieczki lub klas znaków.
Składnia służąca do określania zakresu znaków jest następująca:
[^*firstCharacter*-*lastCharacter*]
gdzie firstCharacter jest znakiem rozpoczynającym zakres, a ostatniCharacter jest znakiem kończącym zakres. 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. Dwa znaki są ciągłe, jeśli mają sąsiadujące punkty kodowe Unicode. firstCharacter musi być znakiem o niższym punkcie kodu, a lastCharacter musi być znakiem o wyższym punkcie kodu.
Uwaga
Ponieważ grupa znaków ujemnych 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.
Można połączyć co najmniej dwa zakresy znaków. Aby na przykład 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]
Wiodący znak karetki (^) w grupie znaków ujemnych jest obowiązkowy i wskazuje, że grupa znaków jest grupą znaków ujemnych zamiast grupy znaków dodatnich.
Ważne
Grupa znaków negatywnych w większym wzorcu wyrażenia regularnego nie jest asercją o zerowej szerokości. Czyli po dokonaniu oceny grupy znaków negatywnych aparat wyrażeń regularnych postępuje o jeden znak do przodu w ciągu wejściowym.
W poniższej tabeli wymieniono niektóre typowe wzorce wyrażeń regularnych zawierających grupy znaków negatywnych.
| Wzorzec | opis |
|---|---|
[^aeiou] |
Dopasowuje wszystkie znaki z wyjątkiem samogłosek. |
[^\p{P}\d] |
Dopasowuje wszystkie znaki z wyjątkiem znaków interpunkcyjnych oraz znaków cyfr dziesiętnych. |
W poniższym przykładzie jest dopasowywany dowolny wyraz rozpoczynający się od znaków „th”, po których nie występuje znak „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 definiowane, jak pokazano w poniższej tabeli.
| Wzorzec | opis |
|---|---|
\b |
Rozpoczyna na granicy wyrazu. |
th |
Dopasowuje znaki literału „th”. |
[^o] |
Dopasowuje dowolny znak inny niż „o”. |
\w+ |
Dopasowuje co najmniej jeden znak słowa. |
\b |
Kończy na granicy wyrazu. |
Dowolny znak: .
Znak kropki (.) pasuje do dowolnego znaku z wyjątkiem \n (znak nowego wiersza), z następującymi dwoma kwalifikacjami:
Jeśli wzorzec wyrażenia regularnego jest modyfikowany przez RegexOptions.Singleline opcję lub część wzorca zawierającego
.klasę znaków jest modyfikowana przezstę opcję,.pasuje do dowolnego znaku. Aby uzyskać więcej informacji, zobacz Opcje wyrażeń regularnych.Poniższy przykład ilustruje różne zachowanie
.klasy znaków domyślnie i z opcją RegexOptions.Singleline . Wyrażenie^.+regularne rozpoczyna się na początku ciągu i pasuje do każdego znaku. Domyślnie dopasowanie kończy się na końcu pierwszego wiersza; wzorzec wyrażenia regularnego pasuje do znaku powrotu karetki,\rale nie jest zgodny\nz . RegexOptions.Singleline Ponieważ opcja interpretuje cały ciąg wejściowy jako pojedynczy wiersz, pasuje do każdego znaku w ciągu wejściowym, w tym\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ż pasuje do dowolnego znaku z wyjątkiem \n, . klasa znaków również pasuje \r (znak powrotu karetki).
W grupie znaków pozytywnych lub negatywnych kropka jest traktowana jako znak kropki literału, a nie jako klasa znaków. Aby uzyskać więcej informacji, zobacz Pozytywna grupa znaków i Grupa negatywnych znaków we wcześniejszej części tego tematu. Poniższy przykład przedstawia ilustrację przez zdefiniowanie wyrażenia regularnego zawierającego znak kropki (
.) zarówno jako klasę znaków, jak i jako składową grupy znaków dodatnich. Wyrażenie\b.*[.?!;:](\s|\z)regularne rozpoczyna się od granicy słowa, dopasuje dowolny znak, dopóki nie napotka jednego z pięciu znaków interpunkcyjnych, w tym kropki, a następnie dopasuje znak odstępu lub koniec ciągu.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ż pasuje do dowolnego znaku, element języka jest często używany z leniwym kwantyfikatorem, . jeśli wzorzec wyrażenia regularnego próbuje dopasować dowolny znak wiele razy. Aby uzyskać więcej informacji, zobacz Kwantyfikatory.
Kategoria Unicode lub blok Unicode: \p{}
W standardzie Unicode każdemu znakowi przypisuje się kategorię ogólną. Na przykład określony znak może być wielką literą (reprezentowaną przez Lu kategorię), cyfrą dziesiętną (kategorią), symbolem matematycznym ( Nd Sm kategoria) lub separatorem akapitu Zl (kategoria). Określone zestawy znaków w standardzie Unicode zajmują również określony zakres lub blok kolejnych kodów znaku. 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.
Konstrukcja wyrażenia regularnego
\p{nazwa }
pasuje do dowolnego znaku należącego do kategorii ogólnej Unicode lub nazwanego bloku, gdzie nazwa jest skrótem kategorii lub nazwaną nazwą bloku. Aby uzyskać listę skrótów kategorii, zobacz sekcję Obsługiwane kategorie ogólne Unicode w dalszej części tego tematu. Listę nazwanych bloków można znaleźć w sekcji Obsługiwane nazwane bloki w dalszej części tego tematu.
Napiwek
Dopasowanie może zostać ulepszone, jeśli ciąg jest najpierw znormalizowany przez wywołanie String.Normalize metody .
W poniższym przykładzie użyto \p{konstrukcji nazw} , aby dopasować zarówno kategorię ogólną Unicode (w tym przypadku Pd, lub interpunkcję, kategorię Dash) i nazwany blok ( IsGreek bloki i IsBasicLatin nazwane).
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 definiowane, jak pokazano w poniższej tabeli.
| Wzorzec | opis |
|---|---|
\b |
Rozpoczyna na granicy wyrazu. |
\p{IsGreek}+ |
Dopasowuje jeden lub więcej znaków greckich. |
(\s)? |
Dopasowuje zero lub jeden znak odstępu. |
(\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. |
\p{Pd} |
Dopasowuje znak interpunkcyjny kreskę. |
\s |
Dopasowuje znak odstępu. |
\p{IsBasicLatin}+ |
Dopasowuje jeden lub więcej znaków łacińskich. |
(\s)? |
Dopasowuje zero lub jeden znak odstępu. |
(\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. |
Ujemna kategoria Unicode lub blok Unicode: \P{}
W standardzie Unicode każdemu znakowi przypisuje się kategorię ogólną. Na przykład określony znak może być wielką literą (reprezentowaną przez Lu kategorię), cyfrą dziesiętną (kategorią), symbolem matematycznym ( Nd Sm kategoria) lub separatorem akapitu Zl (kategoria). Określone zestawy znaków w standardzie Unicode zajmują również określony zakres lub blok kolejnych kodów znaku. 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.
Konstrukcja wyrażenia regularnego
\P{nazwa }
pasuje do dowolnego znaku, który nie należy do kategorii ogólnej Unicode lub nazwanego bloku, gdzie nazwa jest skrótem kategorii lub nazwanym nazwą bloku. Aby uzyskać listę skrótów kategorii, zobacz sekcję Obsługiwane kategorie ogólne Unicode w dalszej części tego tematu. Listę nazwanych bloków można znaleźć w sekcji Obsługiwane nazwane bloki w dalszej części tego tematu.
Napiwek
Dopasowanie może zostać ulepszone, jeśli ciąg jest najpierw znormalizowany przez wywołanie String.Normalize metody .
W poniższym przykładzie użyto \P{konstrukcji nazwy}, aby usunąć wszelkie symbole waluty (w tym przypadku Sckategoria , lub Symbol, Waluta) z ciągów liczbowych.
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 pasuje do jednego lub większej liczby znaków, które nie są symbolami walutowymi; skutecznie usuwa dowolny symbol waluty z ciągu wynikowego.
Znak wyrazu: \w
\w pasuje do dowolnego znaku słowa. Znak słowa jest elementem członkowskim każdej z kategorii Unicode wymienionej w poniższej tabeli.
| Kategoria | opis |
|---|---|
| Ll | Litera, Małe litery |
| Lu | Litera, Wielkie litery |
| Lt | Litera, Duże litery na początku wyrazu |
| Lo | Litera, Inne |
| Lm | Litera, Modyfikator |
| Mn | Znak, Brak odstępów |
| Nd | Liczba, Cyfra dziesiętna |
| Pc | Znak interpunkcyjny, Łącznik. Ta kategoria obejmuje dziesięć znaków, z których najczęściej używany jest znak LOWLINE (_), u+005F. |
Jeśli określono zachowanie zgodne ze standardem ECMAScript, \w jest równoważne .[a-zA-Z_0-9] Aby uzyskać informacje na temat wyrażeń regularnych ECMAScript, zobacz sekcję "EcMAScript Matching Behavior" w temacie Regular Expression Options (Opcje wyrażeń regularnych).
Uwaga
Ponieważ pasuje do dowolnego znaku słowa, element języka jest często używany z leniwym kwantyfikatorem, \w jeśli wzorzec wyrażenia regularnego próbuje dopasować dowolny znak słowa wiele razy, a następnie określony znak słowa. Aby uzyskać więcej informacji, zobacz Kwantyfikatory.
W poniższym przykładzie użyto \w elementu języka, aby dopasować zduplikowane znaki w słowie. W przykładzie zdefiniowano wzorzec wyrażenia regularnego , (\w)\1który można interpretować w następujący sposób.
| Element | opis |
|---|---|
| (\w) | Dopasowuje znak słowa. Jest to pierwsza grupa przechwytywania. |
| \1 | Dopasowuje wartość pierwszego przechwycenia. |
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 inny niż wyraz: \W
\W pasuje do dowolnego znaku innego niż wyraz. Element języka \W jest równoważny z następującą klasą znaków:
[^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]
Innymi słowy, pasuje do dowolnego znaku z wyjątkiem tych w kategoriach Unicode wymienionych w poniższej tabeli.
| Kategoria | opis |
|---|---|
| Ll | Litera, Małe litery |
| Lu | Litera, Wielkie litery |
| Lt | Litera, Duże litery na początku wyrazu |
| Lo | Litera, Inne |
| Lm | Litera, Modyfikator |
| Mn | Znak, Brak odstępów |
| Nd | Liczba, Cyfra dziesiętna |
| Pc | Znak interpunkcyjny, Łącznik. Ta kategoria obejmuje dziesięć znaków, z których najczęściej używany jest znak LOWLINE (_), u+005F. |
Jeśli określono zachowanie zgodne ze standardem ECMAScript, \W jest równoważne .[^a-zA-Z_0-9] Aby uzyskać informacje na temat wyrażeń regularnych ECMAScript, zobacz sekcję "EcMAScript Matching Behavior" w temacie Regular Expression Options (Opcje wyrażeń regularnych).
Uwaga
Ponieważ pasuje do dowolnego znaku innego niż wyraz, element języka jest często używany z leniwym kwantyfikatorem, \W jeśli wzorzec wyrażenia regularnego próbuje dopasować dowolny znak inny niż wyraz wiele razy, po którym następuje określony znak inny niż wyraz. Aby uzyskać więcej informacji, zobacz Kwantyfikatory.
Poniższy przykład ilustruje klasę \W znaków. Definiuje wzorzec wyrażenia regularnego , \b(\w+)(\W){1,2}który pasuje do wyrazu, po którym następuje jeden lub dwa znaki inne niż wyrazy, takie jak biały znak lub znak interpunkcyjny. Wyrażenie regularne jest interpretowane tak jak pokazano w poniższej tabeli.
| Element | opis |
|---|---|
| \b | Rozpoczyna dopasowanie na granicy wyrazu. |
| (\w+) | Dopasowuje co najmniej jeden znak słowa. Jest to pierwsza grupa przechwytywania. |
| (\W){1,2} | Dopasowuje znak niebędący znakiem słowa jeden lub dwa razy. Jest to druga grupa przechwytywania. |
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)
Group Ponieważ obiekt drugiej grupy przechwytywania zawiera tylko jeden przechwycony znak inny niż słowo, w przykładzie są pobierane wszystkie przechwycone znaki inne niż słowa z CaptureCollection obiektu zwracanego przez Group.Captures właściwość .
Znak odstępu: \s
\s pasuje do dowolnego znaku odstępu. Jest to równoważne z sekwencjami ucieczki oraz kategoriami Unicode wymienionymi w poniższej tabeli.
| Kategoria | opis |
|---|---|
\f |
Znak wysuwu strony, \u000C. |
\n |
Znak nowego wiersza, \u000A. |
\r |
Znaku powrotu karetki, \u000D. |
\t |
Znak tabulacji, \u0009. |
\v |
Znak tabulacji pionowej, \u000B. |
\x85 |
Znak NASTĘPNY WIERSZ (NEL), \u0085. |
\p{Z} |
Pasuje do wszystkich znaków separatora. Obejmuje Zsto kategorie , Zli Zp . |
Jeśli określono zachowanie zgodne ze standardem ECMAScript, \s jest równoważne .[ \f\n\r\t\v] Aby uzyskać informacje na temat wyrażeń regularnych ECMAScript, zobacz sekcję "EcMAScript Matching Behavior" w temacie Regular Expression Options (Opcje wyrażeń regularnych).
Poniższy przykład ilustruje klasę \s znaków. Definiuje wzorzec wyrażenia regularnego, \b\w+(e)?s(\s|$)który pasuje do wyrazu kończącego się znakiem "s" lub "es", po którym następuje znak odstępu lub koniec ciągu wejściowego. Wyrażenie regularne jest interpretowane tak jak pokazano w poniższej tabeli.
| Element | opis |
|---|---|
| \b | Rozpoczyna dopasowanie na granicy wyrazu. |
| \w+ | Dopasowuje co najmniej jeden znak słowa. |
| (e)? | Dopasowuje znak „e” zero lub jeden raz. |
| s | Dopasowuje znak „s”. |
| (\s|$) | Dopasuj znak odstępu lub koniec ciągu wejściowego. |
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 bez odstępu: \S
\S pasuje do dowolnego znaku innego niż odstęp. Jest to odpowiednik wzorca wyrażenia regularnego [^\f\n\r\t\v\x85\p{Z}] lub przeciwieństwo wzorca wyrażenia regularnego, który jest odpowiednikiem znaku , który odpowiada znakom \sodstępu. Aby uzyskać więcej informacji, zobacz Znak odstępu: \s.
Jeśli określono zachowanie zgodne ze standardem ECMAScript, \S jest równoważne .[^ \f\n\r\t\v] Aby uzyskać informacje na temat wyrażeń regularnych ECMAScript, zobacz sekcję "EcMAScript Matching Behavior" w temacie Regular Expression Options (Opcje wyrażeń regularnych).
Poniższy przykład ilustruje \S element języka. Wzorzec \b(\S+)\s? wyrażenia regularnego jest zgodny z ciągami rozdzielanymi znakami odstępu. Drugi element w obiekcie dopasowania GroupCollection zawiera dopasowany ciąg. Wyrażenie regularne może być interpretowane tak jak pokazano w poniższej tabeli.
| Element | opis |
|---|---|
\b |
Rozpoczyna dopasowanie na granicy wyrazu. |
(\S+) |
Dopasowuje jeden lub więcej znaków niebędących znakami odstępu. Jest to pierwsza grupa przechwytywania. |
\s? |
Dopasowuje zero lub jeden znak odstępu. |
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: \d
\d pasuje do dowolnej cyfry dziesiętnej. Jest to odpowiednik wzorca wyrażenia regularnego \p{Nd} , który zawiera standardowe cyfry dziesiętne 0–9, a także cyfry dziesiętne wielu innych zestawów znaków.
Jeśli określono zachowanie zgodne ze standardem ECMAScript, \d jest równoważne .[0-9] Aby uzyskać informacje na temat wyrażeń regularnych ECMAScript, zobacz sekcję "EcMAScript Matching Behavior" w temacie Regular Expression Options (Opcje wyrażeń regularnych).
Poniższy przykład ilustruje \d element języka. Sprawdza, czy ciąg wejściowy reprezentuje prawidłowy numeru telefonu w Stanach Zjednoczonych i Kanadzie. Wzorzec ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.
| Element | opis |
|---|---|
^ |
Rozpoczyna dopasowanie na początku ciągu wejściowego. |
\(? |
Dopasowuje zero lub jeden literał znakowy „(”. |
\d{3} |
Dopasowuje trzy cyfry dziesiętne. |
\)? |
Dopasowuje zero lub jeden literał znakowy „)”. |
[\s-] |
Dopasowuje łącznik lub znak odstępu. |
(\(?\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. Jest to pierwsza grupa przechwytywania. |
\d{3}-\d{4} |
Dopasowuje trzy cyfry dziesiętne, po których następuje łącznik i cztery następne cyfry dziesiętne. |
$ |
Dopasowuje koniec ciągu wejściowego. |
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 niecyfrowy: \D
\D pasuje do dowolnego znaku innego niż cyfra. Jest to odpowiednik wzorca wyrażenia regularnego \P{Nd} .
Jeśli określono zachowanie zgodne ze standardem ECMAScript, \D jest równoważne .[^0-9] Aby uzyskać informacje na temat wyrażeń regularnych ECMAScript, zobacz sekcję "EcMAScript Matching Behavior" w temacie Regular Expression Options (Opcje wyrażeń regularnych).
W poniższym przykładzie pokazano element języka \D. Sprawdza, czy ciąg, taki jak numer części, zawiera odpowiednią kombinację znaków dziesiętnych oraz niebędących dziesiętnymi. Wzorzec ^\D\d{1,5}\D*$ wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.
| Element | opis |
|---|---|
^ |
Rozpoczyna dopasowanie na początku ciągu wejściowego. |
\D |
Dopasowuje znak niebędący cyfrą. |
\d{1,5} |
Dopasowuje od jednej do pięciu cyfr dziesiętnych. |
\D* |
Dopasuj zero, jeden lub więcej znaków innych niż dziesiętne. |
$ |
Dopasowuje koniec ciągu wejściowego. |
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 Unicode
Standard Unicode określa ogólne kategorie wymienione w poniższej tabeli. Aby uzyskać więcej informacji, zobacz podtopy "Format pliku UCD" i "Ogólne wartości kategorii" w bazie danych znaków Unicode, sec. 5.7.1, Table 12.
| Kategoria | opis |
|---|---|
Lu |
Litera, Wielkie litery |
Ll |
Litera, Małe litery |
Lt |
Litera, Duże litery na początku wyrazu |
Lm |
Litera, Modyfikator |
Lo |
Litera, Inne |
L |
Wszystkie znaki liter. LuObejmuje to znaki , , LtLl, Lmi Lo . |
Mn |
Znak, Brak odstępów |
Mc |
Znak, Odstępy mieszane |
Me |
Znak, Dołączenie |
M |
Wszystkie znaki łączące. Obejmuje Mnto kategorie , Mci Me . |
Nd |
Liczba, Cyfra dziesiętna |
Nl |
Liczba, Litera |
No |
Liczba, Inne |
N |
Wszystkie liczby. Obejmuje Ndto kategorie , Nli No . |
Pc |
Znak interpunkcyjny, Łącznik |
Pd |
Znak interpunkcyjny, Kreska |
Ps |
Znak interpunkcyjny, Otwarcie |
Pe |
Znak interpunkcyjny, Zamknięcie |
Pi |
Znak interpunkcyjny, Cudzysłów początkowy (może zachowywać się jak Ps i Pe w zależności od użycia) |
Pf |
Znak interpunkcyjny, Cudzysłów końcowy (może zachowywać się jak Ps i Pe w zależności od użycia) |
Po |
Znak interpunkcyjny, Inne |
P |
Wszystkie znaki interpunkcyjne. Obejmuje Pcto kategorie , , Pd, PePsPi, , Pfi Po . |
Sm |
Symbol, Matematyczne |
Sc |
Symbol, Waluta |
Sk |
Symbol, Modyfikator |
So |
Symbol, Inne |
S |
Wszystkie symbole. Obejmuje Smto kategorie , Sc, Ski So . |
Zs |
Separator, Spacja |
Zl |
Separator, Wiersz |
Zp |
Separator, Akapit |
Z |
Wszystkie znaki separatora. Obejmuje Zsto kategorie , Zli Zp . |
Cc |
Inne, Sterowanie |
Cf |
Inne, Format |
Cs |
Inne, Zastępcze |
Co |
Inne, Do użytku prywatnego |
Cn |
Inne, nieprzypisane lub nietypowe |
C |
Wszystkie inne znaki. Obejmuje Ccto kategorie , , CsCf, Coi Cn . |
Kategorię Unicode dowolnego określonego znaku można określić, przekazując ten znak do GetUnicodeCategory metody . W poniższym przykładzie użyto GetUnicodeCategory metody , aby określić kategorię każdego elementu w tablicy zawierającej wybrane znaki łacińskie.
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 bloki nazwane
Platforma .NET udostępnia nazwane bloki wymienione w poniższej tabeli. Zestaw obsługiwanych bloków nazwanych jest oparty na standardach Unicode 4.0 i Perl 5.6. Aby zapoznać się z wyrażeniem regularnym, które używa nazwanych bloków, zobacz kategorię Unicode lub blok Unicode: \p{} .
| Zakres kodów znaków | Nazwa 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— lub — IsGreekandCoptic |
| 0400–04FF | IsCyrillic |
| 0500–052F | IsCyrillicSupplement |
| 0530–058F | IsArmenian |
| 0590–05FF | IsHebrew |
| 0600–06FF | IsArabic |
| 0700–074F | IsSyriac |
| 0780–07BF | IsThaana |
| 0900–097F | IsDevanagari |
| 0980–09FF | IsBengali |
| 0A00–0A7F | IsGurmukhi |
| 0A80–0AFF | IsGujarati |
| 0B00–0B7F | IsOriya |
| 0B80–0BFF | IsTamil |
| 0C00–0C7F | IsTelugu |
| 0C80–0CFF | IsKannada |
| 0D00–0D7F | IsMalayalam |
| 0D80–0DFF | IsSinhala |
| 0E00–0E7F | IsThai |
| 0E80–0EFF | IsLao |
| 0F00–0FFF | IsTibetan |
| 1000–109F | IsMyanmar |
| 10A0–10FF | IsGeorgian |
| 1100–11FF | IsHangulJamo |
| 1200–137F | IsEthiopic |
| 13A0–13FF | IsCherokee |
| 1400–167F | IsUnifiedCanadianAboriginalSyllabics |
| 1680–169F | IsOgham |
| 16A0–16FF | IsRunic |
| 1700–171F | IsTagalog |
| 1720–173F | IsHanunoo |
| 1740–175F | IsBuhid |
| 1760–177F | IsTagbanwa |
| 1780–17FF | IsKhmer |
| 1800–18AF | IsMongolian |
| 1900–194F | IsLimbu |
| 1950–197F | IsTaiLe |
| 19E0–19FF | IsKhmerSymbols |
| 1D00–1D7F | IsPhoneticExtensions |
| 1E00–1EFF | IsLatinExtendedAdditional |
| 1F00–1FFF | IsGreekExtended |
| 2000–206F | IsGeneralPunctuation |
| 2070–209F | IsSuperscriptsandSubscripts |
| 20A0–20CF | IsCurrencySymbols |
| 20D0–20FF | IsCombiningDiacriticalMarksforSymbols— lub — IsCombiningMarksforSymbols |
| 2100–214F | IsLetterlikeSymbols |
| 2150–218F | IsNumberForms |
| 2190–21FF | IsArrows |
| 2200–22FF | IsMathematicalOperators |
| 2300–23FF | IsMiscellaneousTechnical |
| 2400–243F | IsControlPictures |
| 2440–245F | IsOpticalCharacterRecognition |
| 2460–24FF | IsEnclosedAlphanumerics |
| 2500–257F | IsBoxDrawing |
| 2580–259F | IsBlockElements |
| 25A0–25FF | IsGeometricShapes |
| 2600–26FF | IsMiscellaneousSymbols |
| 2700–27BF | IsDingbats |
| 27C0–27EF | IsMiscellaneousMathematicalSymbols-A |
| 27F0–27FF | IsSupplementalArrows-A |
| 2800–28FF | IsBraillePatterns |
| 2900–297F | IsSupplementalArrows-B |
| 2980–29FF | IsMiscellaneousMathematicalSymbols-B |
| 2A00–2AFF | IsSupplementalMathematicalOperators |
| 2B00–2BFF | IsMiscellaneousSymbolsandArrows |
| 2E80–2EFF | IsCJKRadicalsSupplement |
| 2F00–2FDF | IsKangxiRadicals |
| 2FF0–2FFF | IsIdeographicDescriptionCharacters |
| 3000–303F | IsCJKSymbolsandPunctuation |
| 3040–309F | IsHiragana |
| 30A0–30FF | IsKatakana |
| 3100–312F | IsBopomofo |
| 3130–318F | IsHangulCompatibilityJamo |
| 3190–319F | IsKanbun |
| 31A0–31BF | IsBopomofoExtended |
| 31F0–31FF | IsKatakanaPhoneticExtensions |
| 3200–32FF | IsEnclosedCJKLettersandMonths |
| 3300–33FF | IsCJKCompatibility |
| 3400–4DBF | IsCJKUnifiedIdeographsExtensionA |
| 4DC0–4DFF | IsYijingHexagramSymbols |
| 4E00–9FFF | IsCJKUnifiedIdeographs |
| A000–A48F | IsYiSyllables |
| A490–A4CF | IsYiRadicals |
| AC00–D7AF | IsHangulSyllables |
| D800–DB7F | IsHighSurrogates |
| DB80–DBFF | IsHighPrivateUseSurrogates |
| DC00–DFFF | IsLowSurrogates |
| E000–F8FF | IsPrivateUse lub IsPrivateUseArea |
| F900–FAFF | IsCJKCompatibilityIdeographs |
| FB00–FB4F | IsAlphabeticPresentationForms |
| FB50–FDFF | IsArabicPresentationForms-A |
| FE00–FE0F | IsVariationSelectors |
| FE20–FE2F | IsCombiningHalfMarks |
| FE30–FE4F | IsCJKCompatibilityForms |
| FE50–FE6F | IsSmallFormVariants |
| FE70–FEFF | IsArabicPresentationForms-B |
| FF00–FFEF | IsHalfwidthandFullwidthForms |
| FFF0–FFFF | IsSpecials |
Odejmowanie klas znaków: [base_group — [excluded_group]]
Klasy znaków definiuje zestaw znaków. 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.
Wyrażenie odejmowania klas znaków ma następującą formę:
[ -[ base_group excluded_group ]]
Nawiasy kwadratowe ([]) i łącznik (-) są obowiązkowe. Base_group jest grupą znaków dodatnich lub grupą znaków ujemnych. Składnik excluded_group jest inną grupą znaków dodatnich lub ujemnych albo innym wyrażeniem odejmowania klasy znaków (czyli można zagnieżdżać wyrażenia odejmowania klasy znaków).
Na przykład załóżmy że grupa podstawowa składa się z zakresu znaków od „a” do „z”. Aby zdefiniować zestaw znaków, który składa się z grupy podstawowej z wyjątkiem znaku "m", użyj .[a-z-[m]] Aby zdefiniować zestaw znaków składających się z grupy podstawowej z wyjątkiem zestawu znaków "d", "j" i "p", użyj polecenia [a-z-[djp]]. Aby zdefiniować zestaw znaków składających się z grupy podstawowej z wyjątkiem zakresu znaków od "m" do "p", użyj polecenia [a-z-[m-p]].
Rozważ wyrażenie odejmowania klasy znaków zagnieżdżonych, [a-z-[d-w-[m-o]]]. To wyrażenie jest wykonywane począwszy od najbardziej wewnętrznego zakresu znaków na zewnątrz. 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”. Ten zestaw jest następnie odejmowany od zakresu znaków od "a" do "z", co daje zestaw znaków [abcmnoxyz].
Można odejmować dowolne klasy znaków. Aby zdefiniować zestaw znaków, który składa się ze wszystkich znaków Unicode z \u0000 do \uFFFF z wyjątkiem znaków odstępu (), znaków w kategorii ogólnej interpunkcji (\s\p{P}), znaków w IsGreek nazwanym bloku (\p{IsGreek}) i znaku kontrolki Unicode NEXT LINE (\x85), użyj .[\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. 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. Na przykład pusty zestaw jest wynikiem wyrażenia [\p{IsBasicLatin}-[\x00-\x7F]], które odejmuje wszystkie znaki z IsBasicLatin zakresu znaków z IsBasicLatin kategorii ogólnej. Podobnie oryginalna grupa bazowa jest wynikiem wyrażenia [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”.
W poniższym przykładzie zdefiniowano wyrażenie regularne , ^[0-9-[2468]]+$które pasuje do zera i cyfr nieparzyszonych w ciągu wejściowym. Wyrażenie regularne jest interpretowane tak jak pokazano w poniższej tabeli.
| Element | opis |
|---|---|
| ^ | Dopasowywanie rozpoczyna się początku ciągu wejściowego. |
[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. Innymi słowy, dopasowuje co najmniej jedno wystąpienie zera lub cyfry nieparzystej. |
| $ | Dopasowywanie kończy się na końcu ciągu wejściowego. |
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
