Normal ifadelerdeki yapıları gruplandırma

Gruplandırma yapıları normal ifadenin alt ifadelerini belirler ve giriş dizesinin alt dizelerini yakalar. Aşağıdakileri yapmak için gruplandırma yapılarını kullanabilirsiniz:

• Giriş dizesinde tekrarlanan bir alt ifadeyi eşleştirin.
• Birden çok normal ifade dili öğesi içeren bir alt ifadeye niceleyici uygulayın. Niceleyiciler hakkında daha fazla bilgi için bkz . Niceleyiciler.
• ve Match.Result yöntemleri tarafından Regex.Replace döndürülen dizeye bir alt ifade ekleyin.
• özelliğinden Match.Groups tek tek alt ifadeleri alın ve bunları eşleşen metinden bir bütün olarak ayrı olarak işleyin.

Aşağıdaki tabloda, .NET normal ifade altyapısı tarafından desteklenen gruplandırma yapıları listelenmektedir ve bunların yakalanıp yakalanmadığını gösterir.

Gruplar ve normal ifade nesnesi modeli hakkında bilgi için bkz . Yapıları ve normal ifade nesnelerini gruplandırma.

Eşleşen alt ifadeler

Aşağıdaki gruplandırma yapısı eşleşen bir alt ifadeyi yakalar:

(Aradığına )

Burada, alt ifade herhangi bir geçerli normal ifade desenidir. Parantez kullanan yakalamalar, 1'den başlayarak normal ifadedeki açma parantezlerinin sırasına göre soldan sağa otomatik olarak numaralandırılır. Ancak adlandırılmış yakalama grupları, adlandırılmış olmayan yakalama gruplarında her zaman en son sıralanır. 0 numaralı yakalama, normal ifade deseninin tamamıyla eşleşen metindir.

Yakalanan gruplara dört yolla erişebilirsiniz:

• Normal ifade içinde geri başvuru yapısını kullanarak. Eşleşen alt ifade, aynı normal ifadede söz dizimi \numarası kullanılarak başvurulur; burada sayı , yakalanan alt ifadenin sıralı sayısıdır.

• Normal ifade içinde adlandırılmış geri başvuru yapısını kullanarak. Eşleşen alt ifadeye aynı normal ifadede söz dizimi \k<adı> kullanılarak başvurulur; burada ad bir yakalama grubunun adıdır veya \k<sayıdır>; burada sayı, yakalama grubunun sıralı numarasıdır. Yakalama grubu, sıra numarasıyla aynı olan varsayılan bir ada sahiptir. Daha fazla bilgi için bu konunun devamında yer alan Adlandırılmış eşleşen alt ifadeler bölümüne bakın.

• Bir veya Match.Result yöntemi çağrısında Regex.Replace numara değiştirme sırasını kullanarak$, burada numara yakalanan alt ifadenin sıra numarasıdır.

• Program aracılığıyla, özelliği tarafından Match.Groups döndürülen nesnesini kullanarakGroupCollection. Koleksiyondaki sıfır konumundaki üye, normal ifade eşleşmesinin tamamını temsil eder. Sonraki her üye eşleştirilmiş bir alt ifadeyi temsil eder. Daha fazla bilgi için Gruplandırma Yapıları ve Normal İfade Nesneleri bölümüne bakın.

Aşağıdaki örnekte, metindeki yinelenen sözcükleri tanımlayan normal bir ifade gösterilmektedir. Normal ifade deseninin iki yakalama grubu, yinelenen sözcüğün iki örneğini temsil eder. İkinci örnek, giriş dizesindeki başlangıç konumunu raporlamak için yakalanır.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\w+)\s(\1)\W";
      string input = "He said that that was the the correct answer.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("Duplicate '{0}' found at positions {1} and {2}.",
                           match.Groups[1].Value, match.Groups[1].Index, match.Groups[2].Index);
   }
}
// The example displays the following output:
//       Duplicate 'that' found at positions 8 and 13.
//       Duplicate 'the' found at positions 22 and 26.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "(\w+)\s(\1)\W"
        Dim input As String = "He said that that was the the correct answer."
        For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
            Console.WriteLine("Duplicate '{0}' found at positions {1} and {2}.", _
                              match.Groups(1).Value, match.Groups(1).Index, match.Groups(2).Index)
        Next
    End Sub
End Module
' The example displays the following output:
'       Duplicate 'that' found at positions 8 and 13.
'       Duplicate 'the' found at positions 22 and 26.

Normal ifade düzeni aşağıdaki gibidir:

(\w+)\s(\1)\W

Aşağıdaki tabloda normal ifade deseninin nasıl yorumlandığı gösterilmektedir.

Adlandırılmış eşleşen alt ifadeler

Aşağıdaki gruplandırma yapısı eşleşen bir alt ifadeyi yakalar ve ada veya numaraya göre erişmenizi sağlar:

(?<name>subexpression)

veya:

(?'name'subexpression)

Burada ad geçerli bir grup adıdır ve alt ifade geçerli bir normal ifade desenidir. ad herhangi bir noktalama karakteri içermemelidir ve bir sayı ile başlayamaz.

Adlandırılmış yakalanan gruplara aşağıdaki yollarla erişebilirsiniz:

