Normal ifadelerdeki karakter sınıfları

Bir karakter sınıfı, bir eşleşmenin başarılı olması için giriş dizesinde bulunabilecek karakterleri içeren bir karakter kümesi tanımlar. .NET'teki normal ifade dili aşağıdaki karakter sınıflarını destekler:

• Pozitif karakter grupları. Giriş dizesindeki bir karakter, belirli bir karakter kümesindekindeki karakterlerden biriyle eşleşmelidir. Daha fazla bilgi için bkz . Pozitif Karakter Grubu.

• Negatif karakter grupları. Giriş dizesindeki bir karakter, belirli bir karakter kümesindekindeki karakterlerden biriyle eşleşmemelidir. Daha fazla bilgi için bkz . Negatif Karakter Grubu.

• Herhangi bir karakter. Normal . ifadedeki (nokta veya nokta) karakteri, dışında \nherhangi bir karakterle eşleşen bir joker karakterdir. Daha fazla bilgi için bkz . Herhangi Bir Karakter.

• Genel bir Unicode kategorisi veya adlandırılmış blok. Giriş dizesindeki bir karakter, eşleşmenin başarılı olması için belirli bir Unicode kategorisinin üyesi veya bir bitişik Unicode karakterleri aralığında olmalıdır. Daha fazla bilgi için bkz . Unicode Kategorisi veya Unicode Bloğu.

• Negatif bir Unicode kategorisi veya adlandırılmış blok. Giriş dizesindeki bir karakter, eşleşmenin başarılı olması için belirli bir Unicode kategorisinin üyesi veya bir bitişik Unicode karakterleri aralığında olmamalıdır. Daha fazla bilgi için bkz . Negatif Unicode Kategorisi veya Unicode Bloğu.

• Bir sözcük karakteri. Giriş dizesindeki bir karakter, sözcüklerdeki karakterler için uygun olan herhangi bir Unicode kategorisine ait olabilir. Daha fazla bilgi için bkz . Word Karakteri.

• Sözcük olmayan karakter. Giriş dizesindeki bir karakter, sözcük karakteri olmayan herhangi bir Unicode kategorisine ait olabilir. Daha fazla bilgi için bkz . Sözcük Olmayan Karakter.

• Boşluk karakteri. Giriş dizesindeki bir karakter herhangi bir Unicode ayırıcı karakteri ve birçok denetim karakterinden herhangi biri olabilir. Daha fazla bilgi için bkz . Boşluk Karakteri.

• Boşluk olmayan karakter. Giriş dizesindeki bir karakter, boşluk karakteri olmayan herhangi bir karakter olabilir. Daha fazla bilgi için bkz . Boşluk Olmayan Karakter.

• Ondalık basamak. Giriş dizesindeki bir karakter, Unicode ondalık basamak olarak sınıflandırılan herhangi bir karakter olabilir. Daha fazla bilgi için bkz . Ondalık Basamak Karakteri.

• Ondalık olmayan basamak. Giriş dizesindeki bir karakter, bir Unicode basamak karakteri dışındaki herhangi bir karakter olabilir. Daha fazla bilgi için bkz . Ondalık Basamak Karakteri.

.NET, bir karakter sınıfını başka bir karakter sınıfından dışlamanın sonucu olarak bir karakter kümesi tanımlamanızı sağlayan karakter sınıfı çıkarma ifadelerini destekler. Daha fazla bilgi için bkz . Karakter Sınıfı Çıkarma.

Not

