Normal İfadelerdeki Değişimler

Değiştirmeler, yalnızca değiştirme desenleri içinde tanınan dil öğeleridir. Giriş dizesinde eşleşen metnin yerini alacak metnin tümünü veya bir kısmını tanımlamak için normal bir ifade deseni kullanırlar. Değiştirme deseni, değişmez karakterlerin yanı sıra bir veya birden çok değiştirmeden oluşabilir. Değiştirme desenleri, parametresi olan replacement yöntemin Regex.Replace aşırı yüklemelerine ve yöntemine Match.Result sağlanır. Yöntemler, eşlenen deseni parametresi tarafından replacement tanımlanan desenle değiştirir.

.NET, aşağıdaki tabloda listelenen değiştirme öğelerini tanımlar.

Değişim Öğeleri ve Değiştirme Desenleri

Değişimler, bir değiştirme deseninde tanınan tek özel yapılarıdır. Karakter kaçışları ve herhangi bir karakterle eşleşen nokta (). dahil olmak üzere diğer normal ifade dili öğelerinin hiçbiri desteklenmez. Benzer şekilde, değişim dil öğeleri yalnızca değiştirme desenlerinde tanınır ve normal ifade desenlerinde hiçbir zaman geçerli değildirler.

Normal ifade deseninde veya değiştirmede görünebilen tek karakter, her bağlamda farklı bir anlamı olmasına rağmen karakterdir $ . Normal ifade deseninde, $ dizenin sonuyla eşleşen bir yer işaretidir. Değiştirme düzeninde, $ değiştirmenin başlangıcını gösterir.

Numaralandırılmış Bir Grubu Değiştirme

$sayı dili öğesi, değiştirme dizesindeki sayı yakalama grubuyla eşleşen son alt dizeyi içerir; burada sayı, yakalama grubunun dizinidir. Örneğin, değiştirme deseni $1 eşleşen alt dizenin yakalanan ilk grupla değiştirileceğine işaret eder. Numaralandırılmış yakalama grupları hakkında daha fazla bilgi için bkz . Gruplandırma Yapıları.

İzleyen $ tüm basamaklar sayı grubuna ait olarak yorumlanır. Amacınız bu değilse, onun yerine adlandırılmış bir grup kullanabilirsiniz. Örneğin, değiştirme dizesini "1" sayısıyla birlikte yakalanan ilk grubun değeri olarak tanımlamak için yerine $11 değiştirme dizesini ${1}1 kullanabilirsiniz. Daha fazla bilgi için bkz . Adlandırılmış Grup Değiştirme.

Ad>) söz dizimi kullanılarak (?<açıkça ad atanmamış grupları yakalamak, soldan sağa doğru numaralandırılır. Adlandırılmış gruplar da, son adlandırılmamış grubun dizininin bir büyüğünden başlanarak, soldan sağa doğru numaralandırılır. Örneğin, normal ifadesinde (\w)(?<digit>\d), adlandırılmış grubun dizini digit 2'dir.

Sayı normal ifade deseninde tanımlanmış geçerli bir yakalama grubu belirtmezse, $sayı her eşleşmeyi değiştirmek için kullanılan değişmez karakter dizisi olarak yorumlanır.

Aşağıdaki örnek, para birimi simgesini ondalık değerden kaldırmak için sayı değiştirmesini kullanır.$ Bir parasal değerin başında ve sonunda bulunan para birimi simgesini kaldırır ve en yaygın iki ondalık ayırıcıyı ("." ve ",") tanır.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}*";
      string replacement = "$1";
      string input = "$16.32 12.19 £16.29 €18.29  €18,29";
      string result = Regex.Replace(input, pattern, replacement);
      Console.WriteLine(result);
   }
}
// The example displays the following output:
//       16.32 12.19 16.29 18.29  18,29

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}*"
        Dim replacement As String = "$1"
        Dim input As String = "$16.32 12.19 £16.29 €18.29  €18,29"
        Dim result As String = Regex.Replace(input, pattern, replacement)
        Console.WriteLine(result)
    End Sub