• Normal ifade içinde adlandırılmış geri başvuru yapısını kullanarak. Eşleşen alt ifadeye aynı normal ifadede söz dizimi \k<adı> kullanılarak başvurulur; burada ad , yakalanan alt ifadenin adıdır.

• Normal ifade içinde geri başvuru yapısını kullanarak. Eşleşen alt ifade, aynı normal ifadede söz dizimi \numarası kullanılarak başvurulur; burada sayı , yakalanan alt ifadenin sıralı sayısıdır. Adlandırılmış eşleşen alt ifadeler, eşleşen alt ifadelerden sonra soldan sağa art arda numaralandırılır.

• Bir veya Match.Result yöntemi çağrısında Regex.Replace ad} değiştirme sırasını kullanarak${, burada ad yakalanan alt ifadenin adıdır.

• Bir veya Match.Result yöntemi çağrısında Regex.Replace numara değiştirme sırasını kullanarak$, burada numara yakalanan alt ifadenin sıra numarasıdır.

• Program aracılığıyla, özelliği tarafından Match.Groups döndürülen nesnesini kullanarakGroupCollection. Koleksiyondaki sıfır konumundaki üye, normal ifade eşleşmesinin tamamını temsil eder. Sonraki her üye eşleştirilmiş bir alt ifadeyi temsil eder. Adlandırılmış yakalanan gruplar, numaralandırılmış yakalanan grupların ardından koleksiyonda depolanır.

• Program aracılığıyla, nesnenin dizin oluşturucusunun GroupCollection (C# dilinde) veya özelliğine Item[] (Visual Basic'te) alt ifade adı sağlayarak.

Basit bir normal ifade deseni, numaralandırılmış (adsız) ve adlandırılmış gruplara program aracılığıyla veya normal ifade dili söz dizimi kullanılarak nasıl başvurulabileceğini gösterir. Normal ifade ((?<One>abc)\d+)?(?<Two>xyz)(.*) , sayıya ve ada göre aşağıdaki yakalama gruplarını oluşturur. İlk yakalama grubu (0 sayısı) her zaman desenin tamamına başvurur. (Adlandırılmış gruplar her zaman en son sıralanır.)

Aşağıdaki örnek, yinelenen sözcükleri ve yinelenen her sözcüğü hemen izleyen sözcüğü tanımlayan normal bir ifadeyi gösterir. Normal ifade deseni iki adlandırılmış alt ifade tanımlar: duplicateWordyinelenen sözcüğü temsil eden ve nextWordyinelenen sözcüğü izleyen sözcüğü temsil eden .

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)";
      string input = "He said that that was the the correct answer.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("A duplicate '{0}' at position {1} is followed by '{2}'.",
                           match.Groups["duplicateWord"].Value, match.Groups["duplicateWord"].Index,
                           match.Groups["nextWord"].Value);
   }
}
// The example displays the following output:
//       A duplicate 'that' at position 8 is followed by 'was'.
//       A duplicate 'the' at position 22 is followed by 'correct'.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)"
        Dim input As String = "He said that that was the the correct answer."
        Console.WriteLine(Regex.Matches(input, pattern, RegexOptions.IgnoreCase).Count)
        For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
            Console.WriteLine("A duplicate '{0}' at position {1} is followed by '{2}'.", _
                              match.Groups("duplicateWord").Value, match.Groups("duplicateWord").Index, _
                              match.Groups("nextWord").Value)
        Next
    End Sub
End Module
' The example displays the following output:
'    A duplicate 'that' at position 8 is followed by 'was'.
'    A duplicate 'the' at position 22 is followed by 'correct'.

Normal ifade düzeni aşağıdaki gibidir:

(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)

Aşağıdaki tabloda normal ifadenin nasıl yorumlandığı gösterilmektedir.

Grup adı normal ifadede yinelenebilir. Örneğin, aşağıdaki örnekte gösterildiği gibi birden fazla grubun olarak adlandırılması digitmümkündür. Yinelenen adlar söz konusu olduğunda, nesnenin Group değeri giriş dizesindeki son başarılı yakalama tarafından belirlenir. Ayrıca, CaptureCollection grup adı yinelenmediyse olduğu gibi her yakalamayla ilgili bilgilerle doldurulur.