Kategoriye göre karakterlerle eşleşen karakter sınıfları(\w gibi .NET Framework 4.6.2 ve sonraki sürümlerinde karakter kategorileri Unicode Standart, Sürüm 8.0.0'ı temel alır.

Pozitif karakter grubu: [ ]

Pozitif karakter grubu, herhangi biri eşleşmenin gerçekleşmesi için giriş dizesinde görünebilen karakterlerin listesini belirtir. Bu karakter listesi tek tek, aralık veya her ikisi olarak belirtilebilir.

Karakterlerin tek tek bulunduğu bir listeyi belirtmek için kullanılan söz dizimi aşağıdaki gibidir:

[*character_group*]

Burada character_group , eşleşmenin başarılı olması için giriş dizesinde gösterilebilen tek tek karakterlerin listesidir. character_group bir veya daha fazla değişmez karakter, kaçış karakteri veya karakter sınıfı birleşiminden oluşabilir.

Bir karakter aralığı belirtmek için kullanılan söz dizimi aşağıdaki gibidir:

[firstCharacter-lastCharacter]

Burada firstCharacter , aralığın başladığı karakterdir ve lastCharacter aralığı sona erdiren karakterdir. Bir karakter aralığı serideki ilk karakter, tire işareti (-) ve ardından serideki son karakterle belirtilen bitişik karakter dizisidir. İki karakter, eğer bitişik Unicode kod noktaları var ise bitişiktir. firstCharacter , alt kod noktasına sahip karakter ve lastCharacter ise daha yüksek kod noktasına sahip karakter olmalıdır.

Not

Pozitif karakter grubu hem karakter kümesi hem de karakter aralığı içerebileceğinden, bir kısa çizgi karakteri (-), grubun ilk veya son karakteri olmadığı sürece her zaman aralık ayırıcısı olarak yorumlanır.

Karakter grubunun sayısal olmayan bir üyesi olarak kısa çizgi eklemek için, bu karakterden kurtulun. Örneğin, karakteri için bir karakter a grubu oluşturmak ve 'den - karakterlerine doğru /söz dizimi şeklindedir [a\--/].

Pozitif karakter sınıflarını içeren bazı sık kullanılan normal ifade desenleri aşağıdaki tabloda listelenmiştir.

Desen	Açıklama
[aeiou]	Tüm sesli harflerle eşleş.
[\p{P}\d]	Tüm noktalama işaretleriyle ve ondalık basamak işaretleriyle eşleş.
[\s\p{P}]	Tüm boşluk ve noktalama işaretlerini eşleştirin.

Aşağıdaki örnek "a" ve "e" karakterlerini içerek bir pozitif karakterler grubu tanımlar ve eşleşmenin gerçekleşmesi için giriş dizesinde "grey" veya "gray" sözcüklerinin ardından bir sözcük daha bulunmasını gerektirir.

static void PositiveCharacterGroup()
{
    string pattern = @"gr[ae]y\s\S+?[\s\p{P}]";
    string input = "The gray wolf jumped over the grey wall.";
    MatchCollection matches = Regex.Matches(input, pattern);
    foreach (Match match in matches)
        Console.WriteLine($"'{match.Value}'");
}
// The example displays the following output:
//       'gray wolf '
//       'grey wall.'

Sub PositiveCharacterGroup()
    Dim pattern As String = "gr[ae]y\s\S+?[\s\p{P}]"
    Dim input As String = "The gray wolf jumped over the grey wall."
    Dim matches As MatchCollection = Regex.Matches(input, pattern)
    For Each match As Match In matches
        Console.WriteLine($"'{match.Value}'")
    Next
End Sub
' The example displays the following output:
'       'gray wolf '
'       'grey wall.'

Normal ifade gr[ae]y\s\S+?[\s|\p{P}] aşağıdaki gibi tanımlanır:

Desen	Açıklama
gr	"gr" sabit karakterleriyle eşleş.
[ae]	Bir "a" veya "e" ile eşleş.
y\s	"y" sabit karakteri ve ardından bir boşluk karakteriyle eşleş.
\S+?	Bir veya daha fazla boşluk olmayan karakterle, ama olabildiğince az sayıda olanla eşleş.
[\s\p{P}]	Bir boşluk karakteri veya noktalama işaretiyle eşleş.

Aşağıdaki örnek büyük harf ile başlayan sözcüklerle eşleşir. A'dan Z'ye büyük harf aralığını göstermek için alt [A-Z] ifadeyi kullanır.

static void CharacterRange()
{
    string pattern = @"\b[A-Z]\w*\b";
    string input = "A city Albany Zulu maritime Marseilles";
    foreach (Match match in Regex.Matches(input, pattern))
        Console.WriteLine(match.Value);
}
// The example displays the following output:
//       A
//       Albany
//       Zulu
//       Marseilles

Sub CharacterRange()
    Dim pattern As String = "\b[A-Z]\w*\b"
    Dim input As String = "A city Albany Zulu maritime Marseilles"
    For Each match As Match In Regex.Matches(input, pattern)
        Console.WriteLine(match.Value)
    Next
End Sub
' The example displays the following output:
'       A
'       Albany
'       Zulu
'       Marseilles

Normal ifade \b[A-Z]\w*\b aşağıdaki tabloda gösterildiği gibi tanımlanır.

Desen	Açıklama
\b	Bir sözcük sınırında başla.
[A-Z]	A'dan Z'ye herhangi bir büyük harf karakterle eşleş.
\w*	Sıfır veya daha fazla sözcük karakteriyle eşleş.
\b	Bir sözcük sınırıyla eşleş.

Negatif karakter grubu: [^]

Bir negatif karakter grubu, eşleşmenin gerçekleşmesi için giriş dizesinde bulunmaması gereken karakterlerin listesini belirtir. Karakter listesi tek tek, aralık veya her ikisi olarak belirtilebilir.

Karakterlerin tek tek bulunduğu bir listeyi belirtmek için kullanılan söz dizimi aşağıdaki gibidir:

[*^character_group*]

Burada character_group , eşleşmenin başarılı olması için giriş dizesinde görünmeyecek tek tek karakterlerin listesidir. character_group bir veya daha fazla değişmez karakter, kaçış karakteri veya karakter sınıfı birleşiminden oluşabilir.

Bir karakter aralığı belirtmek için kullanılan söz dizimi aşağıdaki gibidir:

[^*firstCharacter*-*lastCharacter*]

Burada firstCharacter , aralığın başladığı karakterdir ve lastCharacter aralığı sona erdiren karakterdir. Bir karakter aralığı serideki ilk karakter, tire işareti (-) ve ardından serideki son karakterle belirtilen bitişik karakter dizisidir. İki karakter, eğer bitişik Unicode kod noktaları var ise bitişiktir. firstCharacter , alt kod noktasına sahip karakter ve lastCharacter ise daha yüksek kod noktasına sahip karakter olmalıdır.

Not

Negatif karakter grubu hem karakter kümesi hem de karakter aralığı içerebileceğinden, bir kısa çizgi karakteri (-), grubun ilk veya son karakteri olmadığı sürece her zaman aralık ayırıcısı olarak yorumlanır.

İki veya daha fazla karakter aralığı birleştirilebilir. Örneğin, "0" ile "9" arasında ondalık basamak aralığını, "a" ile "f" arasında küçük harf aralığını ve "A" ile "F" arasında büyük harf aralığını belirtmek için kullanın [0-9a-fA-F].

Negatif karakter grubundaki baştaki şapka işareti karakteri (^) zorunludur ve karakter grubunun pozitif karakter grubu yerine negatif karakter grubu olduğunu gösterir.

Önemli

Daha büyük bir düzenli ifade desenindeki negatif karakter grubu sıfır genişlikli sınama değildir. Yani, normal ifade motoru negatif karakter grubunu değerlendirdikten sonra giriş dizesinde bir karakter ilerler.

Negatif karakter gruplarını içeren bazı sık kullanılan normal ifade desenleri aşağıdaki tabloda listelenmiştir.

Desen	Açıklama
[^aeiou]	Sesli harfler dışındaki tüm karakterlerle eşleş.
[^\p{P}\d]	Noktalama işaretleri ve ondalık basamak karakterleri dışındaki tüm karakterlerle eşleş.

Aşağıdaki örnek, "th" karakterleriyle başlayan ve ardından "o" olmayan herhangi bir sözcükle eşleşir.

static void NegativeCharacterGroup()
{
    string pattern = @"\bth[^o]\w+\b";
    string input = "thought thing though them through thus thorough this";
    foreach (Match match in Regex.Matches(input, pattern))
        Console.WriteLine(match.Value);
}
// The example displays the following output:
//       thing
//       them
//       through
//       thus
//       this

Sub NegativeCharacterGroup()
    Dim pattern As String = "\bth[^o]\w+\b"
    Dim input As String = "thought thing though them through thus thorough this"
    For Each match As Match In Regex.Matches(input, pattern)
        Console.WriteLine(match.Value)
    Next
End Sub
' The example displays the following output:
'       thing
'       them
'       through
'       thus
'       this

Normal ifade \bth[^o]\w+\b aşağıdaki tabloda gösterildiği gibi tanımlanır.

Desen	Açıklama
\b	Bir sözcük sınırında başla.
th	"th" sabit karakterleriyle eşleş.
[^o]	"O" olmayan herhangi bir karakteri eşleştirin.
\w+	Bir veya daha fazla sözcük karakteri eşleştir.
\b	Bir sözcük sınırında bit.

Herhangi bir karakter: .

Nokta karakteri (.), aşağıdaki iki niteliğe sahip (yeni satır karakteri) dışında \n herhangi bir karakterle eşleşir:

• Normal ifade deseni seçeneğiyle RegexOptions.Singleline değiştirilirse veya desenin karakter sınıfını içeren . kısmı seçeneğiyle s değiştirilirse, . herhangi bir karakterle eşleşir. Daha fazla bilgi için bkz . Normal İfade Seçenekleri.

  Aşağıdaki örnek, karakter sınıfının farklı davranışını . varsayılan olarak ve seçeneğiyle RegexOptions.Singleline gösterir. Normal ifade ^.+ dizenin başında başlar ve her karakterle eşleşir. Varsayılan olarak, eşleşme ilk satırın sonunda biter; normal ifade deseni satır başı karakteriyle eşleşir, \r ile eşleşir ancak \n ile eşleşmez. RegexOptions.Singleline seçeneği giriş dizesinin tamamını tek bir satır olarak yorumladığı için, dahil olmak üzere \ngiriş dizesindeki her karakterle eşleşir.

  static void AnyCharacterMultiline()
  {
      string pattern = "^.+";
      string input = "This is one line and" + Environment.NewLine + "this is the second.";
      foreach (Match match in Regex.Matches(input, pattern))
          Console.WriteLine(Regex.Escape(match.Value));
  
      Console.WriteLine();
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Singleline))
          Console.WriteLine(Regex.Escape(match.Value));
  }
  // The example displays the following output:
  //       This\ is\ one\ line\ and\r
  //
  //       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
  

  Sub AnyCharacterMultiline()
      Dim pattern As String = "^.+"
      Dim input As String = "This is one line and" + Environment.NewLine + "this is the second."
      For Each match As Match In Regex.Matches(input, pattern)
          Console.WriteLine(Regex.Escape(match.Value))
      Next
  
      Console.WriteLine()
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.Singleline)
          Console.WriteLine(Regex.Escape(match.Value))
      Next
  End Sub
  ' The example displays the following output:
  '       This\ is\ one\ line\ and\r
  '
  '       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
  