End Module
' The example displays the following output:
'       16.32 12.19 16.29 18.29  18,29

Normal ifade deseni \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* aşağıdaki tabloda gösterildiği gibi tanımlanır.

Adlandırılmış Bir Grubu Değiştirme

${Name} language öğesi, ad yakalama grubuyla eşleşen son alt dizenin yerini alır; burada ad, ad dili öğesi tarafından (?<tanımlanan bir yakalama grubunun adıdır.>) Adlandırılmış yakalama grupları hakkında daha fazla bilgi için bkz . Gruplandırma Yapıları.

Ad normal ifade deseninde tanımlanan geçerli bir adlandırılmış yakalama grubu belirtmiyorsa ancak basamaklardan oluşuyorsa,${ ad} numaralandırılmış grup olarak yorumlanır.

Ad, normal ifade deseninde tanımlanmış geçerli bir adlandırılmış yakalama grubu veya geçerli bir numaralandırılmış yakalama grubu belirtmiyorsa,${ ad} her eşleşmeyi değiştirmek için kullanılan değişmez karakter dizisi olarak yorumlanır.

Aşağıdaki örnek, para birimi simgesini ondalık değerden kaldırmak için ad} değiştirmesini kullanır${. Bir parasal değerin başında ve sonunda bulunan para birimi simgesini kaldırır ve en yaygın iki ondalık ayırıcıyı ("." ve ",") tanır.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\p{Sc}*(?<amount>\s?\d+[.,]?\d*)\p{Sc}*";
      string replacement = "${amount}";
      string input = "$16.32 12.19 £16.29 €18.29  €18,29";
      string result = Regex.Replace(input, pattern, replacement);
      Console.WriteLine(result);
   }
}
// The example displays the following output:
//       16.32 12.19 16.29 18.29  18,29

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\p{Sc}*(?<amount>\s?\d+[.,]?\d*)\p{Sc}*"
        Dim replacement As String = "${amount}"
        Dim input As String = "$16.32 12.19 £16.29 €18.29  €18,29"
        Dim result As String = Regex.Replace(input, pattern, replacement)
        Console.WriteLine(result)
    End Sub
End Module
' The example displays the following output:
'       16.32 12.19 16.29 18.29  18,29

Normal ifade deseni \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* aşağıdaki tabloda gösterildiği gibi tanımlanır.

Bir "$" Karakterini Değiştirme

Değiştirme, $$ değiştirilen dizeye değişmez bir "$" karakteri ekler.

Aşağıdaki örnek, geçerli kültürün NumberFormatInfo para birimi simgesini ve bir para birimi dizesindeki yerleşimini belirlemek için nesnesini kullanır. Ardından, normal bir ifade deseni ve bir değiştirme desenini dinamik olarak oluşturur. Örnek, geçerli kültürü en-US olan bir bilgisayarda çalıştırılıyorsa, normal ifade desenini ve değiştirme desenini \b(\d+)(\.(\d+))?$$ $1$2oluşturur. Değiştirme deseni, eşleşen metni bir para birimi simgesiyle ve ardından birinci ve ikinci yakalanan grupların geldiği bir boşlukla değiştirir.

using System;
using System.Globalization;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Define array of decimal values.
      string[] values= { "16.35", "19.72", "1234", "0.99"};
      // Determine whether currency precedes (True) or follows (False) number.
      bool precedes = NumberFormatInfo.CurrentInfo.CurrencyPositivePattern % 2 == 0;
      // Get decimal separator.
      string cSeparator = NumberFormatInfo.CurrentInfo.CurrencyDecimalSeparator;
      // Get currency symbol.
      string symbol = NumberFormatInfo.CurrentInfo.CurrencySymbol;
      // If symbol is a "$", add an extra "$".
      if (symbol == "$") symbol = "$$";

      // Define regular expression pattern and replacement string.
      string pattern = @"\b(\d+)(" + cSeparator + @"(\d+))?";
      string replacement = "$1$2";
      replacement = precedes ? symbol + " " + replacement : replacement + " " + symbol;
      foreach (string value in values)
         Console.WriteLine("{0} --> {1}", value, Regex.Replace(value, pattern, replacement));
   }
}
// The example displays the following output:
//       16.35 --> $ 16.35
//       19.72 --> $ 19.72
//       1234 --> $ 1234
//       0.99 --> $ 0.99