Aşağıdaki örnekte, normal ifade \D+(?<digit>\d+)\D+(?<digit>\d+)? adlı digitbir grubun iki örneğini içerir. İlk digit adlandırılmış grup bir veya daha fazla basamak karakteri yakalar. İkinci digit adlandırılmış grup, bir veya daha fazla basamak karakterinin sıfır veya bir oluşumunu yakalar. Örnekteki çıktıda gösterildiği gibi, ikinci yakalama grubu metinle başarıyla eşleşiyorsa, bu metnin değeri nesnenin Group değerini tanımlar. İkinci yakalama grubu giriş dizesiyle eşleşmiyorsa, son başarılı eşleşmenin değeri nesnenin Group değerini tanımlar.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      String pattern = @"\D+(?<digit>\d+)\D+(?<digit>\d+)?";
      String[] inputs = { "abc123def456", "abc123def" };
      foreach (var input in inputs) {
         Match m = Regex.Match(input, pattern);
         if (m.Success) {
            Console.WriteLine("Match: {0}", m.Value);
            for (int grpCtr = 1; grpCtr < m.Groups.Count; grpCtr++) {
               Group grp = m.Groups[grpCtr];
               Console.WriteLine("Group {0}: {1}", grpCtr, grp.Value);
               for (int capCtr = 0; capCtr < grp.Captures.Count; capCtr++)
                  Console.WriteLine("   Capture {0}: {1}", capCtr,
                                    grp.Captures[capCtr].Value);
            }
         }
         else {
            Console.WriteLine("The match failed.");
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       Match: abc123def456
//       Group 1: 456
//          Capture 0: 123
//          Capture 1: 456
//
//       Match: abc123def
//       Group 1: 123
//          Capture 0: 123

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\D+(?<digit>\d+)\D+(?<digit>\d+)?"
        Dim inputs() As String = {"abc123def456", "abc123def"}
        For Each input As String In inputs
            Dim m As Match = Regex.Match(input, pattern)
            If m.Success Then
                Console.WriteLine("Match: {0}", m.Value)
                For grpCtr As Integer = 1 to m.Groups.Count - 1
                    Dim grp As Group = m.Groups(grpCtr)
                    Console.WriteLine("Group {0}: {1}", grpCtr, grp.Value)
                    For capCtr As Integer = 0 To grp.Captures.Count - 1
                        Console.WriteLine("   Capture {0}: {1}", capCtr,
                                          grp.Captures(capCtr).Value)
                    Next
                Next
            Else
                Console.WriteLine("The match failed.")
            End If
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output:
'       Match: abc123def456
'       Group 1: 456
'          Capture 0: 123
'          Capture 1: 456
'
'       Match: abc123def
'       Group 1: 123
'          Capture 0: 123

Aşağıdaki tabloda normal ifadenin nasıl yorumlandığı gösterilmektedir.

Grup tanımlarını dengeleme

Dengeleme grubu tanımı, önceden tanımlanmış bir grubun tanımını siler ve geçerli grupta, önceden tanımlanmış grupla geçerli grup arasındaki aralığı depolar. Bu gruplandırma yapısı aşağıdaki biçime sahiptir:

(?<name1-name2>subexpression)

veya:

(?'name1-name2' subexpression)

Burada ad1 geçerli grup (isteğe bağlı), name2 önceden tanımlanmış bir grup ve alt ifade geçerli bir normal ifade desenidir. Dengeleme grubu tanımı name2 tanımını siler ve ad2 ile ad1 arasındaki aralığı ad1'de depolar. Ad2 grubu tanımlanmamışsa, geri izlemeleri eşleştirir. Name2'nin son tanımının silinmesi name2'nin önceki tanımını ortaya çıkardığından, bu yapı parantezler veya açma ve kapatma köşeli ayraçları gibi iç içe geçmiş yapıları izlemek için grup adı2 için yakalama yığınını bir sayaç olarak kullanmanıza olanak tanır.

Dengeleme grubu tanımı, yığın olarak name2 kullanır. İç içe yerleştirilmiş her bir yapıya ait başlangıç karakteri, gruba ve koleksiyonuna Group.Captures yerleştirilir. Kapanış karakteri eşleştirildiğinde, ilgili açılış karakteri gruptan kaldırılır ve Captures koleksiyon bir azaltılır. tüm iç içe yapıların açma ve kapatma karakterleri eşleştirildikten sonra, ad2 boş olur.

Aşağıdaki örnek, bir giriş dizesindeki sol ve sağ açılı ayraçları (<>) eşleştirmek için bir dengeleme grubu tanımı kullanır. Örnek, Open Closeeşleşen açılı ayraç çiftlerini izlemek için yığın gibi kullanılan ve adlı iki grubu tanımlar. Yakalanan her sol açılı ayraç grubun yakalama koleksiyonuna Open , yakalanan her sağ açılı ayraç da grubun yakalama koleksiyonuna Close itilir. Dengeleme grubu tanımı, her sol açılı ayraç için eşleşen bir sağ açılı ayraç olmasını sağlar. Yoksa, son alt desen, (?(Open)(?!))yalnızca grup boş değilse Open (ve bu nedenle, iç içe yerleştirilmiş tüm yapılar kapatılmadıysa) değerlendirilir. Son alt desen değerlendirilirse, alt desen her zaman başarısız olan sıfır genişlikli negatif bir lookahead onayı olduğundan (?!) eşleşme başarısız olur.

using System;
using System.Text.RegularExpressions;

class Example
{
   public static void Main()
   {
      string pattern = "^[^<>]*" +
                       "(" +
                       "((?'Open'<)[^<>]*)+" +
                       "((?'Close-Open'>)[^<>]*)+" +
                       ")*" +
                       "(?(Open)(?!))$";
      string input = "<abc><mno<xyz>>";

      Match m = Regex.Match(input, pattern);
      if (m.Success == true)
      {
         Console.WriteLine("Input: \"{0}\" \nMatch: \"{1}\"", input, m);
         int grpCtr = 0;
         foreach (Group grp in m.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", grpCtr, grp.Value);
            grpCtr++;
            int capCtr = 0;
            foreach (Capture cap in grp.Captures)
            {
                Console.WriteLine("      Capture {0}: {1}", capCtr, cap.Value);
                capCtr++;
            }
          }
      }
      else
      {
         Console.WriteLine("Match failed.");
      }
    }
}
// The example displays the following output:
//    Input: "<abc><mno<xyz>>"
//    Match: "<abc><mno<xyz>>"
//       Group 0: <abc><mno<xyz>>
//          Capture 0: <abc><mno<xyz>>
//       Group 1: <mno<xyz>>
//          Capture 0: <abc>
//          Capture 1: <mno<xyz>>
//       Group 2: <xyz
//          Capture 0: <abc
//          Capture 1: <mno
//          Capture 2: <xyz
//       Group 3: >
//          Capture 0: >
//          Capture 1: >
//          Capture 2: >
//       Group 4:
//       Group 5: mno<xyz>
//          Capture 0: abc
//          Capture 1: xyz
//          Capture 2: mno<xyz>

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "^[^<>]*" & _
                                "(" + "((?'Open'<)[^<>]*)+" & _
                                "((?'Close-Open'>)[^<>]*)+" + ")*" & _
                                "(?(Open)(?!))$"
        Dim input As String = "<abc><mno<xyz>>"
        Dim rgx AS New Regex(pattern) '
        Dim m As Match = Regex.Match(input, pattern)
        If m.Success Then
            Console.WriteLine("Input: ""{0}"" " & vbCrLf & "Match: ""{1}""", _
                               input, m)
            Dim grpCtr As Integer = 0
            For Each grp As Group In m.Groups
                Console.WriteLine("   Group {0}: {1}", grpCtr, grp.Value)
                grpCtr += 1
                Dim capCtr As Integer = 0
                For Each cap As Capture In grp.Captures
                    Console.WriteLine("      Capture {0}: {1}", capCtr, cap.Value)
                    capCtr += 1
                Next
            Next
        Else
            Console.WriteLine("Match failed.")
        End If
    End Sub
End Module
' The example displays the following output:
'       Input: "<abc><mno<xyz>>"
'       Match: "<abc><mno<xyz>>"
'          Group 0: <abc><mno<xyz>>
'             Capture 0: <abc><mno<xyz>>
'          Group 1: <mno<xyz>>
'             Capture 0: <abc>
'             Capture 1: <mno<xyz>>
'          Group 2: <xyz
'             Capture 0: <abc
'             Capture 1: <mno
'             Capture 2: <xyz
'          Group 3: >
'             Capture 0: >
'             Capture 1: >
'             Capture 2: >
'          Group 4:
'          Group 5: mno<xyz>
'             Capture 0: abc
'             Capture 1: xyz
'             Capture 2: mno<xyz>

Normal ifade düzeni şöyledir:

^[^<>]*(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)*(?(Open)(?!))$

Normal ifade aşağıdaki gibi yorumlanır:

Son alt ifade olan (?(Open)(?!)), giriş dizesindeki iç içe yerleştirme yapılarının düzgün dengelenip dengelenmediğini gösterir (örneğin, her sol açılı ayraç bir dik açılı ayraçla eşleştirilip eşleştirilmemiştir). Geçerli bir yakalanan grubu temel alan koşullu eşleştirme kullanır; daha fazla bilgi için bkz . Alternation Constructs. Open Grup tanımlanmışsa, normal ifade altyapısı giriş dizesindeki alt ifadeyle (?!) eşleşmeyi dener. Grup Open yalnızca iç içe yapıların dengesiz olması durumunda tanımlanmalıdır. Bu nedenle, giriş dizesinde eşleştirilecek desen her zaman eşleşmenin başarısız olmasına neden olan desen olmalıdır. Bu durumda, (?!) boş bir dize giriş dizesinde bir sonraki konumda her zaman örtük olarak bulunduğundan, her zaman başarısız olan sıfır genişlikli negatif bir lookahead onaylama işlemidir.

Örnekte, normal ifade altyapısı aşağıdaki tabloda gösterildiği gibi "<abc><mno<xyz>>" giriş dizesini değerlendirir.

Kapsüllenmeyen gruplar

Aşağıdaki gruplandırma yapısı, bir alt ifadeyle eşleşen alt dizeyi yakalamaz:

(?:subexpression)

Burada, alt ifade herhangi bir geçerli normal ifade desenidir. Kapsüllenmeyen grup yapısı genellikle bir grup için bir niceleyici uygulandığında kullanılır, ancak grup tarafından yakalanan alt dizeler ilgi çekici değildir.

Aşağıdaki örnekte, kapsülleme olmayan grupları içeren normal bir ifade gösterilmektedir. Çıktının yakalanan grupları içermediğini unutmayın.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(?:\b(?:\w+)\W*)+\.";
      string input = "This is a short sentence.";
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: {0}", match.Value);
      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:
//       Match: This is a short sentence.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "(?:\b(?:\w+)\W*)+\."
        Dim input As String = "This is a short sentence."
        Dim match As Match = Regex.Match(input, pattern)
        Console.WriteLine("Match: {0}", match.Value)
        For ctr As Integer = 1 To match.Groups.Count - 1
            Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
        Next
    End Sub
End Module
' The example displays the following output:
'       Match: This is a short sentence.

Normal ifade (?:\b(?:\w+)\W*)+\. , bir nokta tarafından sonlandırılan bir cümleyle eşleşir. Normal ifade tek tek sözcüklere değil tümcelere odaklandığından, gruplandırma yapıları yalnızca niceleyici olarak kullanılır. Normal ifade deseni aşağıdaki tabloda gösterildiği gibi yorumlanır.

Grup seçenekleri

Aşağıdaki gruplandırma yapısı, bir alt ifade içinde belirtilen seçenekleri uygular veya devre dışı bırakır:

(?imnsx-imnsx:Aradığına )

Burada, alt ifade herhangi bir geçerli normal ifade desenidir. Örneğin, (?i-s:) büyük/küçük harf duyarsızlığını açar ve tek satırlı modu devre dışı bırakır. Belirtebileceğiniz satır içi seçenekler hakkında daha fazla bilgi için bkz . Normal İfade Seçenekleri.

Grup seçenekleri yapısı bir yakalama grubu değildir. Yani, alt ifade tarafından yakalanan bir dizenin herhangi bir bölümü eşleşmeye dahil olsa da, yakalanan bir gruba dahil edilmez veya nesneyi doldurmak GroupCollection için kullanılmaz.

Örneğin, aşağıdaki örnekteki normal ifade \b(?ix: d \w+)\s , büyük/küçük harfe duyarsız eşleştirmeyi etkinleştirmek ve "d" harfiyle başlayan tüm sözcükleri tanımlamak için desen boşluklarını yoksaymak için bir gruplandırma yapısındaki satır içi seçenekleri kullanır. Normal ifade aşağıdaki tabloda gösterildiği gibi tanımlanır.

string pattern = @"\b(?ix: d \w+)\s";
string input = "Dogs are decidedly good pets.";

foreach (Match match in Regex.Matches(input, pattern))
    Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
// The example displays the following output:
//    'Dogs // found at index 0.
//    'decidedly // found at index 9.

Dim pattern As String = "\b(?ix: d \w+)\s"
Dim input As String = "Dogs are decidedly good pets."

For Each match As Match In Regex.Matches(input, pattern)
    Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'    'Dogs ' found at index 0.
'    'decidedly ' found at index 9.      

Sıfır genişlikli pozitif lookahead onayları

Aşağıdaki gruplandırma yapısı sıfır genişlikli pozitif bir lookahead onayını tanımlar:

(?=Aradığına )

Burada alt ifade herhangi bir normal ifade desenidir. Eşleşmenin başarılı olması için, eşleşen alt dize eşleşme sonucuna dahil edilmese de, giriş dizesinin alt ifadedeki normal ifade deseni ile eşleşmesi gerekir. Sıfır genişlikli pozitif bir lookahead onaylama işlemi geri dönmez.

Normal olarak, normal ifade deseninin sonunda sıfır genişlikli pozitif bir lookahead onayı bulunur. Eşleşmenin gerçekleşmesi için dizenin sonunda bulunması gereken ancak eşleşmeye dahil edilmemesi gereken bir alt dize tanımlar. Aşırı geri izlemeyi önlemek için de yararlıdır. Belirli bir yakalanan grubun, yakalanan grup için tanımlanan desenin bir alt kümesiyle eşleşen metinle başladığından emin olmak için sıfır genişlikli pozitif lookahead onayını kullanabilirsiniz. Örneğin, bir yakalama grubu ardışık sözcük karakterleriyle eşleşiyorsa, ilk karakterin alfabetik büyük harfli bir karakter olmasını gerektirmek için sıfır genişlikli pozitif bir lookahead onayı kullanabilirsiniz.

Aşağıdaki örnek, giriş dizesindeki "is" fiilinden önceki sözcükle eşleştirmek için sıfır genişlikli pozitif bir lookahead onayı kullanır.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+(?=\sis\b)";
      string[] inputs = { "The dog is a Malamute.",
                          "The island has beautiful birds.",
                          "The pitch missed home plate.",
                          "Sunday is a weekend day." };

      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern);
         if (match.Success)
            Console.WriteLine("'{0}' precedes 'is'.", match.Value);
         else
            Console.WriteLine("'{0}' does not match the pattern.", input);
      }
   }
}
// The example displays the following output:
//    'dog' precedes 'is'.
//    'The island has beautiful birds.' does not match the pattern.
//    'The pitch missed home plate.' does not match the pattern.
//    'Sunday' precedes 'is'.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b\w+(?=\sis\b)"
        Dim inputs() As String = {"The dog is a Malamute.", _
                                   "The island has beautiful birds.", _
                                   "The pitch missed home plate.", _
                                   "Sunday is a weekend day."}

        For Each input As String In inputs
            Dim match As Match = Regex.Match(input, pattern)
            If match.Success Then
                Console.WriteLine("'{0}' precedes 'is'.", match.Value)
            Else
                Console.WriteLine("'{0}' does not match the pattern.", input)
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       'dog' precedes 'is'.
'       'The island has beautiful birds.' does not match the pattern.
'       'The pitch missed home plate.' does not match the pattern.
'       'Sunday' precedes 'is'.