Not

dışında \nherhangi bir karakterle eşleştiğinden . , karakter sınıfı da eşleşir \r (satır başı karakteri).

• Bir pozitif veya negatif karakter grubunda, nokta bir karakter sınıfı yerine sabit karakter olarak kabul edilir. Daha fazla bilgi için bu makalenin önceki bölümlerinde yer alan Pozitif Karakter Grubu ve Negatif Karakter Grubu bölümüne bakın. Aşağıdaki örnek, nokta karakterini (.) hem karakter sınıfı hem de pozitif karakter grubunun üyesi olarak içeren bir normal ifade tanımlayarak bir çizim sağlar. Normal ifade \b.*[.?!;:](\s|\z) bir sözcük sınırında başlar, nokta dahil olmak üzere beş noktalama işaretinden biriyle karşılaşana kadar herhangi bir karakterle eşleşir ve ardından bir boşluk karakteriyle veya dizenin sonuyla eşleşir.

  static void AnyCharacterSingleline()
  {
      string pattern = @"\b.*[.?!;:](\s|\z)";
      string input = "this. what: is? go, thing.";
      foreach (Match match in Regex.Matches(input, pattern))
          Console.WriteLine(match.Value);
  }
  // The example displays the following output:
  //       this. what: is? go, thing.
  

  Sub AnyCharacterSingleline()
      Dim pattern As String = "\b.*[.?!;:](\s|\z)"
      Dim input As String = "this. what: is? go, thing."
      For Each match As Match In Regex.Matches(input, pattern)
          Console.WriteLine(match.Value)
      Next
  End Sub
  ' The example displays the following output:
  '       this. what: is? go, thing.
  

Not

Herhangi bir karakterle eşleştiğinden . , normal ifade deseni herhangi bir karakteri birden çok kez eşleştirmeye çalışırsa dil öğesi genellikle yavaş niceleyici ile kullanılır. Daha fazla bilgi için bkz . Quantifiers.

Unicode kategorisi veya Unicode bloğu: \p{}

Unicode standardı her karakteri genel bir kategoriye atar. Örneğin, belirli bir karakter büyük harf (kategoriyle Lu gösterilir), ondalık basamak ( Nd kategori), matematik simgesi ( Sm kategori) veya paragraf ayırıcısı ( Zl kategori) olabilir. Unicode standardındaki belirli karakter kümeleri ayrıca birbirini izleyen kod noktalarının belirli bir aralığını veya bloğunu kaplar. Örneğin, temel Latin karakter kümesi \u0000 ile \u007F arasındayken, Arapça karakter kümesi \u0600 ile \u06FF arasındadır.

