Normal İfadelerdeki Çeşitli Yapılar

.NET'teki normal ifadeler üç çeşitli dil yapısı içerir. Bunlardan biri, normal ifade deseninin ortasında belirli eşleştirme seçeneklerini etkinleştirmenize veya devre dışı bırakmanıza olanak tanır. Kalan ikisi, normal ifadeye açıklama eklemenize olanak verir.

Satır içi Seçenekler

Söz dizimini kullanarak normal ifadenin bir bölümü için belirli desen eşleştirme seçeneklerini ayarlayabilir veya devre dışı bırakabilirsiniz

(?imnsx-imnsx)

Soru işaretinden sonra etkinleştirmek istediğiniz seçenekleri ve eksi işaretinden sonra devre dışı bırakmak istediğiniz seçenekleri listelersiniz. Aşağıdaki tabloda her bir seçenek açıklanmaktadır. Her seçenek hakkında daha fazla bilgi için bkz . Normal İfade Seçenekleri.

Seçenek	Açıklama
`i`	Büyük/küçük harfe duyarsız eşleştirme.
`m`	Çok satırlı mod.
`n`	Yalnızca açık yakalamalar. (Parantezler, grupları yakalama gibi davranmaz.)
`s`	Tek satırlı mod.
`x`	Boşaltılmamış boşlukları yoksayın ve x modu açıklamalarına izin verin.

(?imnsx-imnsx) yapısı tarafından tanımlanan normal ifade seçeneklerindeki herhangi bir değişiklik, kapsayan grubun sonuna kadar etkili kalır.

Uyarı

(?imnsx-imnsx: Alt ifade) gruplandırma yapısı, bir alt ifade için aynı işlevselliği sağlar. Daha fazla bilgi için bkz . Gruplandırma Yapıları.

Aşağıdaki örnek, i, n ve x seçeneklerini, büyük/küçük harf duyarsızlığını etkinleştirmek, açık yakalamaları kullanmak ve normal ifade modelindeki boşlukları yoksaymak için kullanır.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern;
      string input = "double dare double Double a Drooling dog The Dreaded Deep";

      pattern = @"\b(D\w+)\s(d\w+)\b";
      // Match pattern using default options.
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         if (match.Groups.Count > 1)
            for (int ctr = 1; ctr < match.Groups.Count; ctr++)
               Console.WriteLine($"   Group {ctr}: {match.Groups[ctr].Value}");
      }
      Console.WriteLine();

      // Change regular expression pattern to include options.
      pattern = @"\b(D\w+)(?ixn) \s (d\w+) \b";
      // Match new pattern with options.
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         if (match.Groups.Count > 1)
            for (int ctr = 1; ctr < match.Groups.Count; ctr++)
               Console.WriteLine($"   Group {ctr}: '{match.Groups[ctr].Value}'");
      }
   }
}
// The example displays the following output:
//       Drooling dog
//          Group 1: Drooling
//          Group 2: dog
//
//       Drooling dog
//          Group 1: 'Drooling'
//       Dreaded Deep
//          Group 1: 'Dreaded'

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String
        Dim input As String = "double dare double Double a Drooling dog The Dreaded Deep"

        pattern = "\b(D\w+)\s(d\w+)\b"
        ' Match pattern using default options.
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Value)
            If match.Groups.Count > 1 Then
                For ctr As Integer = 1 To match.Groups.Count - 1
                    Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
                Next
            End If
        Next
        Console.WriteLine()

        ' Change regular expression pattern to include options.
        pattern = "\b(D\w+)(?ixn) \s (d\w+) \b"
        ' Match new pattern with options. 
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Value)
            If match.Groups.Count > 1 Then
                For ctr As Integer = 1 To match.Groups.Count - 1
                    Console.WriteLine("   Group {0}: '{1}'", ctr, match.Groups(ctr).Value)
                Next
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       Drooling dog
'          Group 1: Drooling
'          Group 2: dog
'       
'       Drooling dog
'          Group 1: 'Drooling'
'       Dreaded Deep
'          Group 1: 'Dreaded'

Örnek iki normal ifade tanımlar. birincisi, \b(D\w+)\s(d\w+)\bbüyük harfli "D" ve küçük harfli "d" ile başlayan birbirini izleyen iki sözcükle eşleşir. İkinci normal ifade olan \b(D\w+)(?ixn) \s (d\w+) \b, aşağıdaki tabloda açıklandığı gibi bu düzeni değiştirmek için satır içi seçenekleri kullanır. Sonuçların karşılaştırılması, (?ixn) yapısının etkisini doğrular.

Desen	Açıklama
`\b`	Bir sözcük sınırında başla.
`(D\w+)`	Büyük "D" harfini ve ardından bir veya daha fazla sözcük karakterini eşleştirin. Bu, ilk yakalama grubudur.
`(?ixn)`	Bu noktadan sonra karşılaştırmaları büyük/küçük harfe duyarsız hale getirin, yalnızca açık yakalamalar yapın ve normal ifade desenindeki boşluğu yoksayın.
`\s`	Bir boşluk karakteri eşleştirin.
`(d\w+)`	Büyük veya küçük harfli "d" harfini ve ardından bir veya daha fazla sözcük karakterini eşleştirin. Bu grup, `n` (açık yakalama) seçeneği etkinleştirildiği için yakalanmıyor.
`\b`	Bir kelime sınırını eşleştir.

Satır içi Açıklama