Normal ifade \b\w+(?=\sis\b) aşağıdaki tabloda gösterildiği gibi yorumlanır.

Sıfır genişlikli negatif lookahead onayları

Aşağıdaki gruplandırma yapısı sıfır genişlikli negatif lookahead onayını tanımlar:

(?!Aradığına )

Burada alt ifade herhangi bir normal ifade desenidir. Eşleşmenin başarılı olması için, eşleşen dize eşleşme sonucuna dahil edilmese de giriş dizesinin alt ifadedeki normal ifade deseni ile eşleşmemesi gerekir.

Sıfır genişlikli negatif lookahead onaylama işlemi genellikle normal ifadenin başında veya sonunda kullanılır. Normal ifadenin başında, normal ifadenin başlangıcı eşleştirilecek benzer ama daha genel bir desen tanımladığında eşleşmemesi gereken belirli bir desen tanımlayabilir. Bu durumda, genellikle geri izlemeyi sınırlamak için kullanılır. Normal ifadenin sonunda, bir eşleşmenin sonunda gerçekleşemeyen bir alt ifade tanımlayabilir.

Aşağıdaki örnek, "un" ile başlamayan sözcüklerle eşleştirmek için normal ifadenin başında sıfır genişlikli bir lookahead onayını kullanan bir normal ifade tanımlar.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(?!un)\w+\b";
      string input = "unite one unethical ethics use untie ultimate";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       one
//       ethics
//       use
//       ultimate

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(?!un)\w+\b"
        Dim input As String = "unite one unethical ethics use untie ultimate"
        For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
            Console.WriteLine(match.Value)
        Next
    End Sub
End Module
' The example displays the following output:
'       one
'       ethics
'       use
'       ultimate

Normal ifade \b(?!un)\w+\b aşağıdaki tabloda gösterildiği gibi yorumlanır.

Aşağıdaki örnek, noktalama karakteriyle bitmeyen sözcüklerle eşleştirmek için normal ifadenin sonunda sıfır genişlikli bir lookahead onayını kullanan bir normal ifade tanımlar.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+\b(?!\p{P})";
      string input = "Disconnected, disjointed thoughts in a sentence fragment.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       disjointed
//       thoughts
//       in
//       a
//       sentence

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b\w+\b(?!\p{P})"
        Dim input As String = "Disconnected, disjointed thoughts in a sentence fragment."
        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:
'       disjointed
'       thoughts
'       in
'       a
'       sentence

Normal ifade \b\w+\b(?!\p{P}) aşağıdaki tabloda gösterildiği gibi yorumlanır.

Sıfır genişlikli pozitif lookbehind onayları

Aşağıdaki gruplandırma yapısı sıfır genişlikli pozitif bir onay onayını tanımlar:

(?<=Aradığına )

Burada alt ifade herhangi bir normal ifade desenidir. Eşleşmenin başarılı olması için alt ifadenin, eşleşme sonucuna dahil olmamasına rağmen subexpression geçerli konumun solundaki giriş dizesinde gerçekleşmesi gerekir. Sıfır genişlikli pozitif lookbehind onayı geri izlenmez.

Sıfır genişlikli pozitif lookbehind onayları genellikle normal ifadelerin başında kullanılır. Tanımladıkları desen, eşleşme sonucunun bir parçası olmasa da bir eşleşmenin önkoşuludur.

Örneğin, aşağıdaki örnek yirmi birinci yüzyıl için yılın son iki basamağını eşleştirir (yani, eşleşen dizeden önce "20" rakamlarının olmasını gerektirir).

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "2010 1999 1861 2140 2009";
      string pattern = @"(?<=\b20)\d{2}\b";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       10
//       09

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "2010 1999 1861 2140 2009"
        Dim pattern As String = "(?<=\b20)\d{2}\b"

        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:
'       10
'       09

Normal ifade düzeni (?<=\b20)\d{2}\b aşağıdaki tabloda gösterildiği gibi yorumlanır.

Yakalanan bir gruptaki son karakter veya karakterlerin, bu grubun normal ifade desenine uyan karakterlerin bir alt kümesi olması gerektiğinde, geri izlemeyi sınırlamak için sıfır genişlikli pozitif bakış onayları da kullanılır. Örneğin, bir grup ardışık tüm sözcük karakterlerini yakalarsa, son karakterin alfabetik olmasını istemek için sıfır genişlikli pozitif bir onay kullanabilirsiniz.

Sıfır genişlikli negatif lookbehind onayları

Aşağıdaki gruplandırma yapısı sıfır genişlikli negatif lookbehind onayını tanımlar:

(?<!Aradığına )

Burada alt ifade herhangi bir normal ifade desenidir. Eşleşmenin başarılı olması için geçerli konumun solundaki giriş dizesinde alt ifade oluşmamalıdır. Ancak, eşleşmeyen subexpression alt dizeler eşleşme sonucuna dahil değildir.

Sıfır genişlikli negatif lookbehind onayları genellikle normal ifadelerin başında kullanılır. Tanımladıkları desen, izleyen dizede bir eşleşmeyi önler. Ayrıca, yakalanan bir gruptaki son karakter veya karakterlerin bu grubun normal ifade desenine uyan karakterlerden biri veya daha fazlası olmaması gerektiğinde geri izlemeyi sınırlamak için de kullanılır. Örneğin, bir grup ardışık tüm sözcük karakterlerini yakalarsa, son karakterin alt çizgi (_) olmamasını istemek için sıfır genişlikli pozitif bir onay kullanabilirsiniz.

Aşağıdaki örnek, hafta sonu olmayan haftanın herhangi bir gününün tarihiyle (cumartesi veya pazar) eşleşir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] dates = { "Monday February 1, 2010",
                         "Wednesday February 3, 2010",
                         "Saturday February 6, 2010",
                         "Sunday February 7, 2010",
                         "Monday, February 8, 2010" };
      string pattern = @"(?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b";

      foreach (string dateValue in dates)
      {
         Match match = Regex.Match(dateValue, pattern);
         if (match.Success)
            Console.WriteLine(match.Value);
      }
   }
}
// The example displays the following output:
//       February 1, 2010
//       February 3, 2010
//       February 8, 2010

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim dates() As String = {"Monday February 1, 2010", _
                                  "Wednesday February 3, 2010", _
                                  "Saturday February 6, 2010", _
                                  "Sunday February 7, 2010", _
                                  "Monday, February 8, 2010"}
        Dim pattern As String = "(?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b"

        For Each dateValue As String In dates
            Dim match As Match = Regex.Match(dateValue, pattern)
            If match.Success Then
                Console.WriteLine(match.Value)
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       February 1, 2010
'       February 3, 2010
'       February 8, 2010

Normal ifade düzeni (?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b aşağıdaki tabloda gösterildiği gibi yorumlanır.

Atomik gruplar

Aşağıdaki gruplandırma yapısı bir atomik grubu temsil eder (diğer bazı normal ifade altyapılarında geri izleme olmayan alt ifade, atomik alt ifade veya yalnızca bir kez alt ifade olarak bilinir):

(?>Aradığına )

Burada alt ifade herhangi bir normal ifade desenidir.

Normalde, normal ifade isteğe bağlı veya alternatif bir eşleştirme deseni içeriyorsa ve eşleşme başarılı olmazsa, normal ifade altyapısı bir giriş dizesini desenle eşleştirmek için birden çok yönde dallanabilir. İlk dalı aldığında eşleşme bulunamazsa, normal ifade altyapısı ilk eşleşmeyi aldığı noktaya yedekleyebilir veya geri gidebilir ve ikinci dalı kullanarak eşleşmeyi dener. Tüm dallar denenene kadar bu işlem devam edebilir.

Alt (?>ifade) dili yapısı geri izlemeyi devre dışı bırakır. Normal ifade altyapısı, giriş dizesindeki olabildiğince çok karakterle eşleşecektir. Başka eşleşme mümkün olmadığında, alternatif desen eşleşmelerini denemeye geri dönmez. (Yani, alt ifade yalnızca alt ifadeyle eşleştirilecek dizelerle eşleşir; bir dizeyi alt ifadeye ve onu izleyen alt ifadelere göre eşleştirmeye çalışmaz.)

Geri izlemenin başarılı olmadığını biliyorsanız bu seçenek önerilir. Normal ifade altyapısının gereksiz aramalar yapmasını önlemek performansı artırır.

Aşağıdaki örnekte, bir atomik grubun desen eşleşmesinin sonuçlarını nasıl değiştirildiği gösterilmektedir. Geri izleme normal ifadesi, bir sözcük sınırında aynı karakterin bir kez daha tekrarlanmasıyla devam eden bir dizi yinelenen karakterle başarıyla eşleşir, ancak geri izlenmeyen normal ifade eşleşmez.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "cccd.", "aaad", "aaaa" };
      string back = @"(\w)\1+.\b";
      string noback = @"(?>(\w)\1+).\b";

      foreach (string input in inputs)
      {
         Match match1 = Regex.Match(input, back);
         Match match2 = Regex.Match(input, noback);
         Console.WriteLine("{0}: ", input);

         Console.Write("   Backtracking : ");
         if (match1.Success)
            Console.WriteLine(match1.Value);
         else
            Console.WriteLine("No match");

         Console.Write("   Nonbacktracking: ");
         if (match2.Success)
            Console.WriteLine(match2.Value);
         else
            Console.WriteLine("No match");
      }
   }
}
// The example displays the following output:
//    cccd.:
//       Backtracking : cccd
//       Nonbacktracking: cccd
//    aaad:
//       Backtracking : aaad
//       Nonbacktracking: aaad
//    aaaa:
//       Backtracking : aaaa
//       Nonbacktracking: No match

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim inputs() As String = {"cccd.", "aaad", "aaaa"}
        Dim back As String = "(\w)\1+.\b"
        Dim noback As String = "(?>(\w)\1+).\b"

        For Each input As String In inputs
            Dim match1 As Match = Regex.Match(input, back)
            Dim match2 As Match = Regex.Match(input, noback)
            Console.WriteLine("{0}: ", input)

            Console.Write("   Backtracking : ")
            If match1.Success Then
                Console.WriteLine(match1.Value)
            Else
                Console.WriteLine("No match")
            End If

            Console.Write("   Nonbacktracking: ")
            If match2.Success Then
                Console.WriteLine(match2.Value)
            Else
                Console.WriteLine("No match")
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'    cccd.:
'       Backtracking : cccd
'       Nonbacktracking: cccd
'    aaad:
'       Backtracking : aaad
'       Nonbacktracking: aaad
'    aaaa:
'       Backtracking : aaaa
'       Nonbacktracking: No match

İzlenmeyen normal ifade (?>(\w)\1+).\b aşağıdaki tabloda gösterildiği gibi tanımlanır.

Yapıları ve normal ifade nesnelerini gruplandırma

Normal ifade yakalama grubuyla eşleşen alt dizeler, özelliği tarafından System.Text.RegularExpressions.Group döndürülen nesneden System.Text.RegularExpressions.GroupCollection alınabilen nesnelerle Match.Groups temsil edilir. GroupCollection Nesnesi aşağıdaki gibi doldurulur:

• Koleksiyondaki ilk Group nesne (sıfır dizinindeki nesne) eşleşmenin tamamını temsil eder.
• Sonraki nesne kümesi Group , adsız (numaralandırılmış) yakalama gruplarını temsil eder. Bunlar, soldan sağa doğru normal ifadede tanımlandığı sırada görünür. Bu grupların dizin değerleri 1 ile koleksiyondaki adsız yakalama gruplarının sayısı arasında değişir. (Belirli bir grubun dizini, numaralandırılmış geri başvurusuna eşdeğerdir. Geri başvurular hakkında daha fazla bilgi için bkz . Geri Başvuru Yapıları.)
• Son nesne kümesi Group , adlandırılmış yakalama gruplarını temsil eder. Bunlar, soldan sağa doğru normal ifadede tanımlandığı sırada görünür. İlk adlandırılmış yakalama grubunun dizin değeri, son adlandırılmamış yakalama grubunun dizininden büyüktür. Normal ifadede adsız yakalama grubu yoksa, ilk adlandırılmış yakalama grubunun dizin değeri bir olur.

Bir yakalama grubuna bir niceleyici uygularsanız, ilgili Group nesnenin Capture.Value, Capture.Indexve Capture.Length özellikleri bir yakalama grubu tarafından yakalanan son alt dizeyi yansıtır. Özelliği tarafından Group.Captures döndürülen nesneden CaptureCollection niceleyicileri olan gruplar tarafından yakalanan tam bir alt dize kümesi alabilirsiniz.

Aşağıdaki örnek, ve Capture nesneleri arasındaki ilişkiyi Group açıklar.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\b(\w+)\W+)+";
      string input = "This is a short sentence.";
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: '{0}'", match.Value);
      for (int ctr = 1; ctr < match.Groups.Count; ctr++)
      {
         Console.WriteLine("   Group {0}: '{1}'", ctr, match.Groups[ctr].Value);
         int capCtr = 0;
         foreach (Capture capture in match.Groups[ctr].Captures)
         {
            Console.WriteLine("      Capture {0}: '{1}'", capCtr, capture.Value);
            capCtr++;
         }
      }
   }
}
// The example displays the following output:
//       Match: 'This is a short sentence.'
//          Group 1: 'sentence.'
//             Capture 0: 'This '
//             Capture 1: 'is '
//             Capture 2: 'a '
//             Capture 3: 'short '
//             Capture 4: 'sentence.'
//          Group 2: 'sentence'
//             Capture 0: 'This'
//             Capture 1: 'is'
//             Capture 2: 'a'
//             Capture 3: 'short'
//             Capture 4: 'sentence'

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "(\b(\w+)\W+)+"
        Dim input As String = "This is a short sentence."
        Dim match As Match = Regex.Match(input, pattern)
        Console.WriteLine("Match: '{0}'", match.Value)
        For ctr As Integer = 1 To match.Groups.Count - 1
            Console.WriteLine("   Group {0}: '{1}'", ctr, match.Groups(ctr).Value)
            Dim capCtr As Integer = 0
            For Each capture As Capture In match.Groups(ctr).Captures
                Console.WriteLine("      Capture {0}: '{1}'", capCtr, capture.Value)
                capCtr += 1
            Next
        Next
    End Sub
End Module
' The example displays the following output:
'       Match: 'This is a short sentence.'
'          Group 1: 'sentence.'
'             Capture 0: 'This '
'             Capture 1: 'is '
'             Capture 2: 'a '
'             Capture 3: 'short '
'             Capture 4: 'sentence.'
'          Group 2: 'sentence'
'             Capture 0: 'This'
'             Capture 1: 'is'
'             Capture 2: 'a'
'             Capture 3: 'short'
'             Capture 4: 'sentence'

Normal ifade deseni (\b(\w+)\W+)+ bir dizeden tek tek sözcükleri ayıklar. Aşağıdaki tabloda gösterildiği gibi tanımlanmıştır.

İkinci yakalama grubu tümcenin her sözcüğüyle eşleşir. İlk yakalama grubu, her sözcüğün yanı sıra sözcüğü izleyen noktalama işaretleri ve boşluklarla eşleşir. Dizini Group 2 olan nesne, ikinci yakalama grubuyla eşleşen metin hakkında bilgi sağlar. Yakalama grubu tarafından yakalanan sözcüklerin tam kümesi, özelliği tarafından Group.Captures döndürülen nesneden CaptureCollection kullanılabilir.

Ayrıca bkz.

• Normal İfade Dili - Hızlı Başvuru
• Geri Dönüş