Normal İfadelerdeki Çeşitli Yapılar

Makale
03/05/2024

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

Yapı tarafından tanımlanan normal ifade seçeneklerindeki (?imnsx-imnsx) tüm değişiklikler, kapsayan grubun sonuna kadar etkin kalır.

Not

(?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, büyük/küçük harf duyarsızlığını ve x açık yakalamaları etkinleştirmek ve normal ifadenin ortasındaki normal ifade desenindeki boşluğu yoksaymak için , nve seçeneklerini kullanıri.

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 {0}: {1}", 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 {0}: '{1}'", 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ırması, yapısının etkisini (?ixn) onaylar.

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 ile 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. (Açık yakalama) seçeneği etkinleştirildiğinden `n` bu grup yakalanmıyor.
`\b`	Bir sözcük sınırıyla eşleş.

Satır içi Açıklama

Açıklama) yapısı, (?# 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 yöntemi tarafından döndürülen dizeye Regex.ToString 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. Bu ilk yakalama grubudur.
`\s`	Bir boşluk karakteri ile 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 sözcük sınırıyla eşleş.

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 {0}: {1}", 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ı x kullanmak için seçeneği etkinleştirmeniz (satır içi seçenekler aracılığıyla) veya nesne örneği RegexOptions.IgnorePatternWhitespace oluştururken veya statik Regex bir yöntem çağırırken parametreye Regex değer option sağlamanız gerekir.

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üllerin sıfır veya bir oluşumunu eşleştirin, ardından isteğe bağlı eksi işareti ve ardından bir veya daha fazla ondalık basamak ekleyin.
`(\:\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ınması için desen boşluklarını 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("'{0}':", 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 yapı sağlamak (?x) yerine, açıklamanın yöntemini çağırıp Regex.IsMatch(String, String, RegexOptions) numaralandırma değeri geçirerek de tanınabileceğini RegexOptions.IgnorePatternWhitespace unutmayın.

Ayrıca bkz.

Normal İfade Dili - Hızlı Başvuru

Aracılığıyla paylaş

Normal İfadelerdeki Çeşitli Yapılar

Satır içi Seçenekler

Satır içi Açıklama

Satır Sonu Açıklaması

Ayrıca bkz.

Ek kaynaklar