Açıklama(?#normal ifadeye satır içi açıklama eklemenize olanak tanır. Normal ifade altyapısı, desen eşleştirmede açıklamanın herhangi bir bölümünü kullanmaz, ancak açıklama, Regex.ToString yöntemi tarafından döndürülen dizeye dahil edilir. Açıklama ilk kapanış parantezinde sona erer.

Aşağıdaki örnek, önceki bölümdeki örnekteki ilk normal ifade desenini yineler. Karşılaştırmanın büyük/küçük harfe duyarlı olup olmadığını belirtmek için normal ifadeye iki satır içi açıklama ekler. normal ifade deseni, \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\başağıdaki gibi tanımlanır.

Desen	Açıklama
`\b`	Bir sözcük sınırında başla.
`(?# case-sensitive comparison)`	Bir yorum. Desen eşleştirme davranışını etkilemez.
`(D\w+)`	Büyük "D" harfini ve ardından bir veya daha fazla sözcük karakterini eşleştirin. İlk yakalama grubu budur.
`\s`	Bir boşluk karakteri eşleştirin.
`(?ixn)`	Bu noktadan sonra karşılaştırmaları büyük/küçük harfe duyarsız hale getirin, yalnızca açık yakalamalar yapın ve normal ifade desenindeki boşluğu yoksayın.
`(?#case-insensitive comparison)`	Bir yorum. Desen eşleştirme davranışını etkilemez.
`(d\w+)`	Büyük veya küçük harfli "d" harfini ve ardından bir veya daha fazla sözcük karakterini eşleştirin. Bu, ikinci yakalama grubudur.
`\b`	Bir kelime sınırını eşleştir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b";
      Regex rgx = new Regex(pattern);
      string input = "double dare double Double a Drooling dog The Dreaded Deep";

      Console.WriteLine("Pattern: " + pattern.ToString());
      // Match pattern using default options.
      foreach (Match match in rgx.Matches(input))
      {
         Console.WriteLine(match.Value);
         if (match.Groups.Count > 1)
         {
            for (int ctr = 1; ctr <match.Groups.Count; ctr++)
               Console.WriteLine($"   Group {ctr}: {match.Groups[ctr].Value}");
         }
      }
   }
}
// The example displays the following output:
//    Pattern: \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comp
//    arison)d\w+)\b
//    Drooling dog
//       Group 1: Drooling
//    Dreaded Deep
//       Group 1: Dreaded

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b"
        Dim rgx As New Regex(pattern)
        Dim input As String = "double dare double Double a Drooling dog The Dreaded Deep"

        Console.WriteLine("Pattern: " + pattern.ToString())
        ' Match pattern using default options.
        For Each match As Match In rgx.Matches(input)
            Console.WriteLine(match.Value)
            If match.Groups.Count > 1 Then
                For ctr As Integer = 1 To match.Groups.Count - 1
                    Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
                Next
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'    Pattern: \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comp
'    arison)d\w+)\b
'    Drooling dog
'       Group 1: Drooling
'    Dreaded Deep
'       Group 1: Dreaded

Satır Sonu Açıklaması

Sayı işareti (#), normal ifade deseninin sonundaki sıralanmamış # karakteriyle başlayan ve satırın sonuna kadar devam eden x modu açıklamasını işaretler. Bu yapıyı kullanmak için ya x seçeneğini (satır içi seçenekler aracılığıyla) etkinleştirmeli ya da RegexOptions.IgnorePatternWhitespace değerini option parametresine, Regex nesnesi oluşturulurken veya statik bir Regex yöntemi çağırırken sağlamalısınız.

Aşağıdaki örnekte satır sonu açıklama yapısı gösterilmektedir. Dizenin en az bir biçim öğesi içeren bileşik biçim dizesi olup olmadığını belirler. Aşağıdaki tabloda normal ifade desenindeki yapılar açıklanmaktadır:

\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item.

Desen	Açıklama
`\{`	Açılış ayraçlarını eşleştirin.
`\d+`	Bir veya daha fazla ondalık basamağı eşleştirin.
`(,-\d+)`	Virgülün sıfır veya bir kez bulunmasını eşleştirin, ardından isteğe bağlı bir eksi işareti ve sonrasında bir veya daha fazla ondalık basamak ile devam edin.
`(\:\w{1,4}?)*`	İki nokta üst üstenin sıfır veya bir oluşumunu eşleştirin, ardından bir ila dört, ancak mümkün olduğunca az boşluk karakteri ekleyin.
`\}`	Kapanış ayraçlarını eşleştirin.
`(?x)`	Satır sonu açıklamasının tanınabilmesi için boşluk deseni yoksay seçeneğini etkinleştirin.
`# Looks for a composite format item.`	Satır sonu açıklaması.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item.";
      string input = "{0,-3:F}";
      Console.WriteLine($"'{input}':");
      if (Regex.IsMatch(input, pattern))
         Console.WriteLine("   contains a composite format item.");
      else
         Console.WriteLine("   does not contain a composite format item.");
   }
}
// The example displays the following output:
//       '{0,-3:F}':
//          contains a composite format item.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item."
        Dim input As String = "{0,-3:F}"
        Console.WriteLine("'{0}':", input)
        If Regex.IsMatch(input, pattern) Then
            Console.WriteLine("   contains a composite format item.")
        Else
            Console.WriteLine("   does not contain a composite format item.")
        End If
    End Sub
End Module
' The example displays the following output:
'       '{0,-3:F}':
'          contains a composite format item.

Normal ifadede (?x) yapısını sağlamak yerine, açıklama Regex.IsMatch(String, String, RegexOptions) yöntemini çağırıp ona RegexOptions.IgnorePatternWhitespace numaralandırma değerini geçirerek de tanınabilir.

Ayrıca bkz.

Düzenli İfade Dili - Hızlı Referans

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2025-06-17