Not
Bu sayfaya erişim yetkilendirme gerektiriyor. Oturum açmayı veya dizinleri değiştirmeyi deneyebilirsiniz.
Bu sayfaya erişim yetkilendirme gerektiriyor. Dizinleri değiştirmeyi deneyebilirsiniz.
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.
- Regex.Replace ve Match.Result yöntemleri tarafından 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 motoru tarafından desteklenen gruplama yapıları listelenmekte ve bunların yakalayan ya da yakalamayan türde olup olmadıkları belirtilmektedir.
| Gruplandırma yapısı | Yakalama veya yakalamama |
|---|---|
| Eşleşen alt ifadeler | Yakalama |
| Adlandırılmış eşleşen alt ifadeler | Kayıt alma |
| Grup tanımlarını dengeleme | Yakalama |
| Kapsüllenmeyen gruplar | Yakalama yapmayan |
| Grup seçenekleri | Yakalamayan |
| Sıfır genişlikli pozitif ileri bakma doğrulamaları | Yakalanmayan |
| Sıfır genişlikli negatif bakma doğrulamaları | Yakalamayan |
| Sıfır genişlikli pozitif geriye bakma onayları | Yakalamayan |
| Sıfır genişlikli negatif lookbehind işlemleri | Kapsama içermeyen |
| Atomik gruplar | Yakalama Yok |
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:
(
alt ifade)
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ı her zaman adlandırılmamış yakalama gruplarından sonra sıralanır. 0 numaralı yakalama, normal ifade deseninin tamamıyla eşleşen metindir.
Not
Varsayılan olarak, (alt ifade) dili öğesi eşleşen alt ifadeyi yakalar.
RegexOptions Ancak normal ifade desen eşleştirme yönteminin parametresi bayrağı içeriyorsa RegexOptions.ExplicitCapture veya seçenek bu alt ifadeye uygulanmışsa n (bu makalenin devamında grup seçenekleri bölümüne bakın), eşleşen alt ifade yakalanmaz.
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<>kullanılarak başvurulur; burada ad bir yakalama grubunun adıdır veya\k<>; burada sayı, yakalama grubunun sıralı numarasıdır. Yakalama grubunun varsayılan adı, sıra numarasıyla aynıdır. 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 Regex.Replace yöntem çağrısında numara değiştirme dizisini kullanarak, burada numara, yakalanan alt ifadenin sıra numarasıdır.Programatik olarak, Match.Groups özelliği ile elde edilen GroupCollection nesnesini kullanarak. 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ş dizisindeki başlangıç konumunu bildirmek 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 '{match.Groups[1].Value}' found at positions {match.Groups[1].Index} and {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.
| Desen | Açıklama |
|---|---|
(\w+) |
Bir veya daha fazla sözcük karakteri eşleştir. Bu ilk yakalama grubudur. |
\s |
Bir boşluk karakteri ile eşleştirin. |
(\1) |
Yakalanan ilk gruptaki dizeyi eşleştirin. Bu ikinci yakalama grubudur. Örnek, yinelenen sözcüğün başlangıç konumunun Match.Index özelliğinden alınabilmesi için onu yakalanan bir gruba atar. |
\W |
Boşluk ve noktalama işaretleri dahil olmak üzere sözcük olmayan bir karakteri eşleştirin. Bu, normal ifade deseninin yakalanan ilk gruptaki sözcükle başlayan bir sözcükle eşleşmesini engeller. |
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.
Not
RegexOptions Normal ifade desen eşleştirme yönteminin parametresi bayrağı içeriyorsa RegexOptions.ExplicitCapture veya seçenek bu alt ifadeye uygulanmışsa n (bu konunun devamında grup seçenekleri bölümüne bakın), alt ifade yakalamanın tek yolu yakalama gruplarını açıkça adlandırmaktır.
Adlandırılmış yakalanan gruplara aşağıdaki yollarla erişebilirsiniz:
Normal ifade içinde adlandırılmış geri referans 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 Regex.Replace veya Match.Result yöntemi çağrısında,
${ad}değiştirme dizisini kullanarak, burada ad yakalanan alt ifadenin adıdır.Regex.Replace veya Match.Result yöntemi çağrısında numara değişim sırasını kullanarak, burada numara yakalanan alt ifadenin sıra numarasıdır.
Programatik olarak, GroupCollection tarafından döndürülen nesneyi kullanarak Match.Groups özelliği. 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.)
| Sayı | Veri Akışı Adı | Desen |
|---|---|---|
| 0 | 0 (varsayılan ad) | ((?<One>abc)\d+)?(?<Two>xyz)(.*) |
| 1 | 1 (varsayılan ad) | ((?<One>abc)\d+) |
| 2 | 2 (varsayılan ad) | (.*) |
| 3 | Bir | (?<One>abc) |
| 4 | İki | (?<Two>xyz) |
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 '{match.Groups["duplicateWord"].Value}' at position {match.Groups["duplicateWord"].Index} is followed by '{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.
| Desen | Açıklama |
|---|---|
(?<duplicateWord>\w+) |
Bir veya daha fazla sözcük karakteri eşleştir. Bu yakalama grubunu duplicateWord olarak adlandır. |
\s |
Bir boşluk karakteri ile eşleştirin. |
\k<duplicateWord> |
Yakalanmış grup olan duplicateWord adlı gruptaki dizeyi eşleştirin. |
\W |
Boşluk ve noktalama işaretleri dahil olmak üzere sözcük olmayan bir karakteri eşleştirin. Bu, normal ifade deseninin yakalanan ilk gruptaki sözcükle başlayan bir sözcükle eşleşmesini engeller. |
(?<nextWord>\w+) |
Bir veya daha fazla sözcük karakteri eşleştir. Bu yakalama grubunu nextWord olarak adlandırın. |
Grup adı normal ifadede yinelenebilir. Örneğin, aşağıdaki örnekte gösterildiği gibi, digit olarak birden fazla grup adlandırılması mü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 sayı karakterini yakalar. İkinci digit adlandırılmış grup, bir veya daha fazla basamak karakterinin sıfır veya bir kez 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: {m.Value}");
for (int grpCtr = 1; grpCtr < m.Groups.Count; grpCtr++) {
Group grp = m.Groups[grpCtr];
Console.WriteLine($"Group {grpCtr}: {grp.Value}");
for (int capCtr = 0; capCtr < grp.Captures.Count; capCtr++)
Console.WriteLine($" Capture {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.
| Desen | Açıklama |
|---|---|
\D+ |
Ondalık olmayan bir veya daha fazla basamak karakterini eşleştirin. |
(?<digit>\d+) |
Bir veya daha fazla ondalık basamak karakteri eşleştirin. Eşleşmeyi adlandırılmış gruba atayın digit . |
\D+ |
Ondalık olmayan bir veya daha fazla basamak karakterini eşleştirin. |
(?<digit>\d+)? |
Bir veya daha fazla ondalık basamak karakterinin sıfır veya bir oluşumunu eşleştirin. Eşleşmeyi adlandırılmış gruba atayın digit . |
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 name2 ile name1 arasındaki aralığı name1'de depolar. Ad2 grubu tanımlanmamışsa, eşleşme geri izler. 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 kendi Group.Captures koleksiyonuna yerleştirilir. Kapanış karakteri eşleştirildiğinde, ilgili açılış karakteri gruptan kaldırılır ve Captures koleksiyonu bir birim azaltılır. Tüm iç içe yapıların açılış ve kapanış karakterleri eşleştirildikten sonra, isim2 boş olur.
Not
Aşağıdaki örnekteki normal ifadeyi iç içe bir yapının uygun açma ve kapatma karakterini kullanacak şekilde değiştirdikten sonra, matematiksel ifadeler veya birden çok iç içe yöntem çağrısı içeren program kodu satırları gibi iç içe yapıların çoğunu işlemek için kullanabilirsiniz.
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, eşleşen açılı ayraç çiftlerini izlemek amacıyla bir yığın gibi kullanılan iki adlandırılmış grup, Open ve Close, tanımlar. Her yakalanan sol açılı ayraç Open grubunun yakalama koleksiyonuna itilir ve her yakalanan sağ açılı ayraç Close grubunun yakalama koleksiyonuna itilir. Dengeleme grubu tanımı, her sol açılı ayraç için eşleşen bir sağ açılı ayraç olmasını sağlar. Eğer yoksa, son alt desen (?(Open)(?!)), grup boş değilse Open (ve dolayısıyla tüm iç içe geçmiş yapılar kapanmamışsa) değerlendirilir. En son alt desen değerlendirilirse, (?!) alt deseni sıfır genişlikli negatif bir lookahead onayı olduğundan ve her zaman başarısız 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: \"{input}\" \nMatch: \"{m}\"");
int grpCtr = 0;
foreach (Group grp in m.Groups)
{
Console.WriteLine($" Group {grpCtr}: {grp.Value}");
grpCtr++;
int capCtr = 0;
foreach (Capture cap in grp.Captures)
{
Console.WriteLine($" Capture {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:
| Desen | Açıklama |
|---|---|
^ |
Dizenin başlangıcından başlayın. |
[^<>]* |
Sol veya sağ açılı parantez olmayan sıfır veya daha fazla karakteri eşleştirin. |
(?'Open'<) |
Sol açı parantezi eşleştirin ve Open adlı bir gruba atayın. |
[^<>]* |
Sol veya sağ açılı ayraç içermeyen sıfır veya daha fazla karakteri eşle. |
((?'Open'<)[^<>]*)+ |
Sol açılı ayraçların bir veya daha fazla tekrarını ve ardından sol veya dik açılı ayraç olmayan sıfır veya daha fazla karakteri eşleştirin. İkinci yakalama grubu budur. |
(?'Close-Open'>) |
Sağ açılı ayraç eşleştirin, Open grubu ile geçerli grup arasındaki alt dizeyi Close grubuna atayın ve Open grubunun tanımını silin. |
[^<>]* |
Sol veya sağ açılı ayraç olmayan herhangi bir karakterin sıfır veya daha fazla oluşumunu bulun. |
((?'Close-Open'>)[^<>]*)+ |
Sağ açı parantezinin bir veya daha fazla oluşumuyla eşleşin ve ardından, sol veya sağ açı parantezi olmayan herhangi bir karakterin sıfır veya daha fazla oluşumu gelir. Sağ açılı ayracı eşleştirirken, Open grubu ile mevcut grup arasında kalan alt diziyi Close grubuna atayın ve Open grubunun tanımını silin. Bu, üçüncü yakalama grubudur. |
(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)* |
Aşağıdaki desenin sıfır veya daha fazla tekrarı ile eşleşin: bir veya daha fazla sol köşeli parantez, ardından sıfır veya daha fazla köşeli parantez olmayan karakterler, ardından bir veya daha fazla sağ köşeli parantez ve ardından sıfır veya daha fazla köşeli parantez olmayan karakterler. Sağ açılı ayraçla eşleştirirken, Open grubunun tanımını silin ve Open grubu ile mevcut grup arasındaki alt dizeyi Close grubuna atayın. Bu ilk yakalama grubudur. |
(?(Open)(?!)) |
Open Grup varsa, boş bir dize eşleştirilebiliyorsa eşleşmeyi bırakın, ancak normal ifade altyapısının dizedeki konumunu ilerletmeyin. Bu sıfır genişlikli negatif bir lookahead onayıdır. Giriş dizesinde her zaman örtük olarak boş bir dize bulunduğundan, bu eşleşme her zaman başarısız olur. Bu eşleşmenin başarısızlığı, köşeli parantezlerin dengeli olmadığını gösterir. |
$ |
Giriş dizesinin sonuyla eşleş. |
Son alt ifade olan (?(Open)(?!)), giriş dizesindeki iç içe yerleştirme yapılarının düzgün dengelenip dengelenmediğini (örneğin, her sol açılı ayraç bir sağ açılı ayraçla eşleşmiş mi) gösterir. Geçerli bir yakalanan grubu temel alan koşullu eşleştirme kullanır; daha fazla bilgi için bkz Alternation Constructs.
Open grubu tanımlanmışsa, normal ifade motoru giriş dizesindeki (?!) alt ifadesini eşleştirmeye çalışır. 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 her zaman giriş dizesinde bir sonraki konumda örtük olarak bulunduğundan, her zaman başarısız olan sıfır genişlikli negatif bir ileriye bakış kontrolüdür.
Örnekte, normal ifade altyapısı aşağıdaki tabloda gösterildiği gibi "<abc><mno<xyz>>" giriş dizesini değerlendirir.
| Adım | Desen | Sonuç |
|---|---|---|
| 1 | ^ |
Eşleşmeyi giriş dizesinin başında başlatır |
| 2 | [^<>]* |
Sol açılı ayraç öncesinde açısız ayraç karakterlerini arar; eşleşme bulunamaz. |
| 3 | (((?'Open'<) |
"<abc>" içindeki sol açılı ayraçla eşleşir ve bunu Open gruba atar. |
| 4 | [^<>]* |
"abc" ile eşleşir. |
| 5 | )+ |
"<abc", yakalanan ikinci grubun değeridir. Giriş dizesindeki bir sonraki karakter sol açılı ayraç olmadığından düzenli ifade motoru (?'Open'<)[^<>]*) alt modeline dönmez. |
| 6 | ((?'Close-Open'>) |
"<abc>" içindeki sağ açılı ayraçla eşleşir, Open grubu ile sağ açılı ayraç arasındaki alt dize olan "abc" öğesini Close grubuna atar ve Open grubunun geçerli değerini ("<") silerek boş bırakır. |
| 7 | [^<>]* |
Dik açılı ayraç sonrasında açılı olmayan köşeli ayraç karakterleri arar; eşleşme bulmaz. |
| 8 | )+ |
Yakalanan üçüncü grubun değeri ">"dir. Giriş dizesindeki bir sonraki karakter sağ açı parantezi olmadığından düzenli ifade motoru ((?'Close-Open'>)[^<>]*) alt modeline geri dönmez. |
| 9 | )* |
Yakalanan ilk grubun değeri "<abc>"dir. Giriş dizesindeki bir sonraki karakter sol açılı ayraç olduğundan normal ifade altyapısı alt sayfaya (((?'Open'<) geri döner. |
| 10 | (((?'Open'<) |
"<mno" içindeki sol açılı ayraçla eşleşir ve bunu Open grubuna atar. Koleksiyonu Group.Captures artık "<" adlı tek bir değere sahiptir. |
| 11 | [^<>]* |
"mno" ile eşleşir. |
| 12 | )+ |
"<mno", yakalanan ikinci grubun değeridir. Giriş dizesindeki bir sonraki karakter sol açılı ayraç olduğundan, normal ifade motoru (?'Open'<)[^<>]*) alt desenine döner. |
| 13 | (((?'Open'<) |
"<xyz>" içindeki sol açılı ayraçla eşleşir ve bunu Open grubuna atar.
Group.Captures grubunun Open koleksiyonu artık iki yakalama içerir: "<mno" içinden sol açısal ayraç ve "<xyz>" içindeki sol açısal ayraç. |
| 14 | [^<>]* |
"xyz" ile eşleşir. |
| 15 | )+ |
"<xyz", yakalanan ikinci grubun değeridir. Giriş dizesindeki bir sonraki karakter sol açılı ayraç olmadığından, normal ifade motoru (?'Open'<)[^<>]*) alt modeline geri dönmez. |
| 16 | ((?'Close-Open'>) |
"<xyz>" içindeki dik açılı ayraçla eşleşir. "xyz", Open grubu ile sağ açılı ayraç arasındaki alt dizeyi Close grubuna atar ve Open grubunun mevcut değerini siler. Önceki yakalamanın değeri ("mno" içindeki< sol açılı ayraç), grubun geçerli değeri Open olur.
Captures koleksiyonunun Open grubuna şimdi "<xyz>" içindeki sol açılı parantez olan tek bir yakalama dahildir. |
| 17 | [^<>]* |
Açı olmayan köşeli ayraç karakterlerini arar; eşleşme bulunmaz. |
| 18 | )+ |
Yakalanan üçüncü grubun değeri ">"dir. Giriş dizesindeki bir sonraki karakter sağ açılı ayraç olduğundan, düzenli ifade motoru ((?'Close-Open'>)[^<>]*) alt desenine geri döner. |
| 19 | ((?'Close-Open'>) |
"xyz>>" içindeki son sağ açılı ayraçla eşleşir, "mno<xyz>" dizisini (grup ile sağ açılı ayraç arasındaki Open alt dizesi) Close grubuna atama yapar ve Open grubunun mevcut değerini siler. Grup Open artık boş. |
| 20 | [^<>]* |
Açılı ayraç olmayan karakterleri arar; eşleşme bulamaz. |
| 21 | )+ |
Yakalanan üçüncü grubun değeri ">"dir. Giriş dizesindeki bir sonraki karakter sağ açılı parantez olmadığından, düzenli ifade motoru ((?'Close-Open'>)[^<>]*) alt desenine geri dönmez. |
| 22 | )* |
Yakalanan ilk grubun değeri "<mno<xyz>>"dir. Giriş dizesindeki bir sonraki karakter sol açılı ayraç olmadığından düzenli ifade motoru (((?'Open'<) alt desene geri dönmez. |
| 23 | (?(Open)(?!)) |
Grup Open tanımlanmamıştır, bu nedenle eşleşme denenmemiştir. |
| 24 | $ |
Giriş dizesinin sonuyla eşleşir. |
Yakalanmayan 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.
Not
Normal ifade iç içe gruplandırma yapıları içeriyorsa, iç içe grup yapılarına dış kapsüllemeyen grup yapısı uygulanmaz.
Aşağıdaki örnek, yakalayıcı olmayan grupları içeren bir normal ifade göstermektedir. Çı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: {match.Value}");
for (int ctr = 1; ctr < match.Groups.Count; ctr++)
Console.WriteLine($" Group {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.
Nokta ile sonlandırılan bir cümleyle eşleşen normal ifade (?:\b(?:\w+)\W*)+\. 'dir. 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.
| Desen | 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şleşen metni yakalanan bir gruba atamayın. |
\W* |
Sıfır veya daha fazla sözcük dışı karakter eşleştirin. |
(?:\b(?:\w+)\W*)+ |
Bir sözcük sınırından başlayarak bir veya daha fazla sözcük karakterinin desenini, ardından sıfır veya daha fazla sözcük olmayan karakterle bir veya daha fazla kez eşleşmesini sağlayın. Eşleşen metni yakalanan bir gruba atamayın. |
\. |
Bir dönemi eşleştirin. |
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:
alt ifade)
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.
Not
Sınıf oluşturucu veya statik bir yöntem kullanarak System.Text.RegularExpressions.Regex alt ifade yerine normal ifadenin tamamına uygulanacak seçenekleri belirtebilirsiniz. Dil yapısını kullanarak (?imnsx-imnsx) normal ifadedeki belirli bir noktadan sonra geçerli olacak satır içi seçenekleri de belirtebilirsiniz.
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 ve GroupCollection nesnesini doldurmak için kullanılmaz.
Örneğin, aşağıdaki örnekteki normal ifade \b(?ix: d \w+)\s , bir gruplandırma yapısındaki satır içi seçenekleri kullanarak büyük/küçük harfe duyarsız eşleşmeyi sağlamak ve "d" harfiyle başlayan tüm sözcükleri tanımlarken desen boşluklarını görmezden gelmek için kullanılır. Normal ifade aşağıdaki tabloda gösterildiği gibi tanımlanır.
| Desen | Açıklama |
|---|---|
\b |
Bir sözcük sınırında eşleşmeye başla. |
(?ix: d \w+) |
Büyük/küçük harfe duyarsız eşleştirmeyi kullanarak ve bu desendeki boşlukları yoksayarak bir "d" sözcüğünü ve ardından bir veya daha fazla sözcük karakterini eşleştirin. |
\s |
Bir boşluk karakteri ile eşleştirin. |
string pattern = @"\b(?ix: d \w+)\s";
string input = "Dogs are decidedly good pets.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine($"'{match.Value}// found at index {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 ileri bakış ifadeleri
Aşağıdaki gruplandırma yapısı, sıfır genişlikli pozitif bir ileriye bakma ifadesini tanımlar.
(?=
alt ifade)
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 ileri bakış onaylama işlemi geri dönüş yapmaz.
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 yakalama grubunun, o yakalama grubu 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 ileri bakış ifadesini kullanabilirsiniz. Örneğin, bir yakalama grubu ardışık kelime karakterleriyle eşleşiyorsa, ilk karakterin alfabetik olarak büyük harfli bir karakter olmasını gerektirmek için sıfır genişlikli pozitif bir ileri bakış koşulu kullanabilirsiniz.
Aşağıdaki örnek, giriş dizesinde "is" fiilinden önce gelen kelimeyi eşleştirmek için sıfır genişlikli bir pozitif bakma doğrulaması 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($"'{match.Value}' precedes 'is'.");
else
Console.WriteLine($"'{input}' does not match the pattern.");
}
}
}
// 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.
| Desen | 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. |
(?=\sis\b) |
Sözcük karakterlerinin ardından bir boşluk karakteri ve sözcük sınırında biten "is" dizesinin gelip gelipmeyeceğini belirleyin. Öyleyse, eşleşme başarılı olur. |
Sıfır genişlikli negatif ileri bakış onayları
Aşağıdaki gruplandırma yapısı, sıfır genişlikli negatif ileri bakışlı ifadeyi tanımlar.
(?!
alt ifade)
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. Bir normal ifadenin sonunda, bir eşleşmenin sonunda yer alamayacak 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.
| Desen | Açıklama |
|---|---|
\b |
Bir sözcük sınırında eşleşmeye başla. |
(?!un) |
Sonraki iki karakterin "un" olup olmadığını belirleyin. Eğer öyle değilse, bir eşleşme mümkündür. |
\w+ |
Bir veya daha fazla sözcük karakteri eşleştir. |
\b |
Eşlemeyi bir sözcük sınırında sonlandır. |
Aşağıdaki örnek, noktalama karakteriyle bitmeyen sözcüklerle eşleşmek için, sonunda sıfır genişlikli bir lookahead delili 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.
| Desen | Açıklama |
|---|---|
\b |
Bir kelime sınırında eşleşmeyi başlat. |
\w+ |
Bir veya daha fazla sözcük karakteri eşleştir. |
\b |
Eşleşmeyi bir kelime sınırında sonlandır. |
\p{P}) |
Sonraki karakter noktalama işareti değilse (nokta veya virgül gibi), eşleşme başarılı olur. |
Sıfır genişlikli pozitif geri bakma ifadeleri
Aşağıdaki gruplandırma yapısı sıfır genişlikli pozitif bir lookbehind ifadesi tanımlar.
(?<=
alt ifade)
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.
| Desen | Açıklama |
|---|---|
\d{2} |
İki ondalık basamağı eşleştirin. |
(?<=\b20) |
Bir sözcük sınırında "20" ondalık basamağından önce iki ondalık basamak varsa eşleşmeye devam edin. |
\b |
Eşleşmeyi bir sözcük sınırında sonlandır. |
Yakalanan bir gruptaki son karakter veya karakterlerin, o grubun normal ifade deseniyle eşleşen 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 kelime karakterlerini yakalarsa, son karakterin alfabetik olması gerektiğini belirtmek için sıfır genişlikli pozitif bir lookbehind ifadesi kullanabilirsiniz.
Sıfır genişlikli negatif lookbehind onayları
Aşağıdaki gruplandırma yapısı, sıfır genişlikli negatif geribakış ifadesi tanımlar.
(?<!
alt ifade)
Burada alt ifade herhangi bir normal ifade desenidir. Eşleşmenin başarılı olması için, alt ifade mevcut konumun solundaki giriş dizisinde bulunmamalıdır. Ancak, eşleşmeyen subexpression alt dizeler eşleşme sonucuna dahil değildir.
Sıfır genişlikli negatif lookbehind ifadeleri 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ı gerektirmek için sıfır genişlikli, pozitif bir geriye doğru kontrole dayalı bir doğrulama kullanabilirsiniz.
Aşağıdaki örnek, hafta sonu olmayan haftanın herhangi bir gününün tarihiyle eşleşir, yani cumartesi veya pazar değildir.
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.
| Desen | Açıklama |
|---|---|
\b |
Bir sözcük sınırında eşleşmeye başla. |
\w+ |
Bir veya daha fazla sözcük karakterini ve ardından boşluk karakterini eşleştirin. |
\d{1,2}, |
Bir veya iki ondalık basamağı, ardından boşluk karakteri ve virgülle eşleştirin. |
\d{4}\b |
Dört ondalık basamağı eşleştirin ve eşleşmeyi bir sözcük sınırında sonlandırın. |
(?<!(Saturday|Sunday) ) |
Eşleşmenin önünde "Cumartesi" veya "Pazar" dizelerinden başka bir şey ve ardından boşluk varsa, eşleşme başarılı olur. |
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):
(?>
alt ifade)
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. Düzenli ifade motoru, 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 izleyen normal ifade, aynı karakterin bir kelime sınırında tekrar görünmesiyle devam eden bir dizi yinelenen karakterle uygun şekilde eşleşir, ancak geri izlemeyen 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($"{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
İz sürmeyen düzenli ifade (?>(\w)\1+).\b aşağıdaki tabloda gösterildiği gibi tanımlanır.
| Desen | Açıklama |
|---|---|
(\w) |
Tek bir kelime karakterini eşleştirip ilk yakalama grubuna atayın. |
\1+ |
Yakalanan ilk alt dizenin değerini bir veya daha fazla kez eşleştirin. |
. |
Herhangi bir karakteri eşleştirin. |
\b |
Eşleşmeyi bir sözcük sınırında sonlandırın. |
(?>(\w)\1+) |
Bir kelimenin yinelenen karakterlerinden bir veya daha fazlasını eşleştirin, fakat kelime sınırındaki son karakterle eşleşmeye çalışırken geri gitmeyin. |
Yapıları ve normal ifade nesnelerini gruplandırma
Düzenli ifade yakalama grubuyla eşleşen alt dizeler, Match.Groups özelliği tarafından döndürülen System.Text.RegularExpressions.GroupCollection nesnesinden alınabilecek System.Text.RegularExpressions.Group nesneleriyle 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. Normal ifadede soldan sağa doğru tanımlandığı sırayla görünürler. 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. Tanımlandıkları sırayla, soldan sağa doğru normal ifadede görünürler. İ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 Group.Captures tarafından döndürülen CaptureCollection nesnesinden, niceleyici içeren gruplar tarafından yakalanan alt dizelerin tam bir kümesini alabilirsiniz.
Aşağıdaki örnek, Group ve Capture nesneleri arasındaki ilişkiyi 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: '{match.Value}'");
for (int ctr = 1; ctr < match.Groups.Count; ctr++)
{
Console.WriteLine($" Group {ctr}: '{match.Groups[ctr].Value}'");
int capCtr = 0;
foreach (Capture capture in match.Groups[ctr].Captures)
{
Console.WriteLine($" Capture {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.
| Desen | 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 karakterler birlikte bir sözcük oluşturur. Bu ikinci yakalama grubudur. |
\W+ |
Bir veya daha fazla kelime dışı karakteri eşleştirin. |
(\b(\w+)\W+) |
Bir veya daha fazla sözcük karakterinin desenini ve ardından bir veya daha fazla sözcük olmayan karakteri bir veya birden çok kez eşleştirin. Bu ilk yakalama grubudur. |
İkinci yakalama grubu cümlenin her kelimesiyle eşleşir. İlk yakalama grubu, her bir sözcük ile bu sözcüğü takip eden noktalama işaretleri ve boşlukları eşleştirir. 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, Group.Captures özelliği tarafından döndürülen CaptureCollection nesnesinden kullanılabilir.
Ayrıca bkz.
GitHub'da bizimle işbirliği yapın
Bu içeriğin kaynağı GitHub'da bulunabilir; burada ayrıca sorunları ve çekme isteklerini oluşturup gözden geçirebilirsiniz. Daha fazla bilgi için katkıda bulunan kılavuzumuzu inceleyin.