Normal ifade yapısı

\p{ ad}

Unicode genel kategorisine veya adlandırılmış bloğuna ait herhangi bir karakterle eşleşir; burada ad , kategori kısaltması veya adlandırılmış blok adıdır. Kategori kısaltmalarının listesi için bu makalenin devamında Yer alan Desteklenen Unicode Genel Kategorileri bölümüne bakın. Adlandırılmış blokların listesi için bu makalenin devamında yer alan Desteklenen Adlandırılmış Bloklar bölümüne bakın.

İpucu

Öncelikle String.Normalize yöntemini çağırarak dize normalleştirilirse eşleştirme geliştirilebilir.

Aşağıdaki örnek, hem Unicode genel kategorisiyle (bu örnekte, , veya Noktalama, Tire kategorisi) hem de adlandırılmış blokla (ve \p{ adlandırılmış bloklar) eşleştirmek için ad yapısını kullanır}PdIsGreek.IsBasicLatin

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

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

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

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

Normal ifade \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ aşağıdaki tabloda gösterildiği gibi tanımlanır.

Desen	Açıklama
\b	Bir sözcük sınırında başla.
\p{IsGreek}+	Bir veya daha fazla Yunan karakterle eşleş.
(\s)?	Sıfır veya bir beyaz boşluk karakterini eşleştirin.
(\p{IsGreek}+(\s)?)+	Bir veya birden çok Yunanca karakter desenini, ardından sıfır veya bir beyaz alan karakteri bir veya birden çok kez gelecek şekilde eşleştirin.
\p{Pd}	Bir Punctuation, Dash karakteriyle eşleş.
\s	Bir boşluk karakteri ile eşleştirin.
\p{IsBasicLatin}+	Bir veya daha fazla temel Latin karakteriyle eşleş.
(\s)?	Sıfır veya bir beyaz boşluk karakterini eşleştirin.
(\p{IsBasicLatin}+(\s)?)+	Bir veya daha fazla kere, bir veya daha fazla temel Latin karakterinin ardından sıfır veya bir boşluk karakteri deseniyle eşleş.

Negatif Unicode kategorisi veya Unicode bloğu: \P{}

Unicode standardı her karakteri genel bir kategoriye atar. Örneğin, belirli bir karakter büyük harf (kategoriyle Lu gösterilir), ondalık basamak ( Nd kategori), matematik simgesi ( Sm kategori) veya paragraf ayırıcısı ( Zl kategori) olabilir. Unicode standardındaki belirli karakter kümeleri ayrıca birbirini izleyen kod noktalarının belirli bir aralığını veya bloğunu kaplar. Örneğin, temel Latin karakter kümesi \u0000 ile \u007F arasındayken, Arapça karakter kümesi \u0600 ile \u06FF arasındadır.

Normal ifade yapısı

\P{ ad}

Unicode genel kategorisine veya adlandırılmış bloğuna ait olmayan herhangi bir karakterle eşleşir; burada ad , kategori kısaltması veya adlandırılmış blok adıdır. Kategori kısaltmalarının listesi için bu makalenin devamında Yer alan Desteklenen Unicode Genel Kategorileri bölümüne bakın. Adlandırılmış blokların listesi için bu makalenin devamında yer alan Desteklenen Adlandırılmış Bloklar bölümüne bakın.

İpucu

Dize, önce String.Normalize yöntemini çağırarak normalleştirildiğinde, eşleştirme geliştirilebilir.

Aşağıdaki örnek, sayısal dizelerden tüm para birimi simgelerini (bu örnekte , \P{veya Simge, Para Birimi kategorisi) kaldırmak için ad}.

static void NegativeUnicodeCategory()
{
    string pattern = @"(\P{Sc})+";

    string[] values = { "$164,091.78", "£1,073,142.68", "73¢", "€120" };
    foreach (string value in values)
        Console.WriteLine(Regex.Match(value, pattern).Value);
}
// The example displays the following output:
//       164,091.78
//       1,073,142.68
//       73
//       120

Sub NegativeUnicodeCategory()
    Dim pattern As String = "(\P{Sc})+"

    Dim values() As String = {"$164,091.78", "£1,073,142.68", "73¢", "€120"}
    For Each value As String In values
        Console.WriteLine(Regex.Match(value, pattern).Value)
    Next
End Sub
' The example displays the following output:
'       164,091.78
'       1,073,142.68
'       73
'       120

Normal ifade düzeni (\P{Sc})+ , para birimi simgesi olmayan bir veya daha fazla karakterle eşleşir; sonuç dizesinden herhangi bir para birimi simgesini etkili bir şekilde çıkarır.

Word karakteri: \w

\w herhangi bir sözcük karakteriyle eşleşir. Bir sözcük karakteri, aşağıdaki tabloda listelenen Unicode kategorilerinin herhangi birinin üyesidir.

Kategori	Açıklama
Ll	Harf, Küçük Harf
Lu	Harf, Büyük Harf
Lt	Harf, Başlık Düzeni
Lo	Harf, Diğer
Lm	Harf, Değiştirici
Mn	İşaret, Boşluksuz
Nd	Sayı, Ondalık Basamak
Pc	Noktalama, Bağlayıcı. Bu kategori on karakter içerir ve bu karakterlerin en sık kullanılanı alt çizgi karakteridir (_), u+005F.

ECMAScript uyumlu davranış belirtilirse, \w ile [a-zA-Z_0-9]eşdeğerdir. ECMAScript normal ifadeleri hakkında bilgi için Normal İfade Seçenekleri'ndeki "ECMAScript Eşleştirme Davranışı" bölümüne bakın.

Not

Herhangi bir sözcük karakteriyle eşleştiğinden \w , normal ifade deseni herhangi bir sözcük karakterini birden çok kez eşleştirmeye çalışırsa ve ardından belirli bir sözcük karakteri gelirse dil öğesi genellikle yavaş niceleyici ile kullanılır. Daha fazla bilgi için bkz . Quantifiers.

Aşağıdaki örnek, bir sözcükteki \w yinelenen karakterleri eşleştirmek için dil öğesini kullanır. Örnek, (\w)\1aşağıdaki gibi yorumlanabilen bir normal ifade deseni tanımlar.

Öğe	Açıklama
(\w)	Bir sözcük karakteriyle eşleş. Bu ilk yakalama grubudur.
\1	İlk yakalamanın değeriyle eşleş.

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

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

Sözcük olmayan karakter: \W

\W sözcük olmayan herhangi bir karakterle eşleşir. \W dil öğesi aşağıdaki karakter sınıfıyla eşdeğerdir:

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

Başka bir deyişle, aşağıdaki tabloda listelenen Unicode kategorilerindekiler dışında herhangi bir karakterle eşleşir.

Kategori	Açıklama
Ll	Harf, Küçük Harf
Lu	Harf, Büyük Harf
Lt	Harf, Başlık Düzeni
Lo	Harf, Diğer
Lm	Harf, Değiştirici
Mn	İşaret, Boşluksuz
Nd	Sayı, Ondalık Basamak
Pc	Noktalama, Bağlayıcı. Bu kategori on karakter içerir ve bu karakterlerin en sık kullanılanı alt çizgi karakteridir (_), u+005F.

ECMAScript uyumlu davranış belirtilirse, \W ile [^a-zA-Z_0-9]eşdeğerdir. ECMAScript normal ifadeleri hakkında bilgi için Normal İfade Seçenekleri'ndeki "ECMAScript Eşleştirme Davranışı" bölümüne bakın.

Not

Sözcük olmayan herhangi bir karakterle eşleştiğinden \W , normal ifade deseni sözcük olmayan herhangi bir karakteri birden çok kez eşleştirmeye çalışırsa ve ardından belirli bir sözcük olmayan karakterle eşleşmeye çalışırsa dil öğesi genellikle yavaş bir niceleyici ile kullanılır. Daha fazla bilgi için bkz . Quantifiers.

Aşağıdaki örnekte karakter sınıfı gösterilmektedir \W . Bir sözcüğün ardından boşluk veya noktalama işareti gibi bir veya iki sözcük olmayan karakterle eşleşen normal ifade desenini \b(\w+)(\W){1,2}tanımlar. Normal ifade aşağıdaki tabloda gösterildiği gibi yorumlanır.

Öğe	Açıklama
\b	Bir sözcük sınırında eşleşmeye başla.
(\w+)	Bir veya daha fazla sözcük karakteri eşleştir. Bu ilk yakalama grubudur.
(\W){1,2}	Sözcük olmayan bir karakteri bir veya iki kez eşleştir. Bu ikinci yakalama grubudur.

static void NonWordCharacter()
{
    string pattern = @"\b(\w+)(\W){1,2}";
    string input = "The old, grey mare slowly walked across the narrow, green pasture.";
    foreach (Match match in Regex.Matches(input, pattern))
    {
        Console.WriteLine(match.Value);
        Console.Write("   Non-word character(s):");
        CaptureCollection captures = match.Groups[2].Captures;
        for (int ctr = 0; ctr < captures.Count; ctr++)
            Console.Write(@"'{0}' (\u{1}){2}", captures[ctr].Value,
                          Convert.ToUInt16(captures[ctr].Value[0]).ToString("X4"),
                          ctr < captures.Count - 1 ? ", " : "");
        Console.WriteLine();
    }
}
// The example displays the following output:
//       The
//          Non-word character(s):' ' (\u0020)
//       old,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       grey
//          Non-word character(s):' ' (\u0020)
//       mare
//          Non-word character(s):' ' (\u0020)
//       slowly
//          Non-word character(s):' ' (\u0020)
//       walked
//          Non-word character(s):' ' (\u0020)
//       across
//          Non-word character(s):' ' (\u0020)
//       the
//          Non-word character(s):' ' (\u0020)
//       narrow,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       green
//          Non-word character(s):' ' (\u0020)
//       pasture.
//          Non-word character(s):'.' (\u002E)

Sub NonWordCharacter()
    Dim pattern As String = "\b(\w+)(\W){1,2}"
    Dim input As String = "The old, grey mare slowly walked across the narrow, green pasture."
    For Each match As Match In Regex.Matches(input, pattern)
        Console.WriteLine(match.Value)
        Console.Write("   Non-word character(s):")
        Dim captures As CaptureCollection = match.Groups(2).Captures
        For ctr As Integer = 0 To captures.Count - 1
            Console.Write("'{0}' (\u{1}){2}", captures(ctr).Value,
                          Convert.ToUInt16(captures(ctr).Value.Chars(0)).ToString("X4"),
                          If(ctr < captures.Count - 1, ", ", ""))
        Next
        Console.WriteLine()
    Next
End Sub
' The example displays the following output:
'       The
'          Non-word character(s):' ' (\u0020)
'       old,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       grey
'          Non-word character(s):' ' (\u0020)
'       mare
'          Non-word character(s):' ' (\u0020)
'       slowly
'          Non-word character(s):' ' (\u0020)
'       walked
'          Non-word character(s):' ' (\u0020)
'       across
'          Non-word character(s):' ' (\u0020)
'       the
'          Non-word character(s):' ' (\u0020)
'       narrow,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       green
'          Non-word character(s):' ' (\u0020)
'       pasture.
'          Non-word character(s):'.' (\u002E)

Group İkinci yakalama grubunun nesnesi yalnızca tek bir yakalanan sözcük olmayan karakter içerdiğinden, örnek, özelliği tarafından CaptureCollection döndürülen nesneden Group.Captures yakalanan tüm sözcük olmayan karakterleri alır.

Boşluk karakteri: \s

\s herhangi bir boşluk karakteriyle eşleşir. Bu, aşağıdaki tabloda listelenen kaçış dizilerine ve Unicode kategorilerine eşdeğerdir.

Kategori	Açıklama
\f	Sonraki sayfaya geçme karakteri, \u000C.
\n	Yeni satır karakteri, \u000A.
\r	Satır başı karakteri, \u000D.
\t	Sekme karakteri, \u0009.
\v	Dikey sekme karakteri, \u000B.
\x85	SONRAKI SATıR (NEL) karakteri, \u0085.
\p{Z}	Tüm ayırıcı karakterlerle eşleşir. Bu, , Zsve Zl kategorilerini içerirZp.

ECMAScript uyumlu davranış belirtilirse, \s ile [ \f\n\r\t\v]eşdeğerdir. ECMAScript normal ifadeleri hakkında bilgi için Normal İfade Seçenekleri'ndeki "ECMAScript Eşleştirme Davranışı" bölümüne bakın.

Aşağıdaki örnekte karakter sınıfı gösterilmektedir \s . "s" veya "es" ile biten ve ardından boşluk karakteri veya giriş dizesinin sonu ile biten bir sözcükle eşleşen normal ifade desenini \b\w+(e)?s(\s|$)tanımlar. Normal ifade aşağıdaki tabloda gösterildiği gibi yorumlanır.

Öğe	Açıklama
\b	Bir sözcük sınırında eşleşmeye başla.
\w+	Bir veya daha fazla sözcük karakteri eşleştir.
(e)?	Sıfır veya bir kez "e" ile eşleş.
s	Bir "s" ile eşleş.
(\s|$)	Bir boşluk karakterini veya giriş dizesinin sonunu eşleştirin.

static void WhitespaceCharacter()
{
    string pattern = @"\b\w+(e)?s(\s|$)";
    string input = "matches stores stops leave leaves";
    foreach (Match match in Regex.Matches(input, pattern))
        Console.WriteLine(match.Value);
}
// The example displays the following output:
//       matches
//       stores
//       stops
//       leaves

Sub WhitespaceCharacter()
    Dim pattern As String = "\b\w+(e)?s(\s|$)"
    Dim input As String = "matches stores stops leave leaves"
    For Each match As Match In Regex.Matches(input, pattern)
        Console.WriteLine(match.Value)
    Next
End Sub
' The example displays the following output:
'       matches
'       stores
'       stops
'       leaves

Boşluk olmayan karakter: \S

\S boşluk olmayan herhangi bir karakterle eşleşir. Normal ifade desenine [^\f\n\r\t\v\x85\p{Z}] eşdeğerdir veya \s ifadesiyle boşluk karakterlerini eşleştiren normal ifade deseninin zıddıdır. Daha fazla bilgi için bkz . Boşluk Karakteri: \s.

ECMAScript uyumlu davranış belirtilirse, \S ile [^ \f\n\r\t\v]eşdeğerdir. ECMAScript normal ifadeleri hakkında bilgi için Normal İfade Seçenekleri'ndeki "ECMAScript Eşleştirme Davranışı" bölümüne bakın.

Aşağıdaki örnekte dil öğesi gösterilmektedir \S . Normal ifade deseni \b(\S+)\s? , boşluk karakterleriyle sınırlandırılmış dizelerle eşleşir. Eşleşmenin GroupCollection nesnesindeki ikinci öğe eşleşen dizeyi içerir. Normal ifade aşağıdaki tabloda gösterildiği gibi yorumlanabilir.

Öğe	Açıklama
\b	Bir sözcük sınırında eşleşmeye başla.
(\S+)	Bir veya daha fazla boşluk olmayan karakterle eşleş. Bu ilk yakalama grubudur.
\s?	Sıfır veya bir beyaz boşluk karakterini eşleştirin.

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

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

Ondalık basamak karakteri: \d

\d herhangi bir ondalık basamakla eşleşir. Standart ondalık basamak 0-9 ve diğer birçok karakter kümesinin ondalık basamaklarını içeren normal ifade desenine eşdeğerdir \p{Nd} .

ECMAScript uyumlu davranış belirtilirse, \d ile [0-9]eşdeğerdir. ECMAScript normal ifadeleri hakkında bilgi için Normal İfade Seçenekleri'ndeki "ECMAScript Eşleştirme Davranışı" bölümüne bakın.

Aşağıdaki örnekte dil öğesi gösterilmektedir \d . Bir giriş dizesinin Amerika Birleşik Devletleri ve Kanada'da geçerli bir telefon numarası olup olmadığını test eder. Normal ifade deseni ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ aşağıdaki tabloda gösterildiği gibi tanımlanır.

Öğe	Açıklama
^	Giriş dizesinin başında eşleşmeye başla.
\(?	Sıfır veya bir sabit "(" karakteriyle eşleş.
\d{3}	Üç ondalık basamakla eşleş.
\)?	Sıfır veya bir sabit ")" karakteriyle eşleş.
[\s-]	Bir tire veya boşluk karakteriyle eşleş.
(\(?\d{3}\)?[\s-])?	İsteğe bağlı olarak bir açma parantezi, üç ondalık basamak ve bir kapatma parantezi; ardından da sıfır veya bir kere bir boşluk karakteri veya tire ile eşleş. Bu ilk yakalama grubudur.
\d{3}-\d{4}	Üç ondalık basamak, ardından bir tire ve sonra dört tane daha ondalık basamak ile eşleş.
$	Giriş dizesinin sonuyla eşleş.

static void DigitCharacter()
{
    string pattern = @"^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$";
    string[] inputs = { "111 111-1111", "222-2222", "222 333-444",
                        "(212) 111-1111", "111-AB1-1111",
                        "212-111-1111", "01 999-9999" };

    foreach (string input in inputs)
    {
        if (Regex.IsMatch(input, pattern))
            Console.WriteLine(input + ": matched");
        else
            Console.WriteLine(input + ": match failed");
    }
}
// The example displays the following output:
//       111 111-1111: matched
//       222-2222: matched
//       222 333-444: match failed
//       (212) 111-1111: matched
//       111-AB1-1111: match failed
//       212-111-1111: matched
//       01 999-9999: match failed

Sub DigitCharacter()
    Dim pattern As String = "^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$"
    Dim inputs() As String = {"111 111-1111", "222-2222", "222 333-444",
                               "(212) 111-1111", "111-AB1-1111",
                               "212-111-1111", "01 999-9999"}

    For Each input As String In inputs
        If Regex.IsMatch(input, pattern) Then
            Console.WriteLine(input + ": matched")
        Else
            Console.WriteLine(input + ": match failed")
        End If
    Next
End Sub
' The example displays the following output:
'       111 111-1111: matched
'       222-2222: matched
'       222 333-444: match failed
'       (212) 111-1111: matched
'       111-AB1-1111: match failed
'       212-111-1111: matched
'       01 999-9999: match failed

Basamak olmayan karakter: \D

\D basamak olmayan herhangi bir karakterle eşleşir. Normal ifade desenine \P{Nd} eşdeğerdir.

ECMAScript uyumlu davranış belirtilirse, \D ile [^0-9]eşdeğerdir. ECMAScript normal ifadeleri hakkında bilgi için Normal İfade Seçenekleri'ndeki "ECMAScript Eşleştirme Davranışı" bölümüne bakın.

Aşağıdaki örnek, \D dil öğesini gösterir. Parça numarası gibi bir dizenin doğru ondalık ve ondalık olmayan karakter birleşimini içerip içermediğini test eder. Normal ifade deseni ^\D\d{1,5}\D*$ aşağıdaki tabloda gösterildiği gibi tanımlanır.

Öğe	Açıklama
^	Giriş dizesinin başında eşleşmeye başla.
\D	Basamak olmayan bir karakterle eşleş.
\d{1,5}	Bir ile beş tane arasında ondalık basamakla eşleş.
\D*	Sıfır, bir veya daha fazla ondalık olmayan karakter eşleştirin.
$	Giriş dizesinin sonuyla eşleş.

static void NonDigitCharacter()
{
    string pattern = @"^\D\d{1,5}\D*$";
    string[] inputs = { "A1039C", "AA0001", "C18A", "Y938518" };

    foreach (string input in inputs)
    {
        if (Regex.IsMatch(input, pattern))
            Console.WriteLine(input + ": matched");
        else
            Console.WriteLine(input + ": match failed");
    }
}
// The example displays the following output:
//       A1039C: matched
//       AA0001: match failed
//       C18A: matched
//       Y938518: match failed

Sub NonDigitCharacter()
    Dim pattern As String = "^\D\d{1,5}\D*$"
    Dim inputs() As String = {"A1039C", "AA0001", "C18A", "Y938518"}

    For Each input As String In inputs
        If Regex.IsMatch(input, pattern) Then
            Console.WriteLine(input + ": matched")
        Else
            Console.WriteLine(input + ": match failed")
        End If
    Next
End Sub
' The example displays the following output:
'       A1039C: matched
'       AA0001: match failed
'       C18A: matched
'       Y938518: match failed

Desteklenen Unicode genel kategorileri

Unicode aşağıdaki tabloda listelenen genel kategorileri tanımlar. Daha fazla bilgi için Unicode Karakter Veritabanı, Sn. 5.7.1, Tablo 12'deki "UCD Dosya Biçimi" ve "Genel Kategori Değerleri" alt konularına bakın.

Kategori	Açıklama
Lu	Harf, Büyük Harf
Ll	Harf, Küçük Harf
Lt	Harf, Başlık Düzeni
Lm	Harf, Değiştirici
Lo	Harf, Diğer
L	Tüm harf karakterler. Buna , , Lu, Ll, Ltve Lm karakterleri dahildirLo.
Mn	İşaret, Boşluksuz
Mc	İşaret, Boşluklu Birleşik
Me	İşaret, Çevreleyen
M	Tüm birleştirme işaretleri. Bu, , Mnve Mc kategorilerini içerirMe.
Nd	Sayı, Ondalık Basamak
Nl	Sayı, Harf
No	Sayı, Diğer
N	Tüm sayılar. Bu, , Ndve Nl kategorilerini içerirNo.
Pc	Noktalama, Bağlayıcı
Pd	Noktalama, Tire
Ps	Noktalama, Açık
Pe	Noktalama, Kapalı
Pi	Noktalama işareti, İlk tırnak işareti (kullanıma bağlı olarak Ps veya Pe gibi davranabilir)
Pf	Noktalama işareti, Son tırnak işareti (kullanıma bağlı olarak Ps veya Pe gibi davranabilir)
Po	Noktalama, Diğer
P	Tüm noktalama işaretleri. Bu, , Pc, , Pd, Ps, Pe, Pive Pf kategorilerini içerirPo.
Sm	Sembol, Matematik
Sc	Sembol, Para Birimi
Sk	Sembol, Değiştirici
So	Sembol, Diğer
S	Tüm semboller. Bu, , Sm, Scve Sk kategorilerini içerirSo.
Zs	Ayırıcı, Boşluk
Zl	Ayırıcı, Satır
Zp	Ayırıcı, Paragraf
Z	Tüm ayırıcı karakterlerler. Bu, , Zsve Zl kategorilerini içerirZp.
Cc	Diğer, Denetim
Cf	Diğer, Biçim
Cs	Diğer, Yedek Karakter
Co	Diğer, Özel Kullanım
Cn	Diğer, Atanmamış veya EkLenmemiş
C	Diğer tüm karakterler. Buna , , CcCf, , Csve Co kategorileri dahildirCn.

Belirli bir karakterin Unicode kategorisini belirlemek için bu karakteri yöntemine GetUnicodeCategory geçirebilirsiniz. Aşağıdaki örnek, seçilen Latin karakterleri içeren bir dizideki her öğenin kategorisini belirlemek için yöntemini kullanır GetUnicodeCategory .

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

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

Sub GetUnicodeCategory()
    Dim chars() As Char = {"a"c, "X"c, "8"c, ","c, " "c, ChrW(9), "!"c}

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

Desteklenen adlandırılmış bloklar

.NET, aşağıdaki tabloda listelenen adlandırılmış blokları sağlar. Desteklenen adlandırılmış bloklar kümesi Unicode 4.0 ve Perl 5.6'yı temel alır. Adlandırılmış bloklar kullanan normal bir ifade için Unicode kategorisine veya Unicode bloğu: \p{} bölümüne bakın.

Kod noktası aralığı	Blok adı
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 -veya- 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 -veya- 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 veya 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

Karakter sınıfı çıkarma: [base_group - [excluded_group]]

Bir karakter sınıfı bir karakter kümesini tanımlar. Karakter sınıfı çıkarma, bir karakter sınıfındaki karakterlerin başka bir karakter sınıfından dışlanmasının sonucu olan bir karakter kümesi döndürür.

Bir karakter sınıfı çıkarma ifadesi aşağıdaki biçime sahiptir:

[ -[ base_group excluded_group ]]

Köşeli ayraçlar ([]) ve kısa çizgi (-) zorunlu olur. base_group pozitif karakter grubu veya negatif karakter grubudur. excluded_group bileşeni başka bir pozitif veya negatif karakter grubu ya da başka bir karakter sınıfı çıkarma ifadesidir (yani, karakter sınıfı çıkarma ifadelerini iç içe yerleştirebilirsiniz).

Örneğin, "a" - "z" karakter aralığından oluşan bir temel grubunuz olduğunu varsayalım. "m" karakteri dışında temel gruptan oluşan karakter kümesini tanımlamak için kullanın [a-z-[m]]. "d", "j" ve "p" karakter kümesi dışında temel gruptan oluşan karakter kümesini tanımlamak için kullanın [a-z-[djp]]. "m" ile "p" arasında karakter aralığı dışında temel gruptan oluşan karakter kümesini tanımlamak için kullanın [a-z-[m-p]].

İç içe karakter sınıfı çıkarma ifadesi olan [a-z-[d-w-[m-o]]]değerini göz önünde bulundurun. İfade en içteki karakter aralığından dışa doğru değerlendirilir. İlk önce, "m" - "o" karakter aralığı "d" - "w" karakter aralığından çıkarılır ve bunun sonucunda "d" ile "l" ve "p" ile "w" arasındaki karakterlerin kümesi oluşur. Bu küme daha sonra karakter kümesini veren "a" ile "z" arasında karakter [abcmnoxyz]aralığından çıkarılır.

Karakter sınıfı çıkarma işleminden herhangi bir karakter sınıfını kullanabilirsiniz. \u0000 ile \uFFFF arasında boşluk karakterleri (\s ) dışında tüm Unicode karakterlerinden oluşan karakter kümesini, noktalama genel kategorisindeki\p{P} ( ) karakterleri, adlandırılmış bloktaki IsGreek\p{IsGreek}karakterleri ve Unicode NEXT LINE denetim karakterini (\x85) tanımlamak için kullanın[\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].

Yararlı sonuçlar veren bir karakter sınıfı çıkarma ifadesi için karakter sınıflarını seçin. Hiçbir şeyle eşleşmeyen boş bir karakter kümesi veya özgün temel gruba eşdeğer bir ifade veren bir ifadeden kaçının. Örneğin, boş küme, karakter aralığındaki tüm karakterleri [\p{IsBasicLatin}-[\x00-\x7F]] genel kategoriden çıkaran ifadesinin IsBasicLatinIsBasicLatin sonucudur. Benzer şekilde, özgün temel grup ifadesinin [a-z-[0-9]]sonucudur. Bunun nedeni, "a" ile "z" arasında karakter aralığı olan temel grubun dışlanan grupta karakter içermemesidir. Bu, "0" ile "9" arasında ondalık basamakların karakter aralığıdır.

Aşağıdaki örnek, ^[0-9-[2468]]+$bir giriş dizesindeki sıfır ve tek basamakla eşleşen normal ifadeyi tanımlar. Normal ifade aşağıdaki tabloda gösterildiği gibi yorumlanır.

Öğe	Açıklama
^	Giriş dizesinin başında eşleşmeyi başlat.
[0-9-[2468]]+	0 ile 9 arasında; 2, 4, 6 ve 8 dışındaki herhangi bir karakter bir veya daha fazla bulunduğunda eşleş. Başka bir deyişle, sıfır veya bir tek basamakla eşleş.
$	Giriş dizesinin sonunda eşleşmeyi bitir.

static void CharacterClassSubtraction()
{
    string[] inputs = { "123", "13579753", "3557798", "335599901" };
    string pattern = @"^[0-9-[2468]]+$";

    foreach (string input in inputs)
    {
        Match match = Regex.Match(input, pattern);
        if (match.Success)
            Console.WriteLine(match.Value);
    }
}
// The example displays the following output:
//       13579753
//       335599901

Sub CharacterClassSubtraction()
    Dim inputs() As String = {"123", "13579753", "3557798", "335599901"}
    Dim pattern As String = "^[0-9-[2468]]+$"

    For Each input As String In inputs
        Dim match As Match = Regex.Match(input, pattern)
        If match.Success Then Console.WriteLine(match.Value)
    Next
End Sub
' The example displays the following output:
'       13579753
'       335599901

Ayrıca bkz.

• GetUnicodeCategory
• Normal İfade Dili - Hızlı Başvuru
• Normal İfade Seçenekleri