Imports System.Globalization
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        ' Define array of decimal values.
        Dim values() As String = {"16.35", "19.72", "1234", "0.99"}
        ' Determine whether currency precedes (True) or follows (False) number.
        Dim precedes As Boolean = (NumberFormatInfo.CurrentInfo.CurrencyPositivePattern Mod 2 = 0)
        ' Get decimal separator.
        Dim cSeparator As String = NumberFormatInfo.CurrentInfo.CurrencyDecimalSeparator
        ' Get currency symbol.
        Dim symbol As String = NumberFormatInfo.CurrentInfo.CurrencySymbol
        ' If symbol is a "$", add an extra "$".
        If symbol = "$" Then symbol = "$$"

        ' Define regular expression pattern and replacement string.
        Dim pattern As String = "\b(\d+)(" + cSeparator + "(\d+))?"
        Dim replacement As String = "$1$2"
        replacement = If(precedes, symbol + " " + replacement, replacement + " " + symbol)
        For Each value In values
            Console.WriteLine("{0} --> {1}", value, Regex.Replace(value, pattern, replacement))
        Next
    End Sub
End Module
' The example displays the following output:
'       16.35 --> $ 16.35
'       19.72 --> $ 19.72
'       1234 --> $ 1234
'       0.99 --> $ 0.99

Normal ifade deseni \b(\d+)(\.(\d+))? aşağıdaki tabloda gösterildiği gibi tanımlanır.

Tüm Eşleştirmeyi Değiştirme

Değiştirme $& , değiştirme dizesindeki eşleşmenin tamamını içerir. Genellikle, eşleştirilen dizenin başlangıcına veya sonuna bir alt dize eklemek için kullanılır. Örneğin, değiştirme deseni ($&) her eşleşmenin başına ve sonuna parantez ekler. Eşleşme yoksa, değiştirmenin $& hiçbir etkisi yoktur.

Aşağıdaki örnekte, dize dizisinde $& depolanan kitap başlıklarının başına ve sonuna tırnak işaretleri eklemek için değiştirme kullanılır.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^(\w+\s?)+$";
      string[] titles = { "A Tale of Two Cities",
                          "The Hound of the Baskervilles",
                          "The Protestant Ethic and the Spirit of Capitalism",
                          "The Origin of Species" };
      string replacement = "\"$&\"";
      foreach (string title in titles)
         Console.WriteLine(Regex.Replace(title, pattern, replacement));
   }
}
// The example displays the following output:
//       "A Tale of Two Cities"
//       "The Hound of the Baskervilles"
//       "The Protestant Ethic and the Spirit of Capitalism"
//       "The Origin of Species"

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "^(\w+\s?)+$"
        Dim titles() As String = {"A Tale of Two Cities", _
                                   "The Hound of the Baskervilles", _
                                   "The Protestant Ethic and the Spirit of Capitalism", _
                                   "The Origin of Species"}
        Dim replacement As String = """$&"""
        For Each title As String In titles
            Console.WriteLine(Regex.Replace(title, pattern, replacement))
        Next
    End Sub
End Module
' The example displays the following output:
'       "A Tale of Two Cities"
'       "The Hound of the Baskervilles"
'       "The Protestant Ethic and the Spirit of Capitalism"
'       "The Origin of Species"

Normal ifade deseni ^(\w+\s?)+$ aşağıdaki tabloda gösterildiği gibi tanımlanır.

Değiştirme "$&" düzeni, her eşleşmenin başına ve sonuna değişmez bir tırnak işareti ekler.

Eşleştirmeden Önceki Metni Değiştirme

Değiştirme, $` eşleşmeden önce eşleşen dizeyi giriş dizesinin tamamıyla değiştirir. Yani, giriş dizesini eşleştirmeye kadar çoğaltırken, eşleştirilen metni kaldırır. Eşleştirilen metni izleyen metin, sonuç dizesinde değiştirilmez. Bir giriş dizesinde birden çok eşleştirme varsa, değiştirme metni, metnin daha önceki eşleştirmelerle değiştirildiği dizeden değil, özgün giriş dizesinden türetilir. (Örnek bir çizim sağlar.) Eşleşme yoksa, değiştirmenin $` hiçbir etkisi yoktur.

Aşağıdaki örnek, giriş dizesindeki bir veya daha fazla ondalık basamak dizisiyle eşleştirmek için normal ifade desenini \d+ kullanır. Değiştirme dizesi $` , bu basamakları eşleşmeden önceki metinle değiştirir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "aa1bb2cc3dd4ee5";
      string pattern = @"\d+";
      string substitution = "$`";
      Console.WriteLine("Matches:");
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("   {0} at position {1}", match.Value, match.Index);

      Console.WriteLine("Input string:  {0}", input);
      Console.WriteLine("Output string: " +
                        Regex.Replace(input, pattern, substitution));
   }
}
// The example displays the following output:
//    Matches:
//       1 at position 2
//       2 at position 5
//       3 at position 8
//       4 at position 11
//       5 at position 14
//    Input string:  aa1bb2cc3dd4ee5
//    Output string: aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "aa1bb2cc3dd4ee5"
        Dim pattern As String = "\d+"
        Dim substitution As String = "$`"
        Console.WriteLine("Matches:")
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("   {0} at position {1}", match.Value, match.Index)
        Next
        Console.WriteLine("Input string:  {0}", input)
        Console.WriteLine("Output string: " + _
                          Regex.Replace(input, pattern, substitution))
    End Sub
End Module
' The example displays the following output:
'    Matches:
'       1 at position 2
'       2 at position 5
'       3 at position 8
'       4 at position 11
'       5 at position 14
'    Input string:  aa1bb2cc3dd4ee5
'    Output string: aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee

Bu örnekte, giriş dizesi "aa1bb2cc3dd4ee5" beş eşleşme içerir. Aşağıdaki tabloda, değiştirmenin normal ifade altyapısının $` giriş dizesindeki her eşleşmeyi değiştirmesine nasıl neden olduğu gösterilmektedir. Eklenen metin, sonuçlar sütununda kalın olarak gösterilir.

Eşleştirmeden Sonraki Metni Değiştirme

Değiştirme, $' eşleşen dizeyi eşleştirmeden sonra giriş dizesinin tamamıyla değiştirir. Yani, giriş dizesini eşleştirmeden sonra çoğaltırken, eşleştirilen metni kaldırır. Eşleştirilen metinden önce gelen metin, sonuç dizesinde değiştirilmez. Eşleşme yoksa, değiştirmenin $' hiçbir etkisi yoktur.

Aşağıdaki örnek, giriş dizesindeki bir veya daha fazla ondalık basamak dizisiyle eşleştirmek için normal ifade desenini \d+ kullanır. Değiştirme dizesi $' , bu basamakları eşleşmeyi izleyen metinle değiştirir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "aa1bb2cc3dd4ee5";
      string pattern = @"\d+";
      string substitution = "$'";
      Console.WriteLine("Matches:");
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("   {0} at position {1}", match.Value, match.Index);
      Console.WriteLine("Input string:  {0}", input);
      Console.WriteLine("Output string: " +
                        Regex.Replace(input, pattern, substitution));
   }
}
// The example displays the following output:
//    Matches:
//       1 at position 2
//       2 at position 5
//       3 at position 8
//       4 at position 11
//       5 at position 14
//    Input string:  aa1bb2cc3dd4ee5
//    Output string: aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "aa1bb2cc3dd4ee5"
        Dim pattern As String = "\d+"
        Dim substitution As String = "$'"
        Console.WriteLine("Matches:")
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("   {0} at position {1}", match.Value, match.Index)
        Next
        Console.WriteLine("Input string:  {0}", input)
        Console.WriteLine("Output string: " + _
                          Regex.Replace(input, pattern, substitution))
    End Sub
End Module
' The example displays the following output:
'    Matches:
'       1 at position 2
'       2 at position 5
'       3 at position 8
'       4 at position 11
'       5 at position 14
'    Input string:  aa1bb2cc3dd4ee5
'    Output string: aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee

Bu örnekte, giriş dizesi "aa1bb2cc3dd4ee5" beş eşleşme içerir. Aşağıdaki tabloda, değiştirmenin normal ifade altyapısının $' giriş dizesindeki her eşleşmeyi değiştirmesine nasıl neden olduğu gösterilmektedir. Eklenen metin, sonuçlar sütununda kalın olarak gösterilir.

Yakalanan Son Grubu Değiştirme

Değiştirme, $+ eşleşen dizeyi yakalanan son grupla değiştirir. Yakalanan grup yoksa veya yakalanan son grubun değeri ise String.Empty, değiştirmenin $+ hiçbir etkisi yoktur.

Aşağıdaki örnek, bir dizedeki yinelenen sözcükleri tanımlar ve sözcüğün $+ tek bir oluşumuyla değiştirmek için değiştirme işlemini kullanır. seçeneği RegexOptions.IgnoreCase , büyük/küçük harfe göre farklılık gösteren ancak aksi takdirde aynı olan sözcüklerin yinelenen olarak kabul edilmesini sağlamak için kullanılır.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)\s\1\b";
      string substitution = "$+";
      string input = "The the dog jumped over the fence fence.";
      Console.WriteLine(Regex.Replace(input, pattern, substitution,
                        RegexOptions.IgnoreCase));
   }
}
// The example displays the following output:
//      The dog jumped over the fence.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\w+)\s\1\b"
        Dim substitution As String = "$+"
        Dim input As String = "The the dog jumped over the fence fence."
        Console.WriteLine(Regex.Replace(input, pattern, substitution, _
                                        RegexOptions.IgnoreCase))
    End Sub
End Module
' The example displays the following output:
'      The dog jumped over the fence.

Normal ifade deseni \b(\w+)\s\1\b aşağıdaki tabloda gösterildiği gibi tanımlanır.

Tüm Giriş Dizesini Değiştirme

Değiştirme, $_ eşleşen dizeyi giriş dizesinin tamamıyla değiştirir. Diğer bir deyişle, eşleştirilen metni kaldırır ve eşleştirilen metni içeren tüm dize ile değiştirir.

Aşağıdaki örnekte, giriş dizesindeki bir veya daha fazla ondalık basamak eşleştirilmektedir. Bunları giriş dizesinin $_ tamamıyla değiştirmek için değiştirme işlemini kullanır.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "ABC123DEF456";
      string pattern = @"\d+";
      string substitution = "$_";
      Console.WriteLine("Original string:          {0}", input);
      Console.WriteLine("String with substitution: {0}",
                        Regex.Replace(input, pattern, substitution));
   }
}
// The example displays the following output:
//       Original string:          ABC123DEF456
//       String with substitution: ABCABC123DEF456DEFABC123DEF456

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "ABC123DEF456"
        Dim pattern As String = "\d+"
        Dim substitution As String = "$_"
        Console.WriteLine("Original string:          {0}", input)
        Console.WriteLine("String with substitution: {0}", _
                          Regex.Replace(input, pattern, substitution))
    End Sub
End Module
' The example displays the following output:
'       Original string:          ABC123DEF456
'       String with substitution: ABCABC123DEF456DEFABC123DEF456

Bu örnekte, giriş dizesi "ABC123DEF456" iki eşleşme içerir. Aşağıdaki tabloda, değiştirmenin normal ifade altyapısının $_ giriş dizesindeki her eşleşmeyi değiştirmesine nasıl neden olduğu gösterilmektedir. Eklenen metin, sonuçlar sütununda kalın olarak gösterilir.

Ayrıca bkz.